A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-rrc-header.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Lluis Parcerisa <lparcerisa@cttc.cat>
18 * Modified by:
19 * Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
20 * Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
21 */
22
23#include "lte-rrc-header.h"
24
25#include "ns3/log.h"
26
27#include <sstream>
28#include <stdio.h>
29
30#define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331
31#define MAX_EARFCN 262143
32#define MAX_RAT_CAPABILITIES 8
33#define MAX_SI_MESSAGE 32
34#define MAX_SIB 32
35
36#define MAX_REPORT_CONFIG_ID 32
37#define MAX_OBJECT_ID 32
38#define MAX_MEAS_ID 32
39#define MAX_CELL_MEAS 32
40#define MAX_CELL_REPORT 8
41
42#define MAX_SCELL_REPORT 5
43#define MAX_SCELL_CONF 5
44
45namespace ns3
46{
47
48NS_LOG_COMPONENT_DEFINE("RrcHeader");
49
52{
53}
54
57{
58 static TypeId tid = TypeId("ns3::RrcAsn1Header").SetParent<Header>().SetGroupName("Lte");
59 return tid;
60}
61
64{
65 return GetTypeId();
66}
67
68int
70{
71 return m_messageType;
72}
73
74int
75RrcAsn1Header::BandwidthToEnum(uint16_t bandwidth) const
76{
77 int n;
78 switch (bandwidth)
79 {
80 case 6:
81 n = 0;
82 break;
83 case 15:
84 n = 1;
85 break;
86 case 25:
87 n = 2;
88 break;
89 case 50:
90 n = 3;
91 break;
92 case 75:
93 n = 4;
94 break;
95 case 100:
96 n = 5;
97 break;
98 default:
99 NS_FATAL_ERROR("Wrong bandwidth: " << bandwidth);
100 }
101 return n;
102}
103
104uint16_t
106{
107 uint16_t bw;
108 switch (n)
109 {
110 case 0:
111 bw = 6;
112 break;
113 case 1:
114 bw = 15;
115 break;
116 case 2:
117 bw = 25;
118 break;
119 case 3:
120 bw = 50;
121 break;
122 case 4:
123 bw = 75;
124 break;
125 case 5:
126 bw = 100;
127 break;
128 default:
129 NS_FATAL_ERROR("Wrong enum value for bandwidth: " << n);
130 }
131 return bw;
132}
133
134void
135RrcAsn1Header::SerializeDrbToAddModList(std::list<LteRrcSap::DrbToAddMod> drbToAddModList) const
136{
137 // Serialize DRB-ToAddModList sequence-of
138 SerializeSequenceOf(drbToAddModList.size(), MAX_DRB, 1);
139
140 // Serialize the elements in the sequence-of list
141 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin();
142 for (; it != drbToAddModList.end(); it++)
143 {
144 // Serialize DRB-ToAddMod sequence
145 // 5 optional fields. Extension marker is present.
146 std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5>();
147 drbToAddModListOptionalFieldsPresent.set(4, 1); // eps-BearerIdentity present
148 drbToAddModListOptionalFieldsPresent.set(3, 0); // pdcp-Config not present
149 drbToAddModListOptionalFieldsPresent.set(2, 1); // rlc-Config present
150 drbToAddModListOptionalFieldsPresent.set(1, 1); // logicalChannelIdentity present
151 drbToAddModListOptionalFieldsPresent.set(0, 1); // logicalChannelConfig present
152 SerializeSequence(drbToAddModListOptionalFieldsPresent, true);
153
154 // Serialize eps-BearerIdentity::=INTEGER (0..15)
155 SerializeInteger(it->epsBearerIdentity, 0, 15);
156
157 // Serialize drb-Identity ::= INTEGER (1..32)
158 SerializeInteger(it->drbIdentity, 1, 32);
159
160 switch (it->rlcConfig.choice)
161 {
163 // Serialize rlc-Config choice
164 SerializeChoice(4, 1, true);
165
166 // Serialize UL-UM-RLC
167 SerializeSequence(std::bitset<0>(), false);
168 SerializeEnum(2, 0); // sn-FieldLength
169
170 // Serialize DL-UM-RLC
171 SerializeSequence(std::bitset<0>(), false);
172 SerializeEnum(2, 0); // sn-FieldLength
173 SerializeEnum(32, 0); // t-Reordering
174 break;
175
177 // Serialize rlc-Config choice
178 SerializeChoice(4, 2, true);
179
180 // Serialize UL-UM-RLC
181 SerializeSequence(std::bitset<0>(), false);
182 SerializeEnum(2, 0); // sn-FieldLength
183 break;
184
186 // Serialize rlc-Config choice
187 SerializeChoice(4, 3, true);
188
189 // Serialize DL-UM-RLC
190 SerializeSequence(std::bitset<0>(), false);
191 SerializeEnum(2, 0); // sn-FieldLength
192 SerializeEnum(32, 0); // t-Reordering
193 break;
194
196 default:
197 // Serialize rlc-Config choice
198 SerializeChoice(4, 0, true);
199
200 // Serialize UL-AM-RLC
201 SerializeSequence(std::bitset<0>(), false);
202 SerializeEnum(64, 0); // t-PollRetransmit
203 SerializeEnum(8, 0); // pollPDU
204 SerializeEnum(16, 0); // pollByte
205 SerializeEnum(8, 0); // maxRetxThreshold
206
207 // Serialize DL-AM-RLC
208 SerializeSequence(std::bitset<0>(), false);
209 SerializeEnum(32, 0); // t-Reordering
210 SerializeEnum(64, 0); // t-StatusProhibit
211 break;
212 }
213
214 // Serialize logicalChannelIdentity ::=INTEGER (3..10)
215 SerializeInteger(it->logicalChannelIdentity, 3, 10);
216
217 // Serialize logicalChannelConfig
218 SerializeLogicalChannelConfig(it->logicalChannelConfig);
219 }
220}
221
222void
223RrcAsn1Header::SerializeSrbToAddModList(std::list<LteRrcSap::SrbToAddMod> srbToAddModList) const
224{
225 // Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod
226 SerializeSequenceOf(srbToAddModList.size(), 2, 1);
227
228 // Serialize the elements in the sequence-of list
229 std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin();
230 for (; it != srbToAddModList.end(); it++)
231 {
232 // Serialize SRB-ToAddMod sequence
233 // 2 optional fields. Extension marker is present.
234 std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2>();
235 srbToAddModListOptionalFieldsPresent.set(1, 0); // rlc-Config not present
236 srbToAddModListOptionalFieldsPresent.set(0, 1); // logicalChannelConfig present
237 SerializeSequence(srbToAddModListOptionalFieldsPresent, true);
238
239 // Serialize srb-Identity ::= INTEGER (1..2)
240 SerializeInteger(it->srbIdentity, 1, 2);
241
242 // Serialize logicalChannelConfig choice
243 // 2 options, selected option 0 (var "explicitValue", of type LogicalChannelConfig)
244 SerializeChoice(2, 0, false);
245
246 // Serialize LogicalChannelConfig
247 SerializeLogicalChannelConfig(it->logicalChannelConfig);
248 }
249}
250
251void
253 LteRrcSap::LogicalChannelConfig logicalChannelConfig) const
254{
255 // Serialize LogicalChannelConfig sequence
256 // 1 optional field (ul-SpecificParameters), which is present. Extension marker present.
257 SerializeSequence(std::bitset<1>(1), true);
258
259 // Serialize ul-SpecificParameters sequence
260 // 1 optional field (logicalChannelGroup), which is present. No extension marker.
261 SerializeSequence(std::bitset<1>(1), false);
262
263 // Serialize priority ::= INTEGER (1..16)
264 SerializeInteger(logicalChannelConfig.priority, 1, 16);
265
266 // Serialize prioritisedBitRate
267 int prioritizedBitRate;
268 switch (logicalChannelConfig.prioritizedBitRateKbps)
269 {
270 case 0:
271 prioritizedBitRate = 0;
272 break;
273 case 8:
274 prioritizedBitRate = 1;
275 break;
276 case 16:
277 prioritizedBitRate = 2;
278 break;
279 case 32:
280 prioritizedBitRate = 3;
281 break;
282 case 64:
283 prioritizedBitRate = 4;
284 break;
285 case 128:
286 prioritizedBitRate = 5;
287 break;
288 case 256:
289 prioritizedBitRate = 6;
290 break;
291 default:
292 prioritizedBitRate = 7; // Infinity
293 }
294 SerializeEnum(16, prioritizedBitRate);
295
296 // Serialize bucketSizeDuration
297 int bucketSizeDuration;
298 switch (logicalChannelConfig.bucketSizeDurationMs)
299 {
300 case 50:
301 bucketSizeDuration = 0;
302 break;
303 case 100:
304 bucketSizeDuration = 1;
305 break;
306 case 150:
307 bucketSizeDuration = 2;
308 break;
309 case 300:
310 bucketSizeDuration = 3;
311 break;
312 case 500:
313 bucketSizeDuration = 4;
314 break;
315 case 1000:
316 bucketSizeDuration = 5;
317 break;
318 default:
319 bucketSizeDuration = 5;
320 }
321 SerializeEnum(8, bucketSizeDuration);
322
323 // Serialize logicalChannelGroup ::= INTEGER (0..3)
324 SerializeInteger(logicalChannelConfig.logicalChannelGroup, 0, 3);
325}
326
327void
329 LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const
330{
331 // Serialize PhysicalConfigDedicated Sequence
332 std::bitset<10> optionalFieldsPhysicalConfigDedicated;
333 optionalFieldsPhysicalConfigDedicated.set(
334 9,
335 physicalConfigDedicated.havePdschConfigDedicated); // pdsch-ConfigDedicated
336 optionalFieldsPhysicalConfigDedicated.set(8, 0); // pucch-ConfigDedicated not present
337 optionalFieldsPhysicalConfigDedicated.set(7, 0); // pusch-ConfigDedicated not present
338 optionalFieldsPhysicalConfigDedicated.set(6, 0); // uplinkPowerControlDedicated not present
339 optionalFieldsPhysicalConfigDedicated.set(5, 0); // tpc-PDCCH-ConfigPUCCH not present
340 optionalFieldsPhysicalConfigDedicated.set(4, 0); // tpc-PDCCH-ConfigPUSCH not present
341 optionalFieldsPhysicalConfigDedicated.set(3, 0); // cqi-ReportConfig not present
342 optionalFieldsPhysicalConfigDedicated.set(
343 2,
344 physicalConfigDedicated.haveSoundingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated
345 optionalFieldsPhysicalConfigDedicated.set(
346 1,
347 physicalConfigDedicated.haveAntennaInfoDedicated); // antennaInfo
348 optionalFieldsPhysicalConfigDedicated.set(0, 0); // schedulingRequestConfig not present
349 SerializeSequence(optionalFieldsPhysicalConfigDedicated, true);
350
351 if (physicalConfigDedicated.havePdschConfigDedicated)
352 {
353 // Serialize Pdsch-ConfigDedicated Sequence:
354 // 0 optional / default fields, no extension marker.
355 SerializeSequence(std::bitset<0>(), false);
356
357 // Serialize p-a
358 // Assuming the value in the struct is the enum index
359 SerializeEnum(8, physicalConfigDedicated.pdschConfigDedicated.pa);
360
361 // Serialize release
363 }
364
365 if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
366 {
367 // Serialize SoundingRS-UL-ConfigDedicated choice:
368 switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type)
369 {
371 SerializeChoice(2, 0, false);
373 break;
374
376 default:
377 // 2 options, selected: 1 (setup)
378 SerializeChoice(2, 1, false);
379
380 // Serialize setup sequence
381 // 0 optional / default fields, no extension marker.
382 SerializeSequence(std::bitset<0>(), false);
383
384 // Serialize srs-Bandwidth
385 SerializeEnum(4, physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth);
386
387 // Serialize srs-HoppingBandwidth
388 SerializeEnum(4, 0);
389
390 // Serialize freqDomainPosition
391 SerializeInteger(0, 0, 23);
392
393 // Serialize duration
394 SerializeBoolean(false);
395
396 // Serialize srs-ConfigIndex
398 0,
399 1023);
400
401 // Serialize transmissionComb
402 SerializeInteger(0, 0, 1);
403
404 // Serialize cyclicShift
405 SerializeEnum(8, 0);
406
407 break;
408 }
409 }
410
411 if (physicalConfigDedicated.haveAntennaInfoDedicated)
412 {
413 // Serialize antennaInfo choice
414 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
415 SerializeChoice(2, 0, false);
416
417 // Serialize AntennaInfoDedicated sequence
418 // 1 optional parameter, not present. No extension marker.
419 SerializeSequence(std::bitset<1>(0), false);
420
421 // Serialize transmissionMode
422 // Assuming the value in the struct is the enum index
423 SerializeEnum(8, physicalConfigDedicated.antennaInfo.transmissionMode);
424
425 // Serialize ue-TransmitAntennaSelection choice
426 SerializeChoice(2, 0, false);
427
428 // Serialize release
430 }
431}
432
433void
435 LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
436{
437 bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.empty();
438 bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.empty();
439 bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseList.empty();
440
441 // 6 optional fields. Extension marker is present.
442 std::bitset<6> optionalFieldsPresent = std::bitset<6>();
443 optionalFieldsPresent.set(5, isSrbToAddModListPresent); // srb-ToAddModList present
444 optionalFieldsPresent.set(4, isDrbToAddModListPresent); // drb-ToAddModList present
445 optionalFieldsPresent.set(3, isDrbToReleaseListPresent); // drb-ToReleaseList present
446 optionalFieldsPresent.set(2, 0); // mac-MainConfig not present
447 optionalFieldsPresent.set(1, 0); // sps-Config not present
448 optionalFieldsPresent.set(0,
449 (radioResourceConfigDedicated.havePhysicalConfigDedicated) ? 1 : 0);
450 SerializeSequence(optionalFieldsPresent, true);
451
452 // Serialize srbToAddModList
453 if (isSrbToAddModListPresent)
454 {
455 SerializeSrbToAddModList(radioResourceConfigDedicated.srbToAddModList);
456 }
457
458 // Serialize drbToAddModList
459 if (isDrbToAddModListPresent)
460 {
461 SerializeDrbToAddModList(radioResourceConfigDedicated.drbToAddModList);
462 }
463
464 // Serialize drbToReleaseList
465 if (isDrbToReleaseListPresent)
466 {
467 SerializeSequenceOf(radioResourceConfigDedicated.drbToReleaseList.size(), MAX_DRB, 1);
468 std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToReleaseList.begin();
469 for (; it != radioResourceConfigDedicated.drbToReleaseList.end(); it++)
470 {
471 // DRB-Identity ::= INTEGER (1..32)
472 SerializeInteger(*it, 1, 32);
473 }
474 }
475
476 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
477 {
478 SerializePhysicalConfigDedicated(radioResourceConfigDedicated.physicalConfigDedicated);
479 }
480}
481
482void
484 LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const
485{
486 // 3 optional fields, no extension marker.
487 std::bitset<3> sysInfoBlk1Opts;
488 sysInfoBlk1Opts.set(2, 0); // p-Max absent
489 sysInfoBlk1Opts.set(1, 0); // tdd-Config absent
490 sysInfoBlk1Opts.set(0, 0); // nonCriticalExtension absent
491 SerializeSequence(sysInfoBlk1Opts, false);
492
493 // Serialize cellAccessRelatedInfo
494 // 1 optional field (csgIdentity) which is present, no extension marker.
495 SerializeSequence(std::bitset<1>(1), false);
496
497 // Serialize plmn-IdentityList
498 SerializeSequenceOf(1, 6, 1);
499
500 // PLMN-IdentityInfo
501 SerializeSequence(std::bitset<0>(), false);
502
504 systemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity);
505
506 // Serialize trackingAreaCode
507 SerializeBitstring(std::bitset<16>(0));
508 // Serialize cellIdentity
510 std::bitset<28>(systemInformationBlockType1.cellAccessRelatedInfo.cellIdentity));
511 // Serialize cellBarred
512 SerializeEnum(2, 0);
513 // Serialize intraFreqReselection
514 SerializeEnum(2, 0);
515 // Serialize csg-Indication
516 SerializeBoolean(systemInformationBlockType1.cellAccessRelatedInfo.csgIndication);
517 // Serialize csg-Identity
519 std::bitset<27>(systemInformationBlockType1.cellAccessRelatedInfo.csgIdentity));
520
521 // Serialize cellSelectionInfo
522 SerializeSequence(std::bitset<1>(0), false);
523 // Serialize q-RxLevMin
524 SerializeInteger(-50, -70, -22);
525
526 // Serialize freqBandIndicator
527 SerializeInteger(1, 1, 64);
528
529 // Serialize schedulingInfoList
531 // SchedulingInfo
532 SerializeSequence(std::bitset<0>(), false);
533 // si-Periodicity
534 SerializeEnum(7, 0);
535 // sib-MappingInfo
536 SerializeSequenceOf(0, MAX_SIB - 1, 0);
537
538 // Serialize si-WindowLength
539 SerializeEnum(7, 0);
540
541 // Serialize systemInfoValueTag
542 SerializeInteger(0, 0, 31);
543}
544
545void
547 LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const
548{
549 // 9 optional fields. Extension marker yes.
550 std::bitset<9> rrCfgCmmOpts;
551 rrCfgCmmOpts.set(8, 1); // rach-ConfigCommon is present
552 rrCfgCmmOpts.set(7, 0); // pdsch-ConfigCommon not present
553 rrCfgCmmOpts.set(6, 0); // phich-Config not present
554 rrCfgCmmOpts.set(5, 0); // pucch-ConfigCommon not present
555 rrCfgCmmOpts.set(4, 0); // soundingRS-UL-ConfigCommon not present
556 rrCfgCmmOpts.set(3, 0); // uplinkPowerControlCommon not present
557 rrCfgCmmOpts.set(2, 0); // antennaInfoCommon not present
558 rrCfgCmmOpts.set(1, 0); // p-Max not present
559 rrCfgCmmOpts.set(0, 0); // tdd-Config not present
560
561 SerializeSequence(rrCfgCmmOpts, true);
562
563 if (rrCfgCmmOpts[8])
564 {
565 // Serialize RACH-ConfigCommon
566 SerializeRachConfigCommon(radioResourceConfigCommon.rachConfigCommon);
567 }
568
569 // Serialize PRACH-Config
570 // 1 optional, 0 extension marker.
571 SerializeSequence(std::bitset<1>(0), false);
572
573 // Serialize PRACH-Config rootSequenceIndex
574 SerializeInteger(0, 0, 1023);
575
576 // Serialize PUSCH-ConfigCommon
577 SerializeSequence(std::bitset<0>(), false);
578
579 // Serialize pusch-ConfigBasic
580 SerializeSequence(std::bitset<0>(), false);
581 SerializeInteger(1, 1, 4);
582 SerializeEnum(2, 0);
583 SerializeInteger(0, 0, 98);
584 SerializeBoolean(false);
585
586 // Serialize UL-ReferenceSignalsPUSCH
587 SerializeSequence(std::bitset<0>(), false);
588 SerializeBoolean(false);
589 SerializeInteger(0, 0, 29);
590 SerializeBoolean(false);
591 SerializeInteger(4, 0, 7);
592
593 // Serialize UL-CyclicPrefixLength
594 SerializeEnum(2, 0);
595}
596
597void
599 LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const
600{
601 SerializeSequence(std::bitset<0>(0), true);
602
603 // rach-ConfigCommon
604 SerializeRachConfigCommon(radioResourceConfigCommonSib.rachConfigCommon);
605
606 // bcch-Config
607 SerializeSequence(std::bitset<0>(0), false);
608 SerializeEnum(4, 0); // modificationPeriodCoeff
609 // pcch-Config
610 SerializeSequence(std::bitset<0>(0), false);
611 SerializeEnum(4, 0); // defaultPagingCycle
612 SerializeEnum(8, 0); // nB
613 // prach-Config
614 SerializeSequence(std::bitset<1>(0), false);
615 SerializeInteger(0, 0, 1023); // rootSequenceIndex
616 // pdsch-ConfigCommon
617 SerializeSequence(std::bitset<0>(0), false);
618 SerializeInteger(0, -60, 50); // referenceSignalPower
619 SerializeInteger(0, 0, 3); // p-b
620 // pusch-ConfigCommon
621 SerializeSequence(std::bitset<0>(0), false);
622 SerializeSequence(std::bitset<0>(0), false); // pusch-ConfigBasic
623 SerializeInteger(1, 1, 4); // n-SB
624 SerializeEnum(2, 0); // hoppingMode
625 SerializeInteger(0, 0, 98); // pusch-HoppingOffset
626 SerializeBoolean(false); // enable64QAM
627 SerializeSequence(std::bitset<0>(0), false); // UL-ReferenceSignalsPUSCH
628 SerializeBoolean(false); // groupHoppingEnabled
629 SerializeInteger(0, 0, 29); // groupAssignmentPUSCH
630 SerializeBoolean(false); // sequenceHoppingEnabled
631 SerializeInteger(0, 0, 7); // cyclicShift
632 // pucch-ConfigCommon
633 SerializeSequence(std::bitset<0>(0), false);
634 SerializeEnum(3, 0); // deltaPUCCH-Shift
635 SerializeInteger(0, 0, 98); // nRB-CQI
636 SerializeInteger(0, 0, 7); // nCS-AN
637 SerializeInteger(0, 0, 2047); // n1PUCCH-AN
638 // soundingRS-UL-ConfigCommon
639 SerializeChoice(2, 0, false);
640 SerializeNull(); // release
641 // uplinkPowerControlCommon
642 SerializeSequence(std::bitset<0>(0), false);
643 SerializeInteger(0, -126, 24); // p0-NominalPUSCH
644 SerializeEnum(8, 0); // alpha
645 SerializeInteger(-110, -127, -96); // p0-NominalPUCCH
646 SerializeSequence(std::bitset<0>(0), false); // deltaFList-PUCCH
647 SerializeEnum(3, 0); // deltaF-PUCCH-Format1
648 SerializeEnum(3, 0); // deltaF-PUCCH-Format1b
649 SerializeEnum(4, 0); // deltaF-PUCCH-Format2
650 SerializeEnum(3, 0); // deltaF-PUCCH-Format2a
651 SerializeEnum(3, 0); // deltaF-PUCCH-Format2b
652 SerializeInteger(0, -1, 6);
653 // ul-CyclicPrefixLength
654 SerializeEnum(2, 0);
655}
656
657void
659 LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2) const
660{
661 SerializeSequence(std::bitset<2>(0), true);
662
663 // RadioResourceConfigCommonSib
665
666 // ue-TimersAndConstants
667 SerializeSequence(std::bitset<0>(0), true);
668 SerializeEnum(8, 0); // t300
669 SerializeEnum(8, 0); // t301
670 SerializeEnum(7, 0); // t310
671 SerializeEnum(8, 0); // n310
672 SerializeEnum(7, 0); // t311
673 SerializeEnum(8, 0); // n311
674
675 // freqInfo
676 SerializeSequence(std::bitset<2>(3), false);
677 SerializeInteger((int)systemInformationBlockType2.freqInfo.ulCarrierFreq, 0, MAX_EARFCN);
678 SerializeEnum(6, BandwidthToEnum(systemInformationBlockType2.freqInfo.ulBandwidth));
679
680 SerializeInteger(29, 1, 32); // additionalSpectrumEmission
681 // timeAlignmentTimerCommon
682 SerializeEnum(8, 0);
683}
684
685void
687{
688 // Watchdog: if list has 0 elements, set boolean to false
689 if (measResults.measResultListEutra.empty())
690 {
691 measResults.haveMeasResultNeighCells = false;
692 }
693
694 std::bitset<4> measResultOptional;
695 measResultOptional.set(3, measResults.haveMeasResultServFreqList);
696 measResultOptional.set(2, false); // LocationInfo-r10
697 measResultOptional.set(1, false); // MeasResultForECID-r9
698 measResultOptional.set(0, measResults.haveMeasResultNeighCells);
699 SerializeSequence(measResultOptional, true);
700
701 // Serialize measId
702 SerializeInteger(measResults.measId, 1, MAX_MEAS_ID);
703
704 // Serialize measResultPCell sequence
705 SerializeSequence(std::bitset<0>(0), false);
706
707 // Serialize rsrpResult
708 SerializeInteger(measResults.measResultPCell.rsrpResult, 0, 97);
709
710 // Serialize rsrqResult
711 SerializeInteger(measResults.measResultPCell.rsrqResult, 0, 34);
712
713 if (measResults.haveMeasResultNeighCells)
714 {
715 // Serialize Choice = 0 (MeasResultListEUTRA)
716 SerializeChoice(4, 0, false);
717
718 // Serialize measResultNeighCells
720
721 // serialize MeasResultEutra elements in the list
722 std::list<LteRrcSap::MeasResultEutra>::iterator it;
723 for (it = measResults.measResultListEutra.begin();
724 it != measResults.measResultListEutra.end();
725 it++)
726 {
727 SerializeSequence(std::bitset<1>(it->haveCgiInfo), false);
728
729 // Serialize PhysCellId
730 SerializeInteger(it->physCellId, 0, 503);
731
732 // Serialize CgiInfo
733 if (it->haveCgiInfo)
734 {
735 SerializeSequence(std::bitset<1>(it->cgiInfo.plmnIdentityList.size()), false);
736
737 // Serialize cellGlobalId
738 SerializeSequence(std::bitset<0>(0), false);
739 SerializePlmnIdentity(it->cgiInfo.plmnIdentity);
740 SerializeBitstring(std::bitset<28>(it->cgiInfo.cellIdentity));
741
742 // Serialize trackingAreaCode
743 SerializeBitstring(std::bitset<16>(it->cgiInfo.trackingAreaCode));
744
745 // Serialize plmn-IdentityList
746 if (!it->cgiInfo.plmnIdentityList.empty())
747 {
748 SerializeSequenceOf(it->cgiInfo.plmnIdentityList.size(), 5, 1);
749 std::list<uint32_t>::iterator it2;
750 for (it2 = it->cgiInfo.plmnIdentityList.begin();
751 it2 != it->cgiInfo.plmnIdentityList.end();
752 it2++)
753 {
755 }
756 }
757 }
758
759 // Serialize measResult
760 std::bitset<2> measResultFieldsPresent;
761 measResultFieldsPresent[1] = it->haveRsrpResult;
762 measResultFieldsPresent[0] = it->haveRsrqResult;
763 SerializeSequence(measResultFieldsPresent, true);
764
765 if (it->haveRsrpResult)
766 {
767 SerializeInteger(it->rsrpResult, 0, 97);
768 }
769
770 if (it->haveRsrqResult)
771 {
772 SerializeInteger(it->rsrqResult, 0, 34);
773 }
774 }
775 }
776
777 // measResultServFreqList-r10 serialization
778 if (measResults.haveMeasResultServFreqList)
779 {
780 // Serialize measResultServFreqList-r10
782 // serialize MeasResultServFreqList-r10 elements in the list
783 for (const auto& it : measResults.measResultServFreqList)
784 {
785 // Serialize MeasResultServFreq-r10
786 std::bitset<2> measResultServFreqPresent;
787 measResultServFreqPresent[0] = it.haveMeasResultSCell;
788 measResultServFreqPresent[1] = it.haveMeasResultBestNeighCell;
789 SerializeSequence(measResultServFreqPresent, true);
790
791 // Serialize servFreqId-r10
792 SerializeInteger(it.servFreqId, 0, 7);
793
794 if (it.haveMeasResultSCell)
795 {
796 // Serialize rsrpResultSCell-r10
797 SerializeInteger(it.measResultSCell.rsrpResult, 0, 97);
798
799 // Serialize rsrqResultSCell-r10
800 SerializeInteger(it.measResultSCell.rsrqResult, 0, 34);
801 }
802
803 if (it.haveMeasResultBestNeighCell)
804 {
805 // Serialize physCellId-r10
806 SerializeInteger(it.measResultBestNeighCell.physCellId, 0, 503);
807
808 // Serialize rsrpResultNCell-r10
809 SerializeInteger(it.measResultBestNeighCell.rsrpResult, 0, 97);
810
811 // Serialize rsrqResultNCell-r10
812 SerializeInteger(it.measResultBestNeighCell.rsrqResult, 0, 34);
813 }
814
815 NS_ASSERT(!it.haveMeasResultBestNeighCell); // Not implemented
816 }
817 }
818}
819
820void
822{
823 // plmn-Identity sequence, mcc is optional, no extension marker
824 SerializeSequence(std::bitset<1>(0), false);
825
826 // Serialize mnc
827 int nDig = (plmnId > 99) ? 3 : 2;
828
829 SerializeSequenceOf(nDig, 3, 2);
830 for (int i = nDig - 1; i >= 0; i--)
831 {
832 int n = floor(plmnId / pow(10, i));
833 SerializeInteger(n, 0, 9);
834 plmnId -= n * pow(10, i);
835 }
836
837 // cellReservedForOperatorUse
838 SerializeEnum(2, 0);
839}
840
841void
843{
844 // rach-ConfigCommon
845 SerializeSequence(std::bitset<0>(0), true);
846
847 // preambleInfo
848 SerializeSequence(std::bitset<1>(0), false);
849
850 // numberOfRA-Preambles
851 switch (rachConfigCommon.preambleInfo.numberOfRaPreambles)
852 {
853 case 4:
854 SerializeEnum(16, 0);
855 break;
856 case 8:
857 SerializeEnum(16, 1);
858 break;
859 case 12:
860 SerializeEnum(16, 2);
861 break;
862 case 16:
863 SerializeEnum(16, 3);
864 break;
865 case 20:
866 SerializeEnum(16, 4);
867 break;
868 case 24:
869 SerializeEnum(16, 5);
870 break;
871 case 28:
872 SerializeEnum(16, 6);
873 break;
874 case 32:
875 SerializeEnum(16, 7);
876 break;
877 case 36:
878 SerializeEnum(16, 8);
879 break;
880 case 40:
881 SerializeEnum(16, 9);
882 break;
883 case 44:
884 SerializeEnum(16, 10);
885 break;
886 case 48:
887 SerializeEnum(16, 11);
888 break;
889 case 52:
890 SerializeEnum(16, 12);
891 break;
892 case 56:
893 SerializeEnum(16, 13);
894 break;
895 case 60:
896 SerializeEnum(16, 14);
897 break;
898 case 64:
899 SerializeEnum(16, 15);
900 break;
901 default:
902 NS_FATAL_ERROR("Wrong numberOfRA-Preambles value");
903 }
904
905 SerializeSequence(std::bitset<0>(0), false); // powerRampingParameters
906 SerializeEnum(4, 0); // powerRampingStep
907 SerializeEnum(16, 0); // preambleInitialReceivedTargetPower
908 SerializeSequence(std::bitset<0>(0), false); // ra-SupervisionInfo
909
910 // preambleTransMax
911 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax)
912 {
913 case 3:
914 SerializeEnum(11, 0);
915 break;
916 case 4:
917 SerializeEnum(11, 1);
918 break;
919 case 5:
920 SerializeEnum(11, 2);
921 break;
922 case 6:
923 SerializeEnum(11, 3);
924 break;
925 case 7:
926 SerializeEnum(11, 4);
927 break;
928 case 8:
929 SerializeEnum(11, 5);
930 break;
931 case 10:
932 SerializeEnum(11, 6);
933 break;
934 case 20:
935 SerializeEnum(11, 7);
936 break;
937 case 50:
938 SerializeEnum(11, 8);
939 break;
940 case 100:
941 SerializeEnum(11, 9);
942 break;
943 case 200:
944 SerializeEnum(11, 10);
945 break;
946 default:
947 SerializeEnum(11, 0);
948 }
949
950 // ra-ResponseWindowSize
951 switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize)
952 {
953 case 2:
954 SerializeEnum(8, 0);
955 break;
956 case 3:
957 SerializeEnum(8, 1);
958 break;
959 case 4:
960 SerializeEnum(8, 2);
961 break;
962 case 5:
963 SerializeEnum(8, 3);
964 break;
965 case 6:
966 SerializeEnum(8, 4);
967 break;
968 case 7:
969 SerializeEnum(8, 5);
970 break;
971 case 8:
972 SerializeEnum(8, 6);
973 break;
974 case 10:
975 SerializeEnum(8, 7);
976 break;
977 default:
978 SerializeEnum(8, 0);
979 }
980
981 SerializeEnum(8, 0); // mac-ContentionResolutionTimer
982 SerializeInteger(1, 1, 8); // maxHARQ-Msg3Tx
983
984 // connEstFailCount
985 switch (rachConfigCommon.txFailParam.connEstFailCount)
986 {
987 case 1:
988 SerializeEnum(8, 1);
989 break;
990 case 2:
991 SerializeEnum(8, 2);
992 break;
993 case 3:
994 SerializeEnum(8, 3);
995 break;
996 case 4:
997 SerializeEnum(8, 4);
998 break;
999 default:
1000 SerializeEnum(8, 1);
1001 }
1002}
1003
1004void
1006{
1007 switch (qOffsetRange)
1008 {
1009 case -24:
1010 SerializeEnum(31, 0);
1011 break;
1012 case -22:
1013 SerializeEnum(31, 1);
1014 break;
1015 case -20:
1016 SerializeEnum(31, 2);
1017 break;
1018 case -18:
1019 SerializeEnum(31, 3);
1020 break;
1021 case -16:
1022 SerializeEnum(31, 4);
1023 break;
1024 case -14:
1025 SerializeEnum(31, 5);
1026 break;
1027 case -12:
1028 SerializeEnum(31, 6);
1029 break;
1030 case -10:
1031 SerializeEnum(31, 7);
1032 break;
1033 case -8:
1034 SerializeEnum(31, 8);
1035 break;
1036 case -6:
1037 SerializeEnum(31, 9);
1038 break;
1039 case -5:
1040 SerializeEnum(31, 10);
1041 break;
1042 case -4:
1043 SerializeEnum(31, 11);
1044 break;
1045 case -3:
1046 SerializeEnum(31, 12);
1047 break;
1048 case -2:
1049 SerializeEnum(31, 13);
1050 break;
1051 case -1:
1052 SerializeEnum(31, 14);
1053 break;
1054 case 0:
1055 SerializeEnum(31, 15);
1056 break;
1057 case 1:
1058 SerializeEnum(31, 16);
1059 break;
1060 case 2:
1061 SerializeEnum(31, 17);
1062 break;
1063 case 3:
1064 SerializeEnum(31, 18);
1065 break;
1066 case 4:
1067 SerializeEnum(31, 19);
1068 break;
1069 case 5:
1070 SerializeEnum(31, 20);
1071 break;
1072 case 6:
1073 SerializeEnum(31, 21);
1074 break;
1075 case 8:
1076 SerializeEnum(31, 22);
1077 break;
1078 case 10:
1079 SerializeEnum(31, 23);
1080 break;
1081 case 12:
1082 SerializeEnum(31, 24);
1083 break;
1084 case 14:
1085 SerializeEnum(31, 25);
1086 break;
1087 case 16:
1088 SerializeEnum(31, 26);
1089 break;
1090 case 18:
1091 SerializeEnum(31, 27);
1092 break;
1093 case 20:
1094 SerializeEnum(31, 28);
1095 break;
1096 case 22:
1097 SerializeEnum(31, 29);
1098 break;
1099 case 24:
1100 SerializeEnum(31, 30);
1101 break;
1102 default:
1103 SerializeEnum(31, 15);
1104 }
1105}
1106
1107void
1109{
1110 switch (thresholdEutra.choice)
1111 {
1113 SerializeChoice(2, 0, false);
1114 SerializeInteger(thresholdEutra.range, 0, 97);
1115 break;
1117 default:
1118 SerializeChoice(2, 1, false);
1119 SerializeInteger(thresholdEutra.range, 0, 34);
1120 }
1121}
1122
1123void
1125{
1126 // Serialize MeasConfig sequence
1127 // 11 optional fields, extension marker present
1128 std::bitset<11> measConfigOptional;
1129 measConfigOptional.set(10, !measConfig.measObjectToRemoveList.empty());
1130 measConfigOptional.set(9, !measConfig.measObjectToAddModList.empty());
1131 measConfigOptional.set(8, !measConfig.reportConfigToRemoveList.empty());
1132 measConfigOptional.set(7, !measConfig.reportConfigToAddModList.empty());
1133 measConfigOptional.set(6, !measConfig.measIdToRemoveList.empty());
1134 measConfigOptional.set(5, !measConfig.measIdToAddModList.empty());
1135 measConfigOptional.set(4, measConfig.haveQuantityConfig);
1136 measConfigOptional.set(3, measConfig.haveMeasGapConfig);
1137 measConfigOptional.set(2, measConfig.haveSmeasure);
1138 measConfigOptional.set(1, false); // preRegistrationInfoHRPD
1139 measConfigOptional.set(0, measConfig.haveSpeedStatePars);
1140 SerializeSequence(measConfigOptional, true);
1141
1142 if (!measConfig.measObjectToRemoveList.empty())
1143 {
1145 for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList.begin();
1146 it != measConfig.measObjectToRemoveList.end();
1147 it++)
1148 {
1150 }
1151 }
1152
1153 if (!measConfig.measObjectToAddModList.empty())
1154 {
1156 for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it =
1157 measConfig.measObjectToAddModList.begin();
1158 it != measConfig.measObjectToAddModList.end();
1159 it++)
1160 {
1161 SerializeSequence(std::bitset<0>(), false);
1162 SerializeInteger(it->measObjectId, 1, MAX_OBJECT_ID);
1163 SerializeChoice(4, 0, true); // Select MeasObjectEUTRA
1164
1165 // Serialize measObjectEutra
1166 std::bitset<5> measObjOpts;
1167 measObjOpts.set(4, !it->measObjectEutra.cellsToRemoveList.empty());
1168 measObjOpts.set(3, !it->measObjectEutra.cellsToAddModList.empty());
1169 measObjOpts.set(2, !it->measObjectEutra.blackCellsToRemoveList.empty());
1170 measObjOpts.set(1, !it->measObjectEutra.blackCellsToAddModList.empty());
1171 measObjOpts.set(0, it->measObjectEutra.haveCellForWhichToReportCGI);
1172 SerializeSequence(measObjOpts, true);
1173
1174 // Serialize carrierFreq
1175 SerializeInteger(it->measObjectEutra.carrierFreq, 0, MAX_EARFCN);
1176
1177 // Serialize allowedMeasBandwidth
1178 SerializeEnum(6, BandwidthToEnum(it->measObjectEutra.allowedMeasBandwidth));
1179
1180 SerializeBoolean(it->measObjectEutra.presenceAntennaPort1);
1181 SerializeBitstring(std::bitset<2>(it->measObjectEutra.neighCellConfig));
1182 SerializeQoffsetRange(it->measObjectEutra.offsetFreq);
1183
1184 if (!it->measObjectEutra.cellsToRemoveList.empty())
1185 {
1186 SerializeSequenceOf(it->measObjectEutra.cellsToRemoveList.size(), MAX_CELL_MEAS, 1);
1187 for (std::list<uint8_t>::iterator it2 =
1188 it->measObjectEutra.cellsToRemoveList.begin();
1189 it2 != it->measObjectEutra.cellsToRemoveList.end();
1190 it2++)
1191 {
1193 }
1194 }
1195
1196 if (!it->measObjectEutra.cellsToAddModList.empty())
1197 {
1198 SerializeSequenceOf(it->measObjectEutra.cellsToAddModList.size(), MAX_CELL_MEAS, 1);
1199 for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 =
1200 it->measObjectEutra.cellsToAddModList.begin();
1201 it2 != it->measObjectEutra.cellsToAddModList.end();
1202 it2++)
1203 {
1204 SerializeSequence(std::bitset<0>(), false);
1205
1206 // Serialize cellIndex
1207 SerializeInteger(it2->cellIndex, 1, MAX_CELL_MEAS);
1208
1209 // Serialize PhysCellId
1210 SerializeInteger(it2->physCellId, 0, 503);
1211
1212 // Serialize cellIndividualOffset
1213 SerializeQoffsetRange(it2->cellIndividualOffset);
1214 }
1215 }
1216
1217 if (!it->measObjectEutra.blackCellsToRemoveList.empty())
1218 {
1219 SerializeSequenceOf(it->measObjectEutra.blackCellsToRemoveList.size(),
1221 1);
1222 for (std::list<uint8_t>::iterator it2 =
1223 it->measObjectEutra.blackCellsToRemoveList.begin();
1224 it2 != it->measObjectEutra.blackCellsToRemoveList.end();
1225 it2++)
1226 {
1228 }
1229 }
1230
1231 if (!it->measObjectEutra.blackCellsToAddModList.empty())
1232 {
1233 SerializeSequenceOf(it->measObjectEutra.blackCellsToAddModList.size(),
1235 1);
1236 for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 =
1237 it->measObjectEutra.blackCellsToAddModList.begin();
1238 it2 != it->measObjectEutra.blackCellsToAddModList.end();
1239 it2++)
1240 {
1241 SerializeSequence(std::bitset<0>(), false);
1242 SerializeInteger(it2->cellIndex, 1, MAX_CELL_MEAS);
1243
1244 // Serialize PhysCellIdRange
1245 // range optional
1246 std::bitset<1> rangePresent = std::bitset<1>(it2->physCellIdRange.haveRange);
1247 SerializeSequence(rangePresent, false);
1248 SerializeInteger(it2->physCellIdRange.start, 0, 503);
1249 if (it2->physCellIdRange.haveRange)
1250 {
1251 switch (it2->physCellIdRange.range)
1252 {
1253 case 4:
1254 SerializeEnum(16, 0);
1255 break;
1256 case 8:
1257 SerializeEnum(16, 1);
1258 break;
1259 case 12:
1260 SerializeEnum(16, 2);
1261 break;
1262 case 16:
1263 SerializeEnum(16, 3);
1264 break;
1265 case 24:
1266 SerializeEnum(16, 4);
1267 break;
1268 case 32:
1269 SerializeEnum(16, 5);
1270 break;
1271 case 48:
1272 SerializeEnum(16, 6);
1273 break;
1274 case 64:
1275 SerializeEnum(16, 7);
1276 break;
1277 case 84:
1278 SerializeEnum(16, 8);
1279 break;
1280 case 96:
1281 SerializeEnum(16, 9);
1282 break;
1283 case 128:
1284 SerializeEnum(16, 10);
1285 break;
1286 case 168:
1287 SerializeEnum(16, 11);
1288 break;
1289 case 252:
1290 SerializeEnum(16, 12);
1291 break;
1292 case 504:
1293 SerializeEnum(16, 13);
1294 break;
1295 default:
1296 SerializeEnum(16, 0);
1297 }
1298 }
1299 }
1300 }
1301
1302 if (it->measObjectEutra.haveCellForWhichToReportCGI)
1303 {
1304 SerializeInteger(it->measObjectEutra.cellForWhichToReportCGI, 0, 503);
1305 }
1306 }
1307 }
1308
1309 if (!measConfig.reportConfigToRemoveList.empty())
1310 {
1312 for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveList.begin();
1313 it != measConfig.reportConfigToRemoveList.end();
1314 it++)
1315 {
1317 }
1318 }
1319
1320 if (!measConfig.reportConfigToAddModList.empty())
1321 {
1323 for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it =
1324 measConfig.reportConfigToAddModList.begin();
1325 it != measConfig.reportConfigToAddModList.end();
1326 it++)
1327 {
1328 SerializeSequence(std::bitset<0>(), false);
1329 SerializeInteger(it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
1330 SerializeChoice(2, 0, false); // reportConfigEUTRA
1331
1332 // Serialize ReportConfigEUTRA
1333 SerializeSequence(std::bitset<0>(), true);
1334 switch (it->reportConfigEutra.triggerType)
1335 {
1337 SerializeChoice(2, 1, false);
1338 SerializeSequence(std::bitset<0>(), false);
1339 switch (it->reportConfigEutra.purpose)
1340 {
1342 SerializeEnum(2, 1);
1343 break;
1345 default:
1346 SerializeEnum(2, 0);
1347 }
1348 break;
1350 default:
1351 SerializeChoice(2, 0, false);
1352 SerializeSequence(std::bitset<0>(), false);
1353 switch (it->reportConfigEutra.eventId)
1354 {
1356 SerializeChoice(5, 0, true);
1357 SerializeSequence(std::bitset<0>(), false);
1358 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1359 break;
1361 SerializeChoice(5, 1, true);
1362 SerializeSequence(std::bitset<0>(), false);
1363 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1364 break;
1366 SerializeChoice(5, 2, true);
1367 SerializeSequence(std::bitset<0>(), false);
1368 SerializeInteger(it->reportConfigEutra.a3Offset, -30, 30);
1369 SerializeBoolean(it->reportConfigEutra.reportOnLeave);
1370 break;
1372 SerializeChoice(5, 3, true);
1373 SerializeSequence(std::bitset<0>(), false);
1374 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1375 break;
1377 default:
1378 SerializeChoice(5, 4, true);
1379 SerializeSequence(std::bitset<0>(), false);
1380 SerializeThresholdEutra(it->reportConfigEutra.threshold1);
1381 SerializeThresholdEutra(it->reportConfigEutra.threshold2);
1382 }
1383
1384 SerializeInteger(it->reportConfigEutra.hysteresis, 0, 30);
1385
1386 switch (it->reportConfigEutra.timeToTrigger)
1387 {
1388 case 0:
1389 SerializeEnum(16, 0);
1390 break;
1391 case 40:
1392 SerializeEnum(16, 1);
1393 break;
1394 case 64:
1395 SerializeEnum(16, 2);
1396 break;
1397 case 80:
1398 SerializeEnum(16, 3);
1399 break;
1400 case 100:
1401 SerializeEnum(16, 4);
1402 break;
1403 case 128:
1404 SerializeEnum(16, 5);
1405 break;
1406 case 160:
1407 SerializeEnum(16, 6);
1408 break;
1409 case 256:
1410 SerializeEnum(16, 7);
1411 break;
1412 case 320:
1413 SerializeEnum(16, 8);
1414 break;
1415 case 480:
1416 SerializeEnum(16, 9);
1417 break;
1418 case 512:
1419 SerializeEnum(16, 10);
1420 break;
1421 case 640:
1422 SerializeEnum(16, 11);
1423 break;
1424 case 1024:
1425 SerializeEnum(16, 12);
1426 break;
1427 case 1280:
1428 SerializeEnum(16, 13);
1429 break;
1430 case 2560:
1431 SerializeEnum(16, 14);
1432 break;
1433 case 5120:
1434 default:
1435 SerializeEnum(16, 15);
1436 }
1437 } // end trigger type
1438
1439 // Serialize triggerQuantity
1440 if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::RSRP)
1441 {
1442 SerializeEnum(2, 0);
1443 }
1444 else
1445 {
1446 SerializeEnum(2, 1);
1447 }
1448
1449 // Serialize reportQuantity
1450 if (it->reportConfigEutra.reportQuantity ==
1452 {
1453 SerializeEnum(2, 0);
1454 }
1455 else
1456 {
1457 SerializeEnum(2, 1);
1458 }
1459
1460 // Serialize maxReportCells
1461 SerializeInteger(it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT);
1462
1463 // Serialize reportInterval
1464 switch (it->reportConfigEutra.reportInterval)
1465 {
1467 SerializeEnum(16, 0);
1468 break;
1470 SerializeEnum(16, 1);
1471 break;
1473 SerializeEnum(16, 2);
1474 break;
1476 SerializeEnum(16, 3);
1477 break;
1479 SerializeEnum(16, 4);
1480 break;
1482 SerializeEnum(16, 5);
1483 break;
1485 SerializeEnum(16, 6);
1486 break;
1488 SerializeEnum(16, 7);
1489 break;
1491 SerializeEnum(16, 8);
1492 break;
1494 SerializeEnum(16, 9);
1495 break;
1497 SerializeEnum(16, 10);
1498 break;
1500 SerializeEnum(16, 11);
1501 break;
1503 SerializeEnum(16, 12);
1504 break;
1506 SerializeEnum(16, 13);
1507 break;
1509 SerializeEnum(16, 14);
1510 break;
1512 default:
1513 SerializeEnum(16, 15);
1514 }
1515
1516 // Serialize reportAmount
1517 switch (it->reportConfigEutra.reportAmount)
1518 {
1519 case 1:
1520 SerializeEnum(8, 0);
1521 break;
1522 case 2:
1523 SerializeEnum(8, 1);
1524 break;
1525 case 4:
1526 SerializeEnum(8, 2);
1527 break;
1528 case 8:
1529 SerializeEnum(8, 3);
1530 break;
1531 case 16:
1532 SerializeEnum(8, 4);
1533 break;
1534 case 32:
1535 SerializeEnum(8, 5);
1536 break;
1537 case 64:
1538 SerializeEnum(8, 6);
1539 break;
1540 default:
1541 SerializeEnum(8, 7);
1542 }
1543 }
1544 }
1545
1546 if (!measConfig.measIdToRemoveList.empty())
1547 {
1548 SerializeSequenceOf(measConfig.measIdToRemoveList.size(), MAX_MEAS_ID, 1);
1549 for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.begin();
1550 it != measConfig.measIdToRemoveList.end();
1551 it++)
1552 {
1554 }
1555 }
1556
1557 if (!measConfig.measIdToAddModList.empty())
1558 {
1559 SerializeSequenceOf(measConfig.measIdToAddModList.size(), MAX_MEAS_ID, 1);
1560 for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it =
1561 measConfig.measIdToAddModList.begin();
1562 it != measConfig.measIdToAddModList.end();
1563 it++)
1564 {
1565 SerializeInteger(it->measId, 1, MAX_MEAS_ID);
1566 SerializeInteger(it->measObjectId, 1, MAX_OBJECT_ID);
1567 SerializeInteger(it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
1568 }
1569 }
1570
1571 if (measConfig.haveQuantityConfig)
1572 {
1573 // QuantityConfig sequence
1574 // 4 optional fields, only first (EUTRA) present. Extension marker yes.
1575 std::bitset<4> quantityConfigOpts(0);
1576 quantityConfigOpts.set(3, 1);
1577 SerializeSequence(quantityConfigOpts, true);
1578 SerializeSequence(std::bitset<0>(), false);
1579
1580 switch (measConfig.quantityConfig.filterCoefficientRSRP)
1581 {
1582 case 0:
1583 SerializeEnum(16, 0);
1584 break;
1585 case 1:
1586 SerializeEnum(16, 1);
1587 break;
1588 case 2:
1589 SerializeEnum(16, 2);
1590 break;
1591 case 3:
1592 SerializeEnum(16, 3);
1593 break;
1594 case 4:
1595 SerializeEnum(16, 4);
1596 break;
1597 case 5:
1598 SerializeEnum(16, 5);
1599 break;
1600 case 6:
1601 SerializeEnum(16, 6);
1602 break;
1603 case 7:
1604 SerializeEnum(16, 7);
1605 break;
1606 case 8:
1607 SerializeEnum(16, 8);
1608 break;
1609 case 9:
1610 SerializeEnum(16, 9);
1611 break;
1612 case 11:
1613 SerializeEnum(16, 10);
1614 break;
1615 case 13:
1616 SerializeEnum(16, 11);
1617 break;
1618 case 15:
1619 SerializeEnum(16, 12);
1620 break;
1621 case 17:
1622 SerializeEnum(16, 13);
1623 break;
1624 case 19:
1625 SerializeEnum(16, 14);
1626 break;
1627 default:
1628 SerializeEnum(16, 4);
1629 }
1630
1631 switch (measConfig.quantityConfig.filterCoefficientRSRQ)
1632 {
1633 case 0:
1634 SerializeEnum(16, 0);
1635 break;
1636 case 1:
1637 SerializeEnum(16, 1);
1638 break;
1639 case 2:
1640 SerializeEnum(16, 2);
1641 break;
1642 case 3:
1643 SerializeEnum(16, 3);
1644 break;
1645 case 4:
1646 SerializeEnum(16, 4);
1647 break;
1648 case 5:
1649 SerializeEnum(16, 5);
1650 break;
1651 case 6:
1652 SerializeEnum(16, 6);
1653 break;
1654 case 7:
1655 SerializeEnum(16, 7);
1656 break;
1657 case 8:
1658 SerializeEnum(16, 8);
1659 break;
1660 case 9:
1661 SerializeEnum(16, 9);
1662 break;
1663 case 11:
1664 SerializeEnum(16, 10);
1665 break;
1666 case 13:
1667 SerializeEnum(16, 11);
1668 break;
1669 case 15:
1670 SerializeEnum(16, 12);
1671 break;
1672 case 17:
1673 SerializeEnum(16, 13);
1674 break;
1675 case 19:
1676 SerializeEnum(16, 14);
1677 break;
1678 default:
1679 SerializeEnum(16, 4);
1680 }
1681 }
1682
1683 if (measConfig.haveMeasGapConfig)
1684 {
1685 switch (measConfig.measGapConfig.type)
1686 {
1688 SerializeChoice(2, 0, false);
1689 SerializeNull();
1690 break;
1692 default:
1693 SerializeChoice(2, 1, false);
1694 SerializeSequence(std::bitset<0>(), false);
1695 switch (measConfig.measGapConfig.gapOffsetChoice)
1696 {
1698 SerializeChoice(2, 0, true);
1700 break;
1702 default:
1703 SerializeChoice(2, 1, true);
1705 }
1706 }
1707 }
1708
1709 if (measConfig.haveSmeasure)
1710 {
1711 SerializeInteger(measConfig.sMeasure, 0, 97);
1712 }
1713
1714 // ...Here preRegistrationInfoHRPD would be serialized
1715
1716 if (measConfig.haveSpeedStatePars)
1717 {
1718 switch (measConfig.speedStatePars.type)
1719 {
1721 SerializeChoice(2, 0, false);
1722 SerializeNull();
1723 break;
1725 default:
1726 SerializeChoice(2, 1, false);
1727 SerializeSequence(std::bitset<0>(), false);
1729 {
1730 case 30:
1731 SerializeEnum(8, 0);
1732 break;
1733 case 60:
1734 SerializeEnum(8, 1);
1735 break;
1736 case 120:
1737 SerializeEnum(8, 2);
1738 break;
1739 case 180:
1740 SerializeEnum(8, 3);
1741 break;
1742 case 240:
1743 SerializeEnum(8, 4);
1744 break;
1745 default:
1746 SerializeEnum(8, 5);
1747 break;
1748 }
1749
1751 {
1752 case 30:
1753 SerializeEnum(8, 0);
1754 break;
1755 case 60:
1756 SerializeEnum(8, 1);
1757 break;
1758 case 120:
1759 SerializeEnum(8, 2);
1760 break;
1761 case 180:
1762 SerializeEnum(8, 3);
1763 break;
1764 case 240:
1765 SerializeEnum(8, 4);
1766 break;
1767 default:
1768 SerializeEnum(8, 5);
1769 break;
1770 }
1771
1773 1,
1774 16);
1776 1,
1777 16);
1778
1779 SerializeSequence(std::bitset<0>(), false);
1780 switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium)
1781 {
1782 case 25:
1783 SerializeEnum(4, 0);
1784 break;
1785 case 50:
1786 SerializeEnum(4, 1);
1787 break;
1788 case 75:
1789 SerializeEnum(4, 2);
1790 break;
1791 case 100:
1792 default:
1793 SerializeEnum(4, 3);
1794 }
1795
1796 switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh)
1797 {
1798 case 25:
1799 SerializeEnum(4, 0);
1800 break;
1801 case 50:
1802 SerializeEnum(4, 1);
1803 break;
1804 case 75:
1805 SerializeEnum(4, 2);
1806 break;
1807 case 100:
1808 default:
1809 SerializeEnum(4, 3);
1810 }
1811 }
1812 }
1813}
1814
1815void
1817 LteRrcSap::NonCriticalExtensionConfiguration nonCriticalExtension) const
1818{
1819 // 3 optional fields. Extension marker not present.
1820 std::bitset<3> noncriticalExtension_v1020;
1821 noncriticalExtension_v1020.set(
1822 2,
1823 !nonCriticalExtension.sCellToReleaseList.empty()); // sCellToReleaseList-r10
1824 noncriticalExtension_v1020.set(
1825 1,
1826 !nonCriticalExtension.sCellToAddModList.empty()); // sCellToAddModList-r10
1827 noncriticalExtension_v1020.set(
1828 0,
1829 0); // No nonCriticalExtension RRCConnectionReconfiguration-v1130-IEs
1830 SerializeSequence(noncriticalExtension_v1020, false);
1831
1832 if (!nonCriticalExtension.sCellToReleaseList.empty())
1833 {
1834 SerializeSequenceOf(nonCriticalExtension.sCellToReleaseList.size(), MAX_OBJECT_ID, 1);
1835 for (uint8_t sCellIndex : nonCriticalExtension.sCellToReleaseList)
1836 {
1837 SerializeInteger(sCellIndex, 1, 7); // sCellIndex-r10
1838 }
1839 }
1840
1841 if (!nonCriticalExtension.sCellToAddModList.empty())
1842 {
1843 SerializeSequenceOf(nonCriticalExtension.sCellToAddModList.size(), MAX_OBJECT_ID, 1);
1844 for (auto& it : nonCriticalExtension.sCellToAddModList)
1845 {
1846 std::bitset<4> sCellToAddMod_r10;
1847 sCellToAddMod_r10.set(3, 1); // sCellIndex
1848 sCellToAddMod_r10.set(2, 1); // CellIdentification
1849 sCellToAddMod_r10.set(1, 1); // RadioResourceConfigCommonSCell
1850 sCellToAddMod_r10.set(
1851 0,
1852 it.haveRadioResourceConfigDedicatedSCell); // No nonCriticalExtension RRC
1853 SerializeSequence(sCellToAddMod_r10, false);
1854 SerializeInteger(it.sCellIndex, 1, 7); // sCellIndex-r10
1855
1856 // Serialize CellIdentification
1857 std::bitset<2> cellIdentification_r10;
1858 cellIdentification_r10.set(1, 1); // phyCellId-r10
1859 cellIdentification_r10.set(0, 1); // dl-CarrierFreq-r10
1860 SerializeSequence(cellIdentification_r10, false);
1861
1862 SerializeInteger(it.cellIdentification.physCellId, 1, 65536);
1863 SerializeInteger(it.cellIdentification.dlCarrierFreq, 1, MAX_EARFCN);
1864
1865 // Serialize RadioResourceConfigCommonSCell
1866 SerializeRadioResourceConfigCommonSCell(it.radioResourceConfigCommonSCell);
1867
1868 if (it.haveRadioResourceConfigDedicatedSCell)
1869 {
1870 // Serialize RadioResourceConfigDedicatedSCell
1871 SerializeRadioResourceDedicatedSCell(it.radioResourceConfigDedicatedSCell);
1872 }
1873 }
1874 }
1875}
1876
1877void
1880{
1881 // 2 optional fields. Extension marker not present.
1882 std::bitset<2> radioResourceConfigCommonSCell_r10;
1883 radioResourceConfigCommonSCell_r10.set(1, rrccsc.haveNonUlConfiguration); // NonUlConfiguration
1884 radioResourceConfigCommonSCell_r10.set(0, rrccsc.haveUlConfiguration); // UlConfiguration
1885 SerializeSequence(radioResourceConfigCommonSCell_r10, false);
1886
1887 if (rrccsc.haveNonUlConfiguration)
1888 {
1889 // 5 optional fields. Extension marker not present.
1890 std::bitset<5> nonUlConfiguration_r10;
1891 nonUlConfiguration_r10.set(4, 1); // Dl- bandwidth --> convert in enum
1892 nonUlConfiguration_r10.set(3, 1); // AntennaInfoCommon-r10
1893 nonUlConfiguration_r10.set(2, 0); // phich-Config-r10 Not Implemented
1894 nonUlConfiguration_r10.set(1, 1); // pdschConfigCommon
1895 nonUlConfiguration_r10.set(0, 0); // Tdd-Config-r10 Not Implemented
1896 SerializeSequence(nonUlConfiguration_r10, false);
1897
1899
1900 std::bitset<1> antennaInfoCommon_r10;
1901 antennaInfoCommon_r10.set(0, 1);
1902 SerializeSequence(antennaInfoCommon_r10, false);
1904
1905 std::bitset<2> pdschConfigCommon_r10;
1906 pdschConfigCommon_r10.set(1, 1);
1907 pdschConfigCommon_r10.set(0, 1);
1908 SerializeSequence(pdschConfigCommon_r10, false);
1909
1912 }
1913 if (rrccsc.haveUlConfiguration)
1914 {
1915 // Serialize Ul Configuration
1916 // 7 optional fields. Extension marker present.
1917 std::bitset<7> UlConfiguration_r10;
1918 UlConfiguration_r10.set(6, 1); // ul-Configuration-r10
1919 UlConfiguration_r10.set(5, 0); // p-Max-r10 Not Implemented
1920 UlConfiguration_r10.set(4, 1); // uplinkPowerControlCommonSCell-r10
1921 UlConfiguration_r10.set(3, 0); // soundingRS-UL-ConfigCommon-r10
1922 UlConfiguration_r10.set(2, 0); // ul-CyclicPrefixLength-r10
1923 UlConfiguration_r10.set(1, 1); // prach-ConfigSCell-r10
1924 UlConfiguration_r10.set(0, 0); // pusch-ConfigCommon-r10 Not Implemented
1925 SerializeSequence(UlConfiguration_r10, true);
1926
1927 // Serialize ulFreqInfo
1928 std::bitset<3> FreqInfo_r10;
1929 FreqInfo_r10.set(2, 1); // ulCarrierFreq
1930 FreqInfo_r10.set(1, 1); // UlBandwidth
1931 FreqInfo_r10.set(0, 0); // additionalSpectrumEmissionSCell-r10 Not Implemented
1932 SerializeSequence(FreqInfo_r10, false);
1933
1936
1937 // Serialize UlPowerControlCommonSCell
1938 std::bitset<2> UlPowerControlCommonSCell_r10;
1939 UlPowerControlCommonSCell_r10.set(1, 0); // p0-NominalPUSCH-r10 Not Implemented
1940 UlPowerControlCommonSCell_r10.set(0, 1); // alpha
1941 SerializeSequence(UlPowerControlCommonSCell_r10, false);
1942
1944
1945 // Serialize soundingRs-UlConfigCommon
1946 // Not Implemented
1947
1948 // Serialize PrachConfigSCell
1949 std::bitset<1> prachConfigSCell_r10;
1950 prachConfigSCell_r10.set(0, 1);
1951 SerializeSequence(prachConfigSCell_r10, false);
1953 }
1954}
1955
1956void
1959{
1960 // Serialize RadioResourceConfigDedicatedSCell
1961 std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
1962 RadioResourceConfigDedicatedSCell_r10.set(0, 1);
1963 SerializeSequence(RadioResourceConfigDedicatedSCell_r10, false);
1964
1967}
1968
1969void
1972{
1973 std::bitset<2> pcdscOpt;
1974 pcdscOpt.set(1, pcdsc.haveNonUlConfiguration);
1975 pcdscOpt.set(0, pcdsc.haveUlConfiguration);
1976 SerializeSequence(pcdscOpt, true);
1977
1978 if (pcdsc.haveNonUlConfiguration)
1979 {
1980 // Serialize NonUl configuration
1981 std::bitset<4> nulOpt;
1982 nulOpt.set(3, pcdsc.haveAntennaInfoDedicated);
1983 nulOpt.set(2, 0); // crossCarrierSchedulingConfig-r10 Not Implemented
1984 nulOpt.set(1, 0); // csi-RS-Config-r10 Not Implemented
1985 nulOpt.set(0, pcdsc.havePdschConfigDedicated); // pdsch-ConfigDedicated-r10
1986 SerializeSequence(nulOpt, false);
1987
1988 if (pcdsc.haveAntennaInfoDedicated)
1989 {
1990 // Serialize antennaInfo choice
1991 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
1992 SerializeChoice(2, 0, false);
1993
1994 // Serialize AntennaInfoDedicated sequence
1995 // 1 optional parameter, not present. No extension marker.
1996 SerializeSequence(std::bitset<1>(0), false);
1997
1998 // Serialize transmissionMode
1999 // Assuming the value in the struct is the enum index
2001
2002 // Serialize ue-TransmitAntennaSelection choice
2003 SerializeChoice(2, 0, false);
2004
2005 // Serialize release
2006 SerializeNull();
2007 }
2008 if (pcdsc.havePdschConfigDedicated)
2009 {
2010 // Serialize Pdsch-ConfigDedicated Sequence:
2011 // 0 optional / default fields, no extension marker.
2012 SerializeSequence(std::bitset<0>(), false);
2013
2014 // Serialize p-a
2015 // Assuming the value in the struct is the enum index
2017
2018 // Serialize release
2019 SerializeNull();
2020 }
2021 }
2022 if (pcdsc.haveUlConfiguration)
2023 {
2024 // Serialize Ul Configuration
2025 std::bitset<7> ulOpt;
2026 ulOpt.set(6, pcdsc.haveAntennaInfoUlDedicated); // antennaInfoUL-r10
2027 ulOpt.set(5, 0); // pusch-ConfigDedicatedSCell-r10 not present
2028 ulOpt.set(4, 0); // uplinkPowerControlDedicatedSCell-r10 not present
2029 ulOpt.set(3, 0); // cqi-ReportConfigSCell-r10 not present
2030 ulOpt.set(2, pcdsc.haveSoundingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated-r10
2031 ulOpt.set(1, 0); // soundingRS-UL-ConfigDedicated-v1020 not present
2032 ulOpt.set(0, 0); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present
2033 SerializeSequence(ulOpt, false);
2034
2036 {
2037 // Serialize antennaInfo choice
2038 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")
2039 SerializeChoice(2, 0, false);
2040
2041 // Serialize AntennaInfoDedicated sequence
2042 // 1 optional parameter, not present. No extension marker.
2043 SerializeSequence(std::bitset<1>(0), false);
2044
2045 // Serialize transmissionMode
2046 // Assuming the value in the struct is the enum index
2048
2049 // Serialize ue-TransmitAntennaSelection choice
2050 SerializeChoice(2, 0, false);
2051
2052 // Serialize release
2053 SerializeNull();
2054 }
2056 {
2057 // Serialize SoundingRS-UL-ConfigDedicated choice:
2058 switch (pcdsc.soundingRsUlConfigDedicated.type)
2059 {
2061 SerializeChoice(2, 0, false);
2062 SerializeNull();
2063 break;
2064
2066 default:
2067 // 2 options, selected: 1 (setup)
2068 SerializeChoice(2, 1, false);
2069
2070 // Serialize setup sequence
2071 // 0 optional / default fields, no extension marker.
2072 SerializeSequence(std::bitset<0>(), false);
2073
2074 // Serialize srs-Bandwidth
2076
2077 // Serialize srs-HoppingBandwidth
2078 SerializeEnum(4, 0);
2079
2080 // Serialize freqDomainPosition
2081 SerializeInteger(0, 0, 23);
2082
2083 // Serialize duration
2084 SerializeBoolean(false);
2085
2086 // Serialize srs-ConfigIndex
2088
2089 // Serialize transmissionComb
2090 SerializeInteger(0, 0, 1);
2091
2092 // Serialize cyclicShift
2093 SerializeEnum(8, 0);
2094
2095 break;
2096 }
2097 }
2098 }
2099}
2100
2103 Buffer::Iterator bIterator)
2104{
2105 int thresholdEutraChoice;
2106 int range;
2107 bIterator = DeserializeChoice(2, false, &thresholdEutraChoice, bIterator);
2108
2109 switch (thresholdEutraChoice)
2110 {
2111 case 0:
2113 bIterator = DeserializeInteger(&range, 0, 97, bIterator);
2114 thresholdEutra->range = range;
2115 break;
2116 case 1:
2117 default:
2119 bIterator = DeserializeInteger(&range, 0, 34, bIterator);
2120 thresholdEutra->range = range;
2121 }
2122
2123 return bIterator;
2124}
2125
2128{
2129 int n;
2130 bIterator = DeserializeEnum(31, &n, bIterator);
2131 switch (n)
2132 {
2133 case 0:
2134 *qOffsetRange = -24;
2135 break;
2136 case 1:
2137 *qOffsetRange = -22;
2138 break;
2139 case 2:
2140 *qOffsetRange = -20;
2141 break;
2142 case 3:
2143 *qOffsetRange = -18;
2144 break;
2145 case 4:
2146 *qOffsetRange = -16;
2147 break;
2148 case 5:
2149 *qOffsetRange = -14;
2150 break;
2151 case 6:
2152 *qOffsetRange = -12;
2153 break;
2154 case 7:
2155 *qOffsetRange = -10;
2156 break;
2157 case 8:
2158 *qOffsetRange = -8;
2159 break;
2160 case 9:
2161 *qOffsetRange = -6;
2162 break;
2163 case 10:
2164 *qOffsetRange = -5;
2165 break;
2166 case 11:
2167 *qOffsetRange = -4;
2168 break;
2169 case 12:
2170 *qOffsetRange = -3;
2171 break;
2172 case 13:
2173 *qOffsetRange = -2;
2174 break;
2175 case 14:
2176 *qOffsetRange = -1;
2177 break;
2178 case 15:
2179 *qOffsetRange = 0;
2180 break;
2181 case 16:
2182 *qOffsetRange = 1;
2183 break;
2184 case 17:
2185 *qOffsetRange = 2;
2186 break;
2187 case 18:
2188 *qOffsetRange = 3;
2189 break;
2190 case 19:
2191 *qOffsetRange = 4;
2192 break;
2193 case 20:
2194 *qOffsetRange = 5;
2195 break;
2196 case 21:
2197 *qOffsetRange = 6;
2198 break;
2199 case 22:
2200 *qOffsetRange = 8;
2201 break;
2202 case 23:
2203 *qOffsetRange = 10;
2204 break;
2205 case 24:
2206 *qOffsetRange = 12;
2207 break;
2208 case 25:
2209 *qOffsetRange = 14;
2210 break;
2211 case 26:
2212 *qOffsetRange = 16;
2213 break;
2214 case 27:
2215 *qOffsetRange = 18;
2216 break;
2217 case 28:
2218 *qOffsetRange = 20;
2219 break;
2220 case 29:
2221 *qOffsetRange = 22;
2222 break;
2223 case 30:
2224 default:
2225 *qOffsetRange = 24;
2226 }
2227 return bIterator;
2228}
2229
2232 LteRrcSap::RadioResourceConfigDedicated* radioResourceConfigDedicated,
2233 Buffer::Iterator bIterator)
2234{
2235 // Deserialize RadioResourceConfigDedicated sequence
2236 std::bitset<6> optionalFieldsPresent = std::bitset<6>();
2237 bIterator = DeserializeSequence(&optionalFieldsPresent, true, bIterator);
2238
2239 if (optionalFieldsPresent[5])
2240 {
2241 // Deserialize srb-ToAddModList
2242 bIterator =
2243 DeserializeSrbToAddModList(&(radioResourceConfigDedicated->srbToAddModList), bIterator);
2244 }
2245
2246 if (optionalFieldsPresent[4])
2247 {
2248 // Deserialize drb-ToAddModList
2249 bIterator =
2250 DeserializeDrbToAddModList(&(radioResourceConfigDedicated->drbToAddModList), bIterator);
2251 }
2252
2253 if (optionalFieldsPresent[3])
2254 {
2255 // Deserialize drb-ToReleaseList
2256 int n;
2257 int val;
2258 bIterator = DeserializeSequenceOf(&n, MAX_DRB, 1, bIterator);
2259 for (int i = 0; i < n; i++)
2260 {
2261 bIterator = DeserializeInteger(&val, 1, 32, bIterator);
2262 radioResourceConfigDedicated->drbToReleaseList.push_back(val);
2263 }
2264 }
2265
2266 if (optionalFieldsPresent[2])
2267 {
2268 // Deserialize mac-MainConfig
2269 // ...
2270 }
2271
2272 if (optionalFieldsPresent[1])
2273 {
2274 // Deserialize sps-Config
2275 // ...
2276 }
2277
2278 radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPresent[0];
2279 if (optionalFieldsPresent[0])
2280 {
2281 // Deserialize physicalConfigDedicated
2283 &radioResourceConfigDedicated->physicalConfigDedicated,
2284 bIterator);
2285 }
2286
2287 return bIterator;
2288}
2289
2291RrcAsn1Header::DeserializeSrbToAddModList(std::list<LteRrcSap::SrbToAddMod>* srbToAddModList,
2292 Buffer::Iterator bIterator)
2293{
2294 int numElems;
2295 bIterator = DeserializeSequenceOf(&numElems, 2, 1, bIterator);
2296
2297 srbToAddModList->clear();
2298
2299 // Deserialize SRB-ToAddMod elements
2300 for (int i = 0; i < numElems; i++)
2301 {
2302 LteRrcSap::SrbToAddMod srbToAddMod;
2303 // Deserialize SRB-ToAddMod sequence
2304 // 2 optional fields, extension marker present
2305 std::bitset<2> optionalFields;
2306 bIterator = DeserializeSequence(&optionalFields, true, bIterator);
2307
2308 // Deserialize srbIdentity
2309 int n;
2310 bIterator = DeserializeInteger(&n, 1, 2, bIterator);
2311 srbToAddMod.srbIdentity = n;
2312
2313 if (optionalFields[1])
2314 {
2315 // Deserialize rlcConfig choice
2316 // ...
2317 }
2318
2319 if (optionalFields[0])
2320 {
2321 // Deserialize logicalChannelConfig choice
2322 int sel;
2323 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2324
2325 // Deserialize logicalChannelConfig defaultValue
2326 if (sel == 1)
2327 {
2328 bIterator = DeserializeNull(bIterator);
2329 }
2330
2331 // Deserialize logicalChannelConfig explicitValue
2332 else if (sel == 0)
2333 {
2334 bIterator =
2336 }
2337 }
2338 srbToAddModList->insert(srbToAddModList->end(), srbToAddMod);
2339 }
2340
2341 return bIterator;
2342}
2343
2345RrcAsn1Header::DeserializeDrbToAddModList(std::list<LteRrcSap::DrbToAddMod>* drbToAddModList,
2346 Buffer::Iterator bIterator)
2347{
2348 int n;
2349 int val;
2350 bIterator = DeserializeSequenceOf(&n, MAX_DRB, 1, bIterator);
2351
2352 drbToAddModList->clear();
2353
2354 for (int i = 0; i < n; i++)
2355 {
2356 LteRrcSap::DrbToAddMod drbToAddMod;
2357
2358 std::bitset<5> optionalFields;
2359 bIterator = DeserializeSequence(&optionalFields, true, bIterator);
2360
2361 if (optionalFields[4])
2362 {
2363 // Deserialize epsBearerIdentity
2364 bIterator = DeserializeInteger(&val, 0, 15, bIterator);
2365 drbToAddMod.epsBearerIdentity = val;
2366 }
2367
2368 bIterator = DeserializeInteger(&val, 1, 32, bIterator);
2369 drbToAddMod.drbIdentity = val;
2370
2371 if (optionalFields[3])
2372 {
2373 // Deserialize pdcp-Config
2374 // ...
2375 }
2376
2377 if (optionalFields[2])
2378 {
2379 // Deserialize RLC-Config
2380 int chosen;
2381 bIterator = DeserializeChoice(4, true, &chosen, bIterator);
2382
2383 int sel;
2384 std::bitset<0> bitset0;
2385 switch (chosen)
2386 {
2387 case 0:
2389
2390 // Deserialize UL-AM-RLC
2391 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2392 bIterator = DeserializeEnum(64, &sel, bIterator); // t-PollRetransmit
2393 bIterator = DeserializeEnum(8, &sel, bIterator); // pollPDU
2394 bIterator = DeserializeEnum(16, &sel, bIterator); // pollByte
2395 bIterator = DeserializeEnum(8, &sel, bIterator); // maxRetxThreshold
2396
2397 // Deserialize DL-AM-RLC
2398 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2399 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2400 bIterator = DeserializeEnum(64, &sel, bIterator); // t-StatusProhibit
2401 break;
2402
2403 case 1:
2405
2406 // Deserialize UL-UM-RLC
2407 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2408 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2409
2410 // Deserialize DL-UM-RLC
2411 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2412 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2413 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2414 break;
2415
2416 case 2:
2418
2419 // Deserialize UL-UM-RLC
2420 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2421 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2422 break;
2423
2424 case 3:
2426
2427 // Deserialize DL-UM-RLC
2428 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2429 bIterator = DeserializeEnum(2, &sel, bIterator); // sn-FieldLength
2430 bIterator = DeserializeEnum(32, &sel, bIterator); // t-Reordering
2431 break;
2432 }
2433 }
2434
2435 if (optionalFields[1])
2436 {
2437 bIterator = DeserializeInteger(&val, 3, 10, bIterator);
2438 drbToAddMod.logicalChannelIdentity = val;
2439 }
2440
2441 if (optionalFields[0])
2442 {
2443 bIterator =
2445 }
2446
2447 drbToAddModList->insert(drbToAddModList->end(), drbToAddMod);
2448 }
2449 return bIterator;
2450}
2451
2454 LteRrcSap::LogicalChannelConfig* logicalChannelConfig,
2455 Buffer::Iterator bIterator)
2456{
2457 int n;
2458
2459 // Deserialize LogicalChannelConfig sequence
2460 // 1 optional field, extension marker is present.
2461 std::bitset<1> bitset1;
2462 bIterator = DeserializeSequence(&bitset1, true, bIterator);
2463
2464 if (bitset1[0])
2465 {
2466 // Deserialize ul-SpecificParameters sequence
2467 bIterator = DeserializeSequence(&bitset1, false, bIterator);
2468
2469 // Deserialize priority
2470 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
2471 logicalChannelConfig->priority = n;
2472
2473 // Deserialize prioritisedBitRate
2474 bIterator = DeserializeEnum(16, &n, bIterator);
2475 uint16_t prioritizedBitRateKbps;
2476
2477 switch (n)
2478 {
2479 case 0:
2480 prioritizedBitRateKbps = 0;
2481 break;
2482 case 1:
2483 prioritizedBitRateKbps = 8;
2484 break;
2485 case 2:
2486 prioritizedBitRateKbps = 16;
2487 break;
2488 case 3:
2489 prioritizedBitRateKbps = 32;
2490 break;
2491 case 4:
2492 prioritizedBitRateKbps = 64;
2493 break;
2494 case 5:
2495 prioritizedBitRateKbps = 128;
2496 break;
2497 case 6:
2498 prioritizedBitRateKbps = 256;
2499 break;
2500 case 7:
2501 prioritizedBitRateKbps = 10000;
2502 break;
2503 default:
2504 prioritizedBitRateKbps = 10000;
2505 }
2506 logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps;
2507
2508 // Deserialize bucketSizeDuration
2509 bIterator = DeserializeEnum(8, &n, bIterator);
2510 uint16_t bucketSizeDurationMs;
2511 switch (n)
2512 {
2513 case 0:
2514 bucketSizeDurationMs = 50;
2515 break;
2516 case 1:
2517 bucketSizeDurationMs = 100;
2518 break;
2519 case 2:
2520 bucketSizeDurationMs = 150;
2521 break;
2522 case 3:
2523 bucketSizeDurationMs = 300;
2524 break;
2525 case 4:
2526 bucketSizeDurationMs = 500;
2527 break;
2528 case 5:
2529 bucketSizeDurationMs = 1000;
2530 break;
2531 default:
2532 bucketSizeDurationMs = 1000;
2533 }
2534 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs;
2535
2536 if (bitset1[0])
2537 {
2538 // Deserialize logicalChannelGroup
2539 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
2540 logicalChannelConfig->logicalChannelGroup = n;
2541 }
2542 }
2543 return bIterator;
2544}
2545
2548 LteRrcSap::PhysicalConfigDedicated* physicalConfigDedicated,
2549 Buffer::Iterator bIterator)
2550{
2551 std::bitset<10> optionalFieldPresent;
2552 bIterator = DeserializeSequence(&optionalFieldPresent, true, bIterator);
2553
2554 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9];
2555 if (optionalFieldPresent[9])
2556 {
2557 // Deserialize pdsch-ConfigDedicated
2558 std::bitset<0> bitset0;
2559 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2560
2561 int slct;
2562
2563 // Deserialize p-a
2564 bIterator = DeserializeEnum(8, &slct, bIterator);
2565 physicalConfigDedicated->pdschConfigDedicated.pa = slct;
2566
2567 bIterator = DeserializeNull(bIterator);
2568 }
2569 if (optionalFieldPresent[8])
2570 {
2571 // Deserialize pucch-ConfigDedicated
2572 // ...
2573 }
2574 if (optionalFieldPresent[7])
2575 {
2576 // Deserialize pusch-ConfigDedicated
2577 // ...
2578 }
2579 if (optionalFieldPresent[6])
2580 {
2581 // Deserialize uplinkPowerControlDedicated
2582 // ...
2583 }
2584 if (optionalFieldPresent[5])
2585 {
2586 // Deserialize tpc-PDCCH-ConfigPUCCH
2587 // ...
2588 }
2589 if (optionalFieldPresent[4])
2590 {
2591 // Deserialize tpc-PDCCH-ConfigPUSCH
2592 // ...
2593 }
2594 if (optionalFieldPresent[3])
2595 {
2596 // Deserialize cqi-ReportConfig
2597 // ...
2598 }
2599 physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPresent[2];
2600 if (optionalFieldPresent[2])
2601 {
2602 // Deserialize soundingRS-UL-ConfigDedicated
2603 int sel;
2604 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2605
2606 if (sel == 0)
2607 {
2608 physicalConfigDedicated->soundingRsUlConfigDedicated.type =
2610
2611 bIterator = DeserializeNull(bIterator);
2612 }
2613
2614 else if (sel == 1)
2615 {
2616 physicalConfigDedicated->soundingRsUlConfigDedicated.type =
2618
2619 std::bitset<0> bitset0;
2620 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2621
2622 int slct;
2623
2624 // Deserialize srs-Bandwidth
2625 bIterator = DeserializeEnum(4, &slct, bIterator);
2626 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = slct;
2627
2628 // Deserialize srs-HoppingBandwidth
2629 bIterator = DeserializeEnum(4, &slct, bIterator);
2630
2631 // Deserialize freqDomainPosition
2632 bIterator = DeserializeInteger(&slct, 0, 23, bIterator);
2633
2634 // Deserialize duration
2635 bool duration;
2636 bIterator = DeserializeBoolean(&duration, bIterator);
2637
2638 // Deserialize srs-ConfigIndex
2639 bIterator = DeserializeInteger(&slct, 0, 1023, bIterator);
2640 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex = slct;
2641
2642 // Deserialize transmissionComb
2643 bIterator = DeserializeInteger(&slct, 0, 1, bIterator);
2644
2645 // Deserialize cyclicShift
2646 bIterator = DeserializeEnum(8, &slct, bIterator);
2647 }
2648 }
2649 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1];
2650 if (optionalFieldPresent[1])
2651 {
2652 // Deserialize antennaInfo
2653 int sel;
2654 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2655 if (sel == 1)
2656 {
2657 bIterator = DeserializeNull(bIterator);
2658 }
2659 else if (sel == 0)
2660 {
2661 std::bitset<1> codebookSubsetRestrictionPresent;
2662 bIterator = DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2663
2664 int txmode;
2665 bIterator = DeserializeEnum(8, &txmode, bIterator);
2666 physicalConfigDedicated->antennaInfo.transmissionMode = txmode;
2667
2668 if (codebookSubsetRestrictionPresent[0])
2669 {
2670 // Deserialize codebookSubsetRestriction
2671 // ...
2672 }
2673
2674 int txantennaselchosen;
2675 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2676 if (txantennaselchosen == 0)
2677 {
2678 // Deserialize ue-TransmitAntennaSelection release
2679 bIterator = DeserializeNull(bIterator);
2680 }
2681 else if (txantennaselchosen == 1)
2682 {
2683 // Deserialize ue-TransmitAntennaSelection setup
2684 // ...
2685 }
2686 }
2687 }
2688 if (optionalFieldPresent[0])
2689 {
2690 // Deserialize schedulingRequestConfig
2691 // ...
2692 }
2693 return bIterator;
2694}
2695
2696void
2697RrcAsn1Header::Print(std::ostream& os) const
2698{
2699 NS_LOG_FUNCTION(this << &os);
2700 NS_FATAL_ERROR("RrcAsn1Header Print() function must also specify "
2701 "LteRrcSap::RadioResourceConfigDedicated as a second argument");
2702}
2703
2707 Buffer::Iterator bIterator)
2708{
2709 NS_LOG_FUNCTION(this);
2710 std::bitset<2> nonCriticalExtension_v890;
2711 bIterator = DeserializeSequence(&nonCriticalExtension_v890, false, bIterator);
2712
2713 if (nonCriticalExtension_v890[0])
2714 {
2715 // Continue to analyze future Release optional fields
2716 std::bitset<3> nonCriticalExtension_v920;
2717 bIterator = DeserializeSequence(&nonCriticalExtension_v920, false, bIterator);
2718 if (nonCriticalExtension_v920[0])
2719 {
2720 // Continue to deserialize future Release optional fields
2721 std::bitset<3> nonCriticalExtension_v1020;
2722 bIterator = DeserializeSequence(&nonCriticalExtension_v1020, false, bIterator);
2723
2724 if (nonCriticalExtension_v1020[2])
2725 {
2726 // sCellToReleaseList-r10
2727 int numElems;
2728
2729 bIterator = DeserializeSequenceOf(&numElems, MAX_OBJECT_ID, 1, bIterator);
2730 nonCriticalExtension->sCellToReleaseList.clear();
2731
2732 for (int i = 0; i < numElems; i++)
2733 {
2734 // Deserialize SCellIndex-r10
2735 int sCellIndex;
2736 bIterator = DeserializeInteger(&sCellIndex, 1, 7, bIterator);
2737 nonCriticalExtension->sCellToReleaseList.push_back(sCellIndex);
2738 }
2739 }
2740
2741 if (nonCriticalExtension_v1020[1])
2742 {
2743 // sCellToAddModList-r10
2744
2745 int numElems;
2746 bIterator = DeserializeSequenceOf(&numElems, MAX_OBJECT_ID, 1, bIterator);
2747 nonCriticalExtension->sCellToAddModList.clear();
2748 // Deserialize SCellToAddMod
2749 for (int i = 0; i < numElems; i++)
2750 {
2751 std::bitset<4> sCellToAddMod_r10;
2752 bIterator = DeserializeSequence(&sCellToAddMod_r10, false, bIterator);
2753
2755 // Deserialize sCellIndex
2756 NS_ASSERT(sCellToAddMod_r10[3]); // sCellIndex
2757 int n;
2758 bIterator = DeserializeInteger(&n, 1, 7, bIterator);
2759 sctam.sCellIndex = n;
2760 // Deserialize CellIdentification
2761 NS_ASSERT(sCellToAddMod_r10[2]); // CellIdentification
2762 bIterator = DeserializeCellIdentification(&sctam.cellIdentification, bIterator);
2763
2764 // Deserialize RadioResourceConfigCommonSCell
2765 NS_ASSERT(sCellToAddMod_r10[1]);
2768 bIterator);
2769 if (sCellToAddMod_r10[0])
2770 {
2772 // Deserialize RadioResourceConfigDedicatedSCell
2775 bIterator);
2776 }
2777 else
2778 {
2780 }
2781
2782 nonCriticalExtension->sCellToAddModList.push_back(sctam);
2783 }
2784 }
2785
2786 NS_ASSERT(!nonCriticalExtension_v1020[0]); // No nonCriticalExtension
2787 // RRCConnectionReconfiguration-v1130-IEs
2788 }
2789 }
2790
2791 return bIterator;
2792}
2793
2796 Buffer::Iterator bIterator)
2797{
2798 NS_LOG_FUNCTION(this);
2799 std::bitset<2> cellIdentification_r10;
2800 bIterator = DeserializeSequence(&cellIdentification_r10, false, bIterator);
2801 NS_ASSERT(cellIdentification_r10[1]); // phyCellId-r10
2802 int n1;
2803 bIterator = DeserializeInteger(&n1, 1, 65536, bIterator);
2804 ci->physCellId = n1;
2805 int n2;
2806 NS_ASSERT(cellIdentification_r10[0]); // dl-CarrierFreq-r10
2807 bIterator = DeserializeInteger(&n2, 1, MAX_EARFCN, bIterator);
2808 ci->dlCarrierFreq = n2;
2809
2810 return bIterator;
2811}
2812
2816 Buffer::Iterator bIterator)
2817{
2818 NS_LOG_FUNCTION(this);
2819 std::bitset<2> radioResourceConfigCommonSCell_r10;
2820 bIterator = DeserializeSequence(&radioResourceConfigCommonSCell_r10, false, bIterator);
2821 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1];
2822 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0];
2823 if (rrccsc->haveNonUlConfiguration)
2824 {
2825 std::bitset<5> nonUlConfiguration_r10;
2826 bIterator = DeserializeSequence(&nonUlConfiguration_r10, false, bIterator);
2827 int n;
2828 bIterator = DeserializeInteger(&n, 6, 100, bIterator);
2829 rrccsc->nonUlConfiguration.dlBandwidth = n;
2830
2831 std::bitset<1> antennaInfoCommon_r10;
2832 bIterator = DeserializeSequence(&antennaInfoCommon_r10, false, bIterator);
2833 bIterator = DeserializeInteger(&n, 0, 65536, bIterator);
2835
2836 std::bitset<2> pdschConfigCommon_r10;
2837 bIterator = DeserializeSequence(&pdschConfigCommon_r10, false, bIterator);
2838 bIterator = DeserializeInteger(&n, -60, 50, bIterator);
2840 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
2842 }
2843 if (rrccsc->haveUlConfiguration)
2844 {
2845 std::bitset<7> UlConfiguration_r10;
2846 bIterator = DeserializeSequence(&UlConfiguration_r10, true, bIterator);
2847
2848 std::bitset<3> FreqInfo_r10;
2849 bIterator = DeserializeSequence(&FreqInfo_r10, false, bIterator);
2850 int n;
2851 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
2853 bIterator = DeserializeInteger(&n, 6, 100, bIterator);
2855
2856 std::bitset<2> UlPowerControlCommonSCell_r10;
2857 bIterator = DeserializeSequence(&UlPowerControlCommonSCell_r10, false, bIterator);
2858 bIterator = DeserializeInteger(&n, 0, 65536, bIterator);
2860
2861 std::bitset<1> prachConfigSCell_r10;
2862 bIterator = DeserializeSequence(&prachConfigSCell_r10, false, bIterator);
2863 bIterator = DeserializeInteger(&n, 0, 256, bIterator);
2865 }
2866
2867 return bIterator;
2868}
2869
2873 Buffer::Iterator bIterator)
2874{
2875 NS_LOG_FUNCTION(this);
2876 std::bitset<1> RadioResourceConfigDedicatedSCell_r10;
2877 bIterator = DeserializeSequence(&RadioResourceConfigDedicatedSCell_r10, false, bIterator);
2878 bIterator =
2880
2881 return bIterator;
2882}
2883
2887 Buffer::Iterator bIterator)
2888{
2889 NS_LOG_FUNCTION(this);
2890 std::bitset<2> pcdscOpt;
2891 bIterator = DeserializeSequence(&pcdscOpt, true, bIterator);
2892 pcdsc->haveNonUlConfiguration = pcdscOpt[1];
2893 pcdsc->haveUlConfiguration = pcdscOpt[0];
2894 if (pcdsc->haveNonUlConfiguration)
2895 {
2896 std::bitset<4> nulOpt;
2897 bIterator = DeserializeSequence(&nulOpt, false, bIterator);
2898 pcdsc->haveAntennaInfoDedicated = nulOpt[3];
2899 NS_ASSERT(!nulOpt[2]); // crossCarrierSchedulingConfig-r10 Not Implemented
2900 NS_ASSERT(!nulOpt[1]); // csi-RS-Config-r10 Not Implemented
2901 pcdsc->havePdschConfigDedicated = nulOpt[0];
2902
2903 if (pcdsc->haveAntennaInfoDedicated)
2904 {
2905 // Deserialize antennaInfo
2906 int sel;
2907 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2908 if (sel == 1)
2909 {
2910 bIterator = DeserializeNull(bIterator);
2911 }
2912 else if (sel == 0)
2913 {
2914 std::bitset<1> codebookSubsetRestrictionPresent;
2915 bIterator =
2916 DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2917
2918 int txmode;
2919 bIterator = DeserializeEnum(8, &txmode, bIterator);
2920 pcdsc->antennaInfo.transmissionMode = txmode;
2921
2922 if (codebookSubsetRestrictionPresent[0])
2923 {
2924 // Deserialize codebookSubsetRestriction
2925 NS_FATAL_ERROR("Not implemented yet");
2926 // ...
2927 }
2928
2929 int txantennaselchosen;
2930 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2931 if (txantennaselchosen == 0)
2932 {
2933 // Deserialize ue-TransmitAntennaSelection release
2934 bIterator = DeserializeNull(bIterator);
2935 }
2936 else if (txantennaselchosen == 1)
2937 {
2938 // Deserialize ue-TransmitAntennaSelection setup
2939 NS_FATAL_ERROR("Not implemented yet");
2940 // ...
2941 }
2942 }
2943 }
2944 if (pcdsc->havePdschConfigDedicated)
2945 {
2946 // Deserialize pdsch-ConfigDedicated
2947 std::bitset<0> bitset0;
2948 bIterator = DeserializeSequence(&bitset0, false, bIterator);
2949
2950 int slct;
2951
2952 // Deserialize p-a
2953 bIterator = DeserializeEnum(8, &slct, bIterator);
2954 pcdsc->pdschConfigDedicated.pa = slct;
2955
2956 bIterator = DeserializeNull(bIterator);
2957 }
2958 }
2959 if (pcdsc->haveUlConfiguration)
2960 {
2961 std::bitset<7> ulOpt;
2962 bIterator = DeserializeSequence(&ulOpt, false, bIterator);
2963 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6];
2964 NS_ASSERT(!ulOpt[5]); // pusch-ConfigDedicatedSCell-r10 not present
2965 NS_ASSERT(!ulOpt[4]); // uplinkPowerControlDedicatedSCell-r10 not present
2966 NS_ASSERT(!ulOpt[3]); // cqi-ReportConfigSCell-r10 not present
2967 pcdsc->haveSoundingRsUlConfigDedicated = ulOpt[2];
2968 NS_ASSERT(!ulOpt[1]); // soundingRS-UL-ConfigDedicated-v1020 not present
2969 NS_ASSERT(!ulOpt[0]); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present
2970
2971 if (pcdsc->haveAntennaInfoUlDedicated)
2972 {
2973 // Deserialize antennaInfo
2974 int sel;
2975 bIterator = DeserializeChoice(2, false, &sel, bIterator);
2976 if (sel == 1)
2977 {
2978 bIterator = DeserializeNull(bIterator);
2979 }
2980 else if (sel == 0)
2981 {
2982 std::bitset<1> codebookSubsetRestrictionPresent;
2983 bIterator =
2984 DeserializeSequence(&codebookSubsetRestrictionPresent, false, bIterator);
2985
2986 int txmode;
2987 bIterator = DeserializeEnum(8, &txmode, bIterator);
2988 pcdsc->antennaInfoUl.transmissionMode = txmode;
2989
2990 if (codebookSubsetRestrictionPresent[0])
2991 {
2992 // Deserialize codebookSubsetRestriction
2993 NS_FATAL_ERROR("Not implemented yet");
2994 // ...
2995 }
2996
2997 int txantennaselchosen;
2998 bIterator = DeserializeChoice(2, false, &txantennaselchosen, bIterator);
2999 if (txantennaselchosen == 0)
3000 {
3001 // Deserialize ue-TransmitAntennaSelection release
3002 bIterator = DeserializeNull(bIterator);
3003 }
3004 else if (txantennaselchosen == 1)
3005 {
3006 // Deserialize ue-TransmitAntennaSelection setup
3007 NS_FATAL_ERROR("Not implemented yet");
3008 // ...
3009 }
3010 }
3011 }
3013 {
3014 // Deserialize soundingRS-UL-ConfigDedicated
3015 int sel;
3016 bIterator = DeserializeChoice(2, false, &sel, bIterator);
3017
3018 if (sel == 0)
3019 {
3022
3023 bIterator = DeserializeNull(bIterator);
3024 }
3025
3026 else if (sel == 1)
3027 {
3030
3031 std::bitset<0> bitset0;
3032 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3033
3034 int slct;
3035
3036 // Deserialize srs-Bandwidth
3037 bIterator = DeserializeEnum(4, &slct, bIterator);
3039
3040 // Deserialize srs-HoppingBandwidth
3041 bIterator = DeserializeEnum(4, &slct, bIterator);
3042
3043 // Deserialize freqDomainPosition
3044 bIterator = DeserializeInteger(&slct, 0, 23, bIterator);
3045
3046 // Deserialize duration
3047 bool duration;
3048 bIterator = DeserializeBoolean(&duration, bIterator);
3049
3050 // Deserialize srs-ConfigIndex
3051 bIterator = DeserializeInteger(&slct, 0, 1023, bIterator);
3053
3054 // Deserialize transmissionComb
3055 bIterator = DeserializeInteger(&slct, 0, 1, bIterator);
3056
3057 // Deserialize cyclicShift
3058 bIterator = DeserializeEnum(8, &slct, bIterator);
3059 }
3060 }
3061 }
3062
3063 return bIterator;
3064}
3065
3066void
3067RrcAsn1Header::Print(std::ostream& os,
3068 LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
3069{
3070 os << " srbToAddModList: " << std::endl;
3071 std::list<LteRrcSap::SrbToAddMod>::iterator it =
3072 radioResourceConfigDedicated.srbToAddModList.begin();
3073 for (; it != radioResourceConfigDedicated.srbToAddModList.end(); it++)
3074 {
3075 os << " srbIdentity: " << (int)it->srbIdentity << std::endl;
3076 os << " logicalChannelConfig: " << std::endl;
3077 os << " priority: " << (int)it->logicalChannelConfig.priority << std::endl;
3078 os << " prioritizedBitRateKbps: "
3079 << (int)it->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
3080 os << " bucketSizeDurationMs: "
3081 << (int)it->logicalChannelConfig.bucketSizeDurationMs << std::endl;
3082 os << " logicalChannelGroup: " << (int)it->logicalChannelConfig.logicalChannelGroup
3083 << std::endl;
3084 }
3085 os << std::endl;
3086
3087 os << " drbToAddModList: " << std::endl;
3088 std::list<LteRrcSap::DrbToAddMod>::iterator it2 =
3089 radioResourceConfigDedicated.drbToAddModList.begin();
3090 for (; it2 != radioResourceConfigDedicated.drbToAddModList.end(); it2++)
3091 {
3092 os << " epsBearerIdentity: " << (int)it2->epsBearerIdentity << std::endl;
3093 os << " drbIdentity: " << (int)it2->drbIdentity << std::endl;
3094 os << " rlcConfig: " << it2->rlcConfig.choice << std::endl;
3095 os << " logicalChannelIdentity: " << (int)it2->logicalChannelIdentity << std::endl;
3096 os << " logicalChannelConfig: " << std::endl;
3097 os << " priority: " << (int)it2->logicalChannelConfig.priority << std::endl;
3098 os << " prioritizedBitRateKbps: "
3099 << (int)it2->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
3100 os << " bucketSizeDurationMs: "
3101 << (int)it2->logicalChannelConfig.bucketSizeDurationMs << std::endl;
3102 os << " logicalChannelGroup: " << (int)it2->logicalChannelConfig.logicalChannelGroup
3103 << std::endl;
3104 }
3105 os << std::endl;
3106
3107 os << " drbToReleaseList: ";
3108 std::list<uint8_t>::iterator it3 = radioResourceConfigDedicated.drbToReleaseList.begin();
3109 for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end(); it3++)
3110 {
3111 os << (int)*it3 << ", ";
3112 }
3113 os << std::endl;
3114
3115 os << " havePhysicalConfigDedicated: "
3116 << radioResourceConfigDedicated.havePhysicalConfigDedicated << std::endl;
3117
3118 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
3119 {
3120 os << " physicalConfigDedicated: " << std::endl;
3121
3122 os << " haveSoundingRsUlConfigDedicated: "
3123 << radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated
3124 << std::endl;
3125 if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
3126 {
3127 os << " soundingRsUlConfigDedicated: " << std::endl;
3128 os << " type: "
3129 << radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated
3130 .type
3131 << std::endl;
3132 os << " srsBandwidth: "
3133 << (int)radioResourceConfigDedicated.physicalConfigDedicated
3135 << std::endl;
3136 os << " srsConfigIndex: "
3137 << (int)radioResourceConfigDedicated.physicalConfigDedicated
3139 << std::endl;
3140 }
3141
3142 os << " haveAntennaInfoDedicated: "
3143 << radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated
3144 << std::endl;
3145 if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated)
3146 {
3147 os << " antennaInfo Tx mode: "
3148 << (int)radioResourceConfigDedicated.physicalConfigDedicated.antennaInfo
3150 << std::endl;
3151 }
3152 }
3153}
3154
3157 LteRrcSap::SystemInformationBlockType1* systemInformationBlockType1,
3158 Buffer::Iterator bIterator)
3159{
3160 std::bitset<0> bitset0;
3161 int n;
3162
3163 std::bitset<3> sysInfoBlkT1Opts;
3164 bIterator = DeserializeSequence(&sysInfoBlkT1Opts, false, bIterator);
3165
3166 // Deserialize cellAccessRelatedInfo
3167 std::bitset<1> cellAccessRelatedInfoOpts;
3168 bIterator = DeserializeSequence(&cellAccessRelatedInfoOpts, false, bIterator);
3169
3170 // Deserialize plmn-IdentityList
3171 int numPlmnIdentityInfoElements;
3172 bIterator = DeserializeSequenceOf(&numPlmnIdentityInfoElements, 6, 1, bIterator);
3173 for (int i = 0; i < numPlmnIdentityInfoElements; i++)
3174 {
3175 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3176
3177 // plmn-Identity
3178 bIterator = DeserializePlmnIdentity(
3179 &systemInformationBlockType1->cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity,
3180 bIterator);
3181 }
3182
3183 // Deserialize trackingAreaCode
3184 std::bitset<16> trackingAreaCode;
3185 bIterator = DeserializeBitstring(&trackingAreaCode, bIterator);
3186
3187 // Deserialize cellIdentity
3188 std::bitset<28> cellIdentity;
3189 bIterator = DeserializeBitstring(&cellIdentity, bIterator);
3190 systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdentity.to_ulong();
3191
3192 // Deserialize cellBarred
3193 bIterator = DeserializeEnum(2, &n, bIterator);
3194
3195 // Deserialize intraFreqReselection
3196 bIterator = DeserializeEnum(2, &n, bIterator);
3197
3198 // Deserialize csg-Indication
3199 bIterator =
3200 DeserializeBoolean(&systemInformationBlockType1->cellAccessRelatedInfo.csgIndication,
3201 bIterator);
3202
3203 if (cellAccessRelatedInfoOpts[0])
3204 {
3205 // Deserialize csg-Identity
3206 std::bitset<27> csgIdentity;
3207 bIterator = DeserializeBitstring(&csgIdentity, bIterator);
3208 systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIdentity.to_ulong();
3209 }
3210
3211 // Deserialize cellSelectionInfo
3212 std::bitset<1> qRxLevMinOffsetPresent;
3213 bIterator = DeserializeSequence(&qRxLevMinOffsetPresent, false, bIterator);
3214 bIterator = DeserializeInteger(&n, -70, -22, bIterator); // q-RxLevMin
3215 if (qRxLevMinOffsetPresent[0])
3216 {
3217 // Deserialize qRxLevMinOffset
3218 // ...
3219 }
3220
3221 if (sysInfoBlkT1Opts[2])
3222 {
3223 // Deserialize p-Max
3224 // ...
3225 }
3226
3227 // freqBandIndicator
3228 bIterator = DeserializeInteger(&n, 1, 64, bIterator);
3229
3230 // schedulingInfoList
3231 int numSchedulingInfo;
3232 bIterator = DeserializeSequenceOf(&numSchedulingInfo, MAX_SI_MESSAGE, 1, bIterator);
3233 for (int i = 0; i < numSchedulingInfo; i++)
3234 {
3235 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3236 bIterator = DeserializeEnum(7, &n, bIterator); // si-Periodicity
3237 int numSibType;
3238 bIterator =
3239 DeserializeSequenceOf(&numSibType, MAX_SIB - 1, 0, bIterator); // sib-MappingInfo
3240 for (int j = 0; j < numSibType; j++)
3241 {
3242 bIterator = DeserializeEnum(16, &n, bIterator); // SIB-Type
3243 }
3244 }
3245
3246 if (sysInfoBlkT1Opts[1])
3247 {
3248 // tdd-Config
3249 // ...
3250 }
3251
3252 // si-WindowLength
3253 bIterator = DeserializeEnum(7, &n, bIterator);
3254
3255 // systemInfoValueTag
3256 bIterator = DeserializeInteger(&n, 0, 31, bIterator);
3257
3258 if (sysInfoBlkT1Opts[0])
3259 {
3260 // Deserialize nonCriticalExtension
3261 // ...
3262 }
3263 return bIterator;
3264}
3265
3268 LteRrcSap::SystemInformationBlockType2* systemInformationBlockType2,
3269 Buffer::Iterator bIterator)
3270{
3271 std::bitset<0> bitset0;
3272 int n;
3273
3274 std::bitset<2> sysInfoBlkT2Opts;
3275 bIterator = DeserializeSequence(&sysInfoBlkT2Opts, true, bIterator);
3276 if (sysInfoBlkT2Opts[1])
3277 {
3278 // Deserialize ac-BarringInfo
3279 // ...
3280 }
3281
3282 // Deserialize radioResourceConfigCommon
3284 &systemInformationBlockType2->radioResourceConfigCommon,
3285 bIterator);
3286
3287 // Deserialize ue-TimersAndConstants
3288 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3289 bIterator = DeserializeEnum(8, &n, bIterator); // t300
3290 bIterator = DeserializeEnum(8, &n, bIterator); // t301
3291 bIterator = DeserializeEnum(7, &n, bIterator); // t310
3292 bIterator = DeserializeEnum(8, &n, bIterator); // n310
3293 bIterator = DeserializeEnum(7, &n, bIterator); // t311
3294 bIterator = DeserializeEnum(8, &n, bIterator); // n311
3295
3296 // Deserialize freqInfo
3297 std::bitset<2> freqInfoOpts;
3298 bIterator = DeserializeSequence(&freqInfoOpts, false, bIterator);
3299 if (freqInfoOpts[1])
3300 {
3301 // Deserialize ul-CarrierFreq
3302 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
3303 systemInformationBlockType2->freqInfo.ulCarrierFreq = n;
3304 }
3305 if (freqInfoOpts[0])
3306 {
3307 // Deserialize ul-Bandwidth
3308 bIterator = DeserializeEnum(6, &n, bIterator);
3309 systemInformationBlockType2->freqInfo.ulBandwidth = EnumToBandwidth(n);
3310 }
3311
3312 // additionalSpectrumEmission
3313 bIterator = DeserializeInteger(&n, 1, 32, bIterator);
3314
3315 if (sysInfoBlkT2Opts[0])
3316 {
3317 // Deserialize mbsfn-SubframeConfigList
3318 // ...
3319 }
3320
3321 // Deserialize timeAlignmentTimerCommon
3322 bIterator = DeserializeEnum(8, &n, bIterator);
3323
3324 return bIterator;
3325}
3326
3329 LteRrcSap::RadioResourceConfigCommon* radioResourceConfigCommon,
3330 Buffer::Iterator bIterator)
3331{
3332 std::bitset<0> bitset0;
3333 int n;
3334
3335 std::bitset<9> rrCfgCommOptions;
3336 bIterator = DeserializeSequence(&rrCfgCommOptions, true, bIterator);
3337
3338 // rach-ConfigCommon
3339 if (rrCfgCommOptions[8])
3340 {
3341 bIterator =
3342 DeserializeRachConfigCommon(&radioResourceConfigCommon->rachConfigCommon, bIterator);
3343 }
3344
3345 // prach-Config
3346 std::bitset<1> prachConfigInfoPresent;
3347 bIterator = DeserializeSequence(&prachConfigInfoPresent, false, bIterator);
3348
3349 // prach-Config -> rootSequenceIndex
3350 bIterator = DeserializeInteger(&n, 0, 1023, bIterator);
3351
3352 // prach-Config -> prach-ConfigInfo
3353 if (prachConfigInfoPresent[0])
3354 {
3355 // ...
3356 }
3357
3358 // pdsch-ConfigCommon
3359 if (rrCfgCommOptions[7])
3360 {
3361 // ...
3362 }
3363
3364 // pusch-ConfigCommon
3365 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3366
3367 // pusch-ConfigCommon -> pusch-ConfigBasic
3368 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3369
3370 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
3371 bIterator = DeserializeInteger(&n, 1, 4, bIterator);
3372
3373 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
3374 bIterator = DeserializeEnum(2, &n, bIterator);
3375
3376 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
3377 bIterator = DeserializeInteger(&n, 0, 98, bIterator);
3378
3379 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
3380 bool enable64QAM;
3381 bIterator = DeserializeBoolean(&enable64QAM, bIterator);
3382
3383 // ul-ReferenceSignalsPUSCH
3384 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3385
3386 // groupHoppingEnabled
3387 bool dummyBool;
3388 bIterator = DeserializeBoolean(&dummyBool, bIterator);
3389
3390 // groupAssignmentPUSCH
3391 bIterator = DeserializeInteger(&n, 0, 29, bIterator);
3392
3393 // sequenceHoppingEnabled
3394 bIterator = DeserializeBoolean(&dummyBool, bIterator);
3395
3396 // cyclicShift
3397 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
3398
3399 // phich-Config
3400 if (rrCfgCommOptions[6])
3401 {
3402 // ...
3403 }
3404
3405 // pucch-ConfigCommon
3406 if (rrCfgCommOptions[5])
3407 {
3408 // ...
3409 }
3410
3411 // soundingRS-UL-ConfigCommon
3412 if (rrCfgCommOptions[4])
3413 {
3414 // ...
3415 }
3416
3417 // uplinkPowerControlCommon
3418 if (rrCfgCommOptions[3])
3419 {
3420 // ...
3421 }
3422
3423 // antennaInfoCommon
3424 if (rrCfgCommOptions[2])
3425 {
3426 // ...
3427 }
3428
3429 // p-Max
3430 if (rrCfgCommOptions[1])
3431 {
3432 // ...
3433 }
3434
3435 // tdd-Config
3436 if (rrCfgCommOptions[0])
3437 {
3438 // ...
3439 }
3440
3441 // ul-CyclicPrefixLength
3442 bIterator = DeserializeEnum(2, &n, bIterator);
3443
3444 return bIterator;
3445}
3446
3449 Buffer::Iterator bIterator)
3450{
3451 std::bitset<0> bitset0;
3452 int n;
3453
3454 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3455
3456 // preambleInfo
3457 std::bitset<1> preamblesGroupAConfigPresent;
3458 bIterator = DeserializeSequence(&preamblesGroupAConfigPresent, false, bIterator);
3459
3460 // numberOfRA-Preambles
3461 bIterator = DeserializeEnum(16, &n, bIterator);
3462 switch (n)
3463 {
3464 case 0:
3465 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
3466 break;
3467 case 1:
3468 rachConfigCommon->preambleInfo.numberOfRaPreambles = 8;
3469 break;
3470 case 2:
3471 rachConfigCommon->preambleInfo.numberOfRaPreambles = 12;
3472 break;
3473 case 3:
3474 rachConfigCommon->preambleInfo.numberOfRaPreambles = 16;
3475 break;
3476 case 4:
3477 rachConfigCommon->preambleInfo.numberOfRaPreambles = 20;
3478 break;
3479 case 5:
3480 rachConfigCommon->preambleInfo.numberOfRaPreambles = 24;
3481 break;
3482 case 6:
3483 rachConfigCommon->preambleInfo.numberOfRaPreambles = 28;
3484 break;
3485 case 7:
3486 rachConfigCommon->preambleInfo.numberOfRaPreambles = 32;
3487 break;
3488 case 8:
3489 rachConfigCommon->preambleInfo.numberOfRaPreambles = 36;
3490 break;
3491 case 9:
3492 rachConfigCommon->preambleInfo.numberOfRaPreambles = 40;
3493 break;
3494 case 10:
3495 rachConfigCommon->preambleInfo.numberOfRaPreambles = 44;
3496 break;
3497 case 11:
3498 rachConfigCommon->preambleInfo.numberOfRaPreambles = 48;
3499 break;
3500 case 12:
3501 rachConfigCommon->preambleInfo.numberOfRaPreambles = 52;
3502 break;
3503 case 13:
3504 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56;
3505 break;
3506 case 14:
3507 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60;
3508 break;
3509 case 15:
3510 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64;
3511 break;
3512 default:
3513 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
3514 }
3515
3516 if (preamblesGroupAConfigPresent[0])
3517 {
3518 // Deserialize preamblesGroupAConfig
3519 // ...
3520 }
3521
3522 // powerRampingParameters
3523 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3524 bIterator = DeserializeEnum(4, &n, bIterator); // powerRampingStep
3525 bIterator = DeserializeEnum(16, &n, bIterator); // preambleInitialReceivedTargetPower
3526
3527 // ra-SupervisionInfo
3528 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3529 bIterator = DeserializeEnum(11, &n, bIterator); // preambleTransMax
3530 switch (n)
3531 {
3532 case 0:
3533 rachConfigCommon->raSupervisionInfo.preambleTransMax = 3;
3534 break;
3535 case 1:
3536 rachConfigCommon->raSupervisionInfo.preambleTransMax = 4;
3537 break;
3538 case 2:
3539 rachConfigCommon->raSupervisionInfo.preambleTransMax = 5;
3540 break;
3541 case 3:
3542 rachConfigCommon->raSupervisionInfo.preambleTransMax = 6;
3543 break;
3544 case 4:
3545 rachConfigCommon->raSupervisionInfo.preambleTransMax = 7;
3546 break;
3547 case 5:
3548 rachConfigCommon->raSupervisionInfo.preambleTransMax = 8;
3549 break;
3550 case 6:
3551 rachConfigCommon->raSupervisionInfo.preambleTransMax = 10;
3552 break;
3553 case 7:
3554 rachConfigCommon->raSupervisionInfo.preambleTransMax = 20;
3555 break;
3556 case 8:
3557 rachConfigCommon->raSupervisionInfo.preambleTransMax = 50;
3558 break;
3559 case 9:
3560 rachConfigCommon->raSupervisionInfo.preambleTransMax = 100;
3561 break;
3562 case 10:
3563 rachConfigCommon->raSupervisionInfo.preambleTransMax = 200;
3564 break;
3565 default:
3566 rachConfigCommon->raSupervisionInfo.preambleTransMax = 0;
3567 }
3568
3569 // ra-ResponseWindowSize
3570 bIterator = DeserializeEnum(8, &n, bIterator);
3571 switch (n)
3572 {
3573 case 0:
3574 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2;
3575 break;
3576 case 1:
3577 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3;
3578 break;
3579 case 2:
3580 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4;
3581 break;
3582 case 3:
3583 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5;
3584 break;
3585 case 4:
3586 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6;
3587 break;
3588 case 5:
3589 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7;
3590 break;
3591 case 6:
3592 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8;
3593 break;
3594 case 7:
3595 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10;
3596 break;
3597 default:
3598 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0;
3599 }
3600
3601 bIterator = DeserializeEnum(8, &n, bIterator); // mac-ContentionResolutionTimer
3602 bIterator = DeserializeInteger(&n, 1, 8, bIterator); // maxHARQ-Msg3Tx
3603
3604 // connEstFailCount
3605 bIterator = DeserializeEnum(8, &n, bIterator);
3606 switch (n)
3607 {
3608 case 1:
3609 rachConfigCommon->txFailParam.connEstFailCount = 1;
3610 break;
3611 case 2:
3612 rachConfigCommon->txFailParam.connEstFailCount = 2;
3613 break;
3614 case 3:
3615 rachConfigCommon->txFailParam.connEstFailCount = 3;
3616 break;
3617 case 4:
3618 rachConfigCommon->txFailParam.connEstFailCount = 4;
3619 break;
3620 default:
3621 rachConfigCommon->txFailParam.connEstFailCount = 1;
3622 }
3623 return bIterator;
3624}
3625
3628 LteRrcSap::RadioResourceConfigCommonSib* radioResourceConfigCommonSib,
3629 Buffer::Iterator bIterator)
3630{
3631 std::bitset<0> bitset0;
3632 int n;
3633
3634 bIterator = DeserializeSequence(&bitset0, true, bIterator);
3635
3636 // rach-ConfigCommon
3637 bIterator =
3638 DeserializeRachConfigCommon(&radioResourceConfigCommonSib->rachConfigCommon, bIterator);
3639
3640 // bcch-Config
3641 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3642 bIterator = DeserializeEnum(4, &n, bIterator); // modificationPeriodCoeff
3643
3644 // pcch-Config
3645 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3646 bIterator = DeserializeEnum(4, &n, bIterator); // defaultPagingCycle
3647 bIterator = DeserializeEnum(8, &n, bIterator); // nB
3648
3649 // prach-Config
3650 std::bitset<1> prachConfigInfoPresent;
3651 bIterator = DeserializeSequence(&prachConfigInfoPresent, false, bIterator);
3652 // prach-Config -> rootSequenceIndex
3653 bIterator = DeserializeInteger(&n, 0, 1023, bIterator);
3654 // prach-Config -> prach-ConfigInfo
3655 if (prachConfigInfoPresent[0])
3656 {
3657 // ...
3658 }
3659
3660 // pdsch-ConfigCommon
3661 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3662 bIterator = DeserializeInteger(&n, -60, 50, bIterator); // referenceSignalPower
3663 bIterator = DeserializeInteger(&n, 0, 3, bIterator); // p-b
3664
3665 // pusch-ConfigCommon
3666 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3667
3668 // pusch-ConfigCommon -> pusch-ConfigBasic
3669 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3670
3671 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB
3672 bIterator = DeserializeInteger(&n, 1, 4, bIterator);
3673
3674 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode
3675 bIterator = DeserializeEnum(2, &n, bIterator);
3676
3677 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset
3678 bIterator = DeserializeInteger(&n, 0, 98, bIterator);
3679
3680 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM
3681 bool dummyBoolean;
3682 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3683
3684 // ul-ReferenceSignalsPUSCH
3685 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3686
3687 // groupHoppingEnabled
3688 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3689
3690 // groupAssignmentPUSCH
3691 bIterator = DeserializeInteger(&n, 0, 29, bIterator);
3692
3693 // sequenceHoppingEnabled
3694 bIterator = DeserializeBoolean(&dummyBoolean, bIterator);
3695
3696 // cyclicShift
3697 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
3698
3699 // pucch-ConfigCommon
3700 bIterator = DeserializeEnum(3, &n, bIterator); // deltaPUCCH-Shift
3701 bIterator = DeserializeInteger(&n, 0, 98, bIterator); // nRB-CQI
3702 bIterator = DeserializeInteger(&n, 0, 7, bIterator); // nCS-AN
3703 bIterator = DeserializeInteger(&n, 0, 2047, bIterator); // n1PUCCH-AN
3704
3705 // soundingRS-UL-ConfigCommon
3706 int choice;
3707 bIterator = DeserializeChoice(2, false, &choice, bIterator);
3708 if (choice == 0)
3709 {
3710 bIterator = DeserializeNull(bIterator); // release
3711 }
3712 if (choice == 1)
3713 {
3714 // setup
3715 // ...
3716 }
3717
3718 // uplinkPowerControlCommon
3719 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3720 bIterator = DeserializeInteger(&n, -126, 24, bIterator); // p0-NominalPUSCH
3721 bIterator = DeserializeEnum(8, &n, bIterator); // alpha
3722 bIterator = DeserializeInteger(&n, -127, -96, bIterator); // p0-NominalPUCCH
3723 // deltaFList-PUCCH
3724 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3725 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format1
3726 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format1b
3727 bIterator = DeserializeEnum(4, &n, bIterator); // deltaF-PUCCH-Format2
3728 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format2a
3729 bIterator = DeserializeEnum(3, &n, bIterator); // deltaF-PUCCH-Format2b
3730 bIterator = DeserializeInteger(&n, -1, 6, bIterator); // deltaPreambleMsg3
3731
3732 // ul-CyclicPrefixLength
3733 bIterator = DeserializeEnum(2, &n, bIterator);
3734
3735 return bIterator;
3736}
3737
3740 Buffer::Iterator bIterator)
3741{
3742 int n;
3743 std::bitset<0> b0;
3744 std::bitset<4> measResultOptionalPresent;
3745 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIterator);
3746 bIterator = DeserializeSequence(&measResultOptionalPresent, true, bIterator);
3747
3748 // Deserialize measId
3749 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
3750 measResults->measId = n;
3751
3752 // Deserialize measResultServCell
3753 bIterator = DeserializeSequence(&b0, false, bIterator);
3754
3755 // Deserialize rsrpResult
3756 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3757 measResults->measResultPCell.rsrpResult = n;
3758
3759 // Deserialize rsrqResult
3760 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3761 measResults->measResultPCell.rsrqResult = n;
3762
3763 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0];
3764 measResults->haveMeasResultServFreqList = measResultOptionalPresent[3];
3765 if (measResults->haveMeasResultNeighCells)
3766 {
3767 int measResultNeighCellsChoice;
3768
3769 // Deserialize measResultNeighCells
3770 bIterator = DeserializeChoice(4, false, &measResultNeighCellsChoice, bIterator);
3771
3772 if (measResultNeighCellsChoice == 0)
3773 {
3774 // Deserialize measResultListEUTRA
3775 int numElems;
3776 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_REPORT, 1, bIterator);
3777
3778 for (int i = 0; i < numElems; i++)
3779 {
3780 LteRrcSap::MeasResultEutra measResultEutra;
3781
3782 std::bitset<1> isCgiInfoPresent;
3783 bIterator = DeserializeSequence(&isCgiInfoPresent, false, bIterator);
3784
3785 // PhysCellId
3786 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
3787 measResultEutra.physCellId = n;
3788
3789 measResultEutra.haveCgiInfo = isCgiInfoPresent[0];
3790 if (isCgiInfoPresent[0])
3791 {
3792 std::bitset<1> havePlmnIdentityList;
3793 bIterator = DeserializeSequence(&havePlmnIdentityList, false, bIterator);
3794
3795 // Deserialize cellGlobalId
3796 bIterator = DeserializeSequence(&b0, false, bIterator);
3797
3798 // Deserialize plmn-Identity
3799 bIterator =
3800 DeserializePlmnIdentity(&measResultEutra.cgiInfo.plmnIdentity, bIterator);
3801
3802 // Deserialize CellIdentity
3803 std::bitset<28> cellId;
3804 bIterator = DeserializeBitstring(&cellId, bIterator);
3805 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong();
3806
3807 // Deserialize trackingAreaCode
3808 std::bitset<16> trArCo;
3809 bIterator = DeserializeBitstring(&trArCo, bIterator);
3810 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong();
3811
3812 // Deserialize plmn-IdentityList
3813 if (havePlmnIdentityList[0])
3814 {
3815 int numPlmnElems;
3816 bIterator = DeserializeSequenceOf(&numPlmnElems, 5, 1, bIterator);
3817
3818 for (int j = 0; j < numPlmnElems; j++)
3819 {
3820 uint32_t plmnId;
3821 bIterator = DeserializePlmnIdentity(&plmnId, bIterator);
3822 measResultEutra.cgiInfo.plmnIdentityList.push_back(plmnId);
3823 }
3824 }
3825 }
3826
3827 // Deserialize measResult
3828 std::bitset<2> measResultOpts;
3829 bIterator = DeserializeSequence(&measResultOpts, true, bIterator);
3830
3831 measResultEutra.haveRsrpResult = measResultOpts[1];
3832 if (measResultOpts[1])
3833 {
3834 // Deserialize rsrpResult
3835 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3836 measResultEutra.rsrpResult = n;
3837 }
3838
3839 measResultEutra.haveRsrqResult = measResultOpts[0];
3840 if (measResultOpts[0])
3841 {
3842 // Deserialize rsrqResult
3843 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3844 measResultEutra.rsrqResult = n;
3845 }
3846
3847 measResults->measResultListEutra.push_back(measResultEutra);
3848 }
3849 }
3850
3851 if (measResultNeighCellsChoice == 1)
3852 {
3853 // Deserialize measResultListUTRA
3854 // ...
3855 }
3856
3857 if (measResultNeighCellsChoice == 2)
3858 {
3859 // Deserialize measResultListGERAN
3860 // ...
3861 }
3862 if (measResultNeighCellsChoice == 3)
3863 {
3864 // Deserialize measResultsCDMA2000
3865 // ...
3866 }
3867 }
3868 if (measResults->haveMeasResultServFreqList)
3869 {
3870 int numElems;
3871 bIterator = DeserializeSequenceOf(&numElems, MAX_SCELL_REPORT, 1, bIterator);
3872 for (int i = 0; i < numElems; i++)
3873 {
3874 LteRrcSap::MeasResultServFreq measResultServFreq;
3875
3876 // Deserialize MeasResultServFreq-r10
3877 std::bitset<2> measResultScellPresent;
3878 bIterator = DeserializeSequence(&measResultScellPresent, true, bIterator);
3879 measResultServFreq.haveMeasResultSCell = measResultScellPresent[0];
3880 measResultServFreq.haveMeasResultBestNeighCell = measResultScellPresent[1];
3881
3882 // Deserialize servFreqId-r10
3883 int servFreqId;
3884 bIterator = DeserializeInteger(&servFreqId, 0, 7, bIterator);
3885 measResultServFreq.servFreqId = servFreqId;
3886
3887 if (measResultServFreq.haveMeasResultSCell)
3888 {
3889 // Deserialize rsrpResult
3890 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3891 measResultServFreq.measResultSCell.rsrpResult = n;
3892
3893 // Deserialize rsrqResult
3894 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3895 measResultServFreq.measResultSCell.rsrqResult = n;
3896 }
3897
3898 if (measResultServFreq.haveMeasResultBestNeighCell)
3899 {
3900 // Deserialize physCellId-r10
3901 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
3902 measResultServFreq.measResultBestNeighCell.physCellId = n;
3903
3904 // Deserialize rsrpResultNCell-r10
3905 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
3906 measResultServFreq.measResultBestNeighCell.rsrpResult = n;
3907
3908 // Deserialize rsrqResultNCell-r10
3909 bIterator = DeserializeInteger(&n, 0, 34, bIterator);
3910 measResultServFreq.measResultBestNeighCell.rsrqResult = n;
3911 }
3912 measResults->measResultServFreqList.push_back(measResultServFreq);
3913 }
3914 }
3915 return bIterator;
3916}
3917
3920{
3921 int n;
3922 std::bitset<1> isMccPresent;
3923 bIterator = DeserializeSequence(&isMccPresent, false, bIterator);
3924
3925 if (isMccPresent[0])
3926 {
3927 // Deserialize mcc
3928 // ...
3929 }
3930
3931 // Deserialize mnc
3932 int mncDigits;
3933 int mnc = 0;
3934 bIterator = DeserializeSequenceOf(&mncDigits, 3, 2, bIterator);
3935
3936 for (int j = mncDigits - 1; j >= 0; j--)
3937 {
3938 bIterator = DeserializeInteger(&n, 0, 9, bIterator);
3939 mnc += n * pow(10, j);
3940 }
3941
3942 *plmnId = mnc;
3943
3944 // cellReservedForOperatorUse
3945 bIterator = DeserializeEnum(2, &n, bIterator);
3946 return bIterator;
3947}
3948
3951{
3952 std::bitset<0> bitset0;
3953 std::bitset<2> bitset2;
3954 std::bitset<11> bitset11;
3955 int n;
3956
3957 // measConfig
3958 bIterator = DeserializeSequence(&bitset11, true, bIterator);
3959
3960 if (bitset11[10])
3961 {
3962 // measObjectToRemoveList
3963 int measObjectToRemoveListElems;
3964 bIterator =
3965 DeserializeSequenceOf(&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator);
3966
3967 for (int i = 0; i < measObjectToRemoveListElems; i++)
3968 {
3969 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
3970 measConfig->measObjectToRemoveList.push_back(n);
3971 }
3972 }
3973
3974 if (bitset11[9])
3975 {
3976 // measObjectToAddModList
3977 int measObjectToAddModListElems;
3978 bIterator =
3979 DeserializeSequenceOf(&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator);
3980
3981 for (int i = 0; i < measObjectToAddModListElems; i++)
3982 {
3984
3985 bIterator = DeserializeSequence(&bitset0, false, bIterator);
3986
3987 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
3988 elem.measObjectId = n;
3989
3990 int measObjectChoice;
3991 bIterator = DeserializeChoice(4, true, &measObjectChoice, bIterator);
3992
3993 switch (measObjectChoice)
3994 {
3995 case 1:
3996 // Deserialize measObjectUTRA
3997 // ...
3998 break;
3999
4000 case 2:
4001 // Deserialize measObjectGERAN
4002 // ...
4003 break;
4004
4005 case 3:
4006 // Deserialize measObjectCDMA2000
4007 // ...
4008 break;
4009
4010 case 0:
4011 default:
4012 // Deserialize measObjectEUTRA
4013 std::bitset<5> measObjectEutraOpts;
4014 bIterator = DeserializeSequence(&measObjectEutraOpts, true, bIterator);
4015
4016 // carrierFreq
4017 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
4019
4020 // allowedMeasBandwidth
4021 bIterator = DeserializeEnum(6, &n, bIterator);
4023
4024 // presenceAntennaPort1
4025 bIterator =
4027
4028 // neighCellConfig
4029 bIterator = DeserializeBitstring(&bitset2, bIterator);
4030 elem.measObjectEutra.neighCellConfig = bitset2.to_ulong();
4031
4032 // offsetFreq
4033 bIterator = DeserializeQoffsetRange(&elem.measObjectEutra.offsetFreq, bIterator);
4034
4035 if (measObjectEutraOpts[4])
4036 {
4037 // cellsToRemoveList
4038 int numElems;
4039 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4040
4041 for (int i = 0; i < numElems; i++)
4042 {
4043 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4044 elem.measObjectEutra.cellsToRemoveList.push_back(n);
4045 }
4046 }
4047
4048 if (measObjectEutraOpts[3])
4049 {
4050 // cellsToAddModList
4051 int numElems;
4052 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4053
4054 for (int i = 0; i < numElems; i++)
4055 {
4056 LteRrcSap::CellsToAddMod cellsToAddMod;
4057
4058 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4059
4060 // cellIndex
4061 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4062 cellsToAddMod.cellIndex = n;
4063
4064 // PhysCellId
4065 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4066 cellsToAddMod.physCellId = n;
4067
4068 // cellIndividualOffset
4069 bIterator =
4070 DeserializeQoffsetRange(&cellsToAddMod.cellIndividualOffset, bIterator);
4071
4072 elem.measObjectEutra.cellsToAddModList.push_back(cellsToAddMod);
4073 }
4074 }
4075
4076 if (measObjectEutraOpts[2])
4077 {
4078 // blackCellsToRemoveList
4079 int numElems;
4080 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4081
4082 for (int i = 0; i < numElems; i++)
4083 {
4084 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4085 elem.measObjectEutra.blackCellsToRemoveList.push_back(n);
4086 }
4087 }
4088
4089 if (measObjectEutraOpts[1])
4090 {
4091 // blackCellsToAddModList
4092 int numElems;
4093 bIterator = DeserializeSequenceOf(&numElems, MAX_CELL_MEAS, 1, bIterator);
4094
4095 for (int i = 0; i < numElems; i++)
4096 {
4097 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod;
4098 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4099
4100 bIterator = DeserializeInteger(&n, 1, MAX_CELL_MEAS, bIterator);
4101 blackCellsToAddMod.cellIndex = n;
4102
4103 // PhysCellIdRange
4104 std::bitset<1> isRangePresent;
4105 bIterator = DeserializeSequence(&isRangePresent, false, bIterator);
4106
4107 // start
4108 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4109 blackCellsToAddMod.physCellIdRange.start = n;
4110
4111 blackCellsToAddMod.physCellIdRange.haveRange = isRangePresent[0];
4112 // initialize range to silence compiler warning
4113 blackCellsToAddMod.physCellIdRange.range = 0;
4114 if (blackCellsToAddMod.physCellIdRange.haveRange)
4115 {
4116 // range
4117 bIterator = DeserializeEnum(16, &n, bIterator);
4118 switch (n)
4119 {
4120 case 0:
4121 blackCellsToAddMod.physCellIdRange.range = 4;
4122 break;
4123 case 1:
4124 blackCellsToAddMod.physCellIdRange.range = 8;
4125 break;
4126 case 2:
4127 blackCellsToAddMod.physCellIdRange.range = 12;
4128 break;
4129 case 3:
4130 blackCellsToAddMod.physCellIdRange.range = 16;
4131 break;
4132 case 4:
4133 blackCellsToAddMod.physCellIdRange.range = 24;
4134 break;
4135 case 5:
4136 blackCellsToAddMod.physCellIdRange.range = 32;
4137 break;
4138 case 6:
4139 blackCellsToAddMod.physCellIdRange.range = 48;
4140 break;
4141 case 7:
4142 blackCellsToAddMod.physCellIdRange.range = 64;
4143 break;
4144 case 8:
4145 blackCellsToAddMod.physCellIdRange.range = 84;
4146 break;
4147 case 9:
4148 blackCellsToAddMod.physCellIdRange.range = 96;
4149 break;
4150 case 10:
4151 blackCellsToAddMod.physCellIdRange.range = 128;
4152 break;
4153 case 11:
4154 blackCellsToAddMod.physCellIdRange.range = 168;
4155 break;
4156 case 12:
4157 blackCellsToAddMod.physCellIdRange.range = 252;
4158 break;
4159 case 13:
4160 blackCellsToAddMod.physCellIdRange.range = 504;
4161 break;
4162 default:
4163 blackCellsToAddMod.physCellIdRange.range = 0;
4164 }
4165 }
4166
4167 elem.measObjectEutra.blackCellsToAddModList.push_back(blackCellsToAddMod);
4168 }
4169 }
4170
4171 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0];
4172 if (measObjectEutraOpts[0])
4173 {
4174 // cellForWhichToReportCGI
4175 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
4177 }
4178 }
4179 measConfig->measObjectToAddModList.push_back(elem);
4180 }
4181 }
4182
4183 if (bitset11[8])
4184 {
4185 // reportConfigToRemoveList
4186 int reportConfigToRemoveListElems;
4187 bIterator = DeserializeSequenceOf(&reportConfigToRemoveListElems,
4189 1,
4190 bIterator);
4191
4192 for (int i = 0; i < reportConfigToRemoveListElems; i++)
4193 {
4194 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4195 measConfig->reportConfigToRemoveList.push_back(n);
4196 }
4197 }
4198
4199 if (bitset11[7])
4200 {
4201 // reportConfigToAddModList
4202 int reportConfigToAddModListElems;
4203 bIterator = DeserializeSequenceOf(&reportConfigToAddModListElems,
4205 1,
4206 bIterator);
4207
4208 for (int i = 0; i < reportConfigToAddModListElems; i++)
4209 {
4211
4212 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4213 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4214 elem.reportConfigId = n;
4215
4216 // Deserialize reportConfig
4217 int reportConfigChoice;
4218 bIterator = DeserializeChoice(2, false, &reportConfigChoice, bIterator);
4219
4220 if (reportConfigChoice == 0)
4221 {
4222 // reportConfigEUTRA
4223 bIterator = DeserializeSequence(&bitset0, true, bIterator);
4224
4225 // triggerType
4226 int triggerTypeChoice;
4227 bIterator = DeserializeChoice(2, false, &triggerTypeChoice, bIterator);
4228
4229 if (triggerTypeChoice == 0)
4230 {
4231 // event
4233 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4234
4235 // eventId
4236 int eventIdChoice;
4237 bIterator = DeserializeChoice(5, true, &eventIdChoice, bIterator);
4238
4239 switch (eventIdChoice)
4240 {
4241 case 0:
4243 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4245 bIterator);
4246 break;
4247
4248 case 1:
4250 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4252 bIterator);
4253 break;
4254
4255 case 2:
4257 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4258 bIterator = DeserializeInteger(&n, -30, 30, bIterator);
4259 elem.reportConfigEutra.a3Offset = n;
4260 bIterator =
4262 break;
4263
4264 case 3:
4266 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4268 bIterator);
4269 break;
4270
4271 case 4:
4272 default:
4274 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4276 bIterator);
4278 bIterator);
4279 }
4280
4281 bIterator = DeserializeInteger(&n, 0, 30, bIterator);
4283
4284 bIterator = DeserializeEnum(16, &n, bIterator);
4285 switch (n)
4286 {
4287 case 0:
4289 break;
4290 case 1:
4292 break;
4293 case 2:
4295 break;
4296 case 3:
4298 break;
4299 case 4:
4301 break;
4302 case 5:
4304 break;
4305 case 6:
4307 break;
4308 case 7:
4310 break;
4311 case 8:
4313 break;
4314 case 9:
4316 break;
4317 case 10:
4319 break;
4320 case 11:
4322 break;
4323 case 12:
4324 elem.reportConfigEutra.timeToTrigger = 1024;
4325 break;
4326 case 13:
4327 elem.reportConfigEutra.timeToTrigger = 1280;
4328 break;
4329 case 14:
4330 elem.reportConfigEutra.timeToTrigger = 2560;
4331 break;
4332 case 15:
4333 default:
4334 elem.reportConfigEutra.timeToTrigger = 5120;
4335 break;
4336 }
4337 }
4338
4339 if (triggerTypeChoice == 1)
4340 {
4341 // periodical
4343
4344 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4345 bIterator = DeserializeEnum(2, &n, bIterator);
4346 if (n == 0)
4347 {
4350 }
4351 else
4352 {
4354 }
4355 }
4356
4357 // triggerQuantity
4358 bIterator = DeserializeEnum(2, &n, bIterator);
4359 if (n == 0)
4360 {
4362 }
4363 else
4364 {
4366 }
4367
4368 // reportQuantity
4369 bIterator = DeserializeEnum(2, &n, bIterator);
4370 if (n == 0)
4371 {
4374 }
4375 else
4376 {
4378 }
4379
4380 // maxReportCells
4381 bIterator = DeserializeInteger(&n, 1, MAX_CELL_REPORT, bIterator);
4383
4384 // reportInterval
4385 bIterator = DeserializeEnum(16, &n, bIterator);
4386 switch (n)
4387 {
4388 case 0:
4390 break;
4391 case 1:
4393 break;
4394 case 2:
4396 break;
4397 case 3:
4399 break;
4400 case 4:
4402 break;
4403 case 5:
4405 break;
4406 case 6:
4408 break;
4409 case 7:
4411 break;
4412 case 8:
4414 break;
4415 case 9:
4417 break;
4418 case 10:
4420 break;
4421 case 11:
4423 break;
4424 case 12:
4426 break;
4427 case 13:
4429 break;
4430 case 14:
4432 break;
4433 case 15:
4434 default:
4436 }
4437
4438 // reportAmount
4439 bIterator = DeserializeEnum(8, &n, bIterator);
4440 switch (n)
4441 {
4442 case 0:
4444 break;
4445 case 1:
4447 break;
4448 case 2:
4450 break;
4451 case 3:
4453 break;
4454 case 4:
4456 break;
4457 case 5:
4459 break;
4460 case 6:
4462 break;
4463 default:
4465 }
4466 }
4467
4468 if (reportConfigChoice == 1)
4469 {
4470 // ReportConfigInterRAT
4471 // ...
4472 }
4473
4474 measConfig->reportConfigToAddModList.push_back(elem);
4475 }
4476 }
4477
4478 if (bitset11[6])
4479 {
4480 // measIdToRemoveList
4481 int measIdToRemoveListElems;
4482 bIterator = DeserializeSequenceOf(&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator);
4483
4484 for (int i = 0; i < measIdToRemoveListElems; i++)
4485 {
4486 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
4487 measConfig->measIdToRemoveList.push_back(n);
4488 }
4489 }
4490
4491 if (bitset11[5])
4492 {
4493 // measIdToAddModList
4494 int measIdToAddModListElems;
4495 bIterator = DeserializeSequenceOf(&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator);
4496
4497 for (int i = 0; i < measIdToAddModListElems; i++)
4498 {
4500
4501 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4502
4503 bIterator = DeserializeInteger(&n, 1, MAX_MEAS_ID, bIterator);
4504 elem.measId = n;
4505
4506 bIterator = DeserializeInteger(&n, 1, MAX_OBJECT_ID, bIterator);
4507 elem.measObjectId = n;
4508
4509 bIterator = DeserializeInteger(&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
4510 elem.reportConfigId = n;
4511
4512 measConfig->measIdToAddModList.push_back(elem);
4513 }
4514 }
4515
4516 measConfig->haveQuantityConfig = bitset11[4];
4517 if (measConfig->haveQuantityConfig)
4518 {
4519 // quantityConfig
4520 std::bitset<4> quantityConfigOpts;
4521 bIterator = DeserializeSequence(&quantityConfigOpts, true, bIterator);
4522
4523 if (quantityConfigOpts[3])
4524 {
4525 // quantityConfigEUTRA
4526 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4527 bIterator = DeserializeEnum(16, &n, bIterator);
4528 switch (n)
4529 {
4530 case 0:
4531 measConfig->quantityConfig.filterCoefficientRSRP = 0;
4532 break;
4533 case 1:
4534 measConfig->quantityConfig.filterCoefficientRSRP = 1;
4535 break;
4536 case 2:
4537 measConfig->quantityConfig.filterCoefficientRSRP = 2;
4538 break;
4539 case 3:
4540 measConfig->quantityConfig.filterCoefficientRSRP = 3;
4541 break;
4542 case 4:
4543 measConfig->quantityConfig.filterCoefficientRSRP = 4;
4544 break;
4545 case 5:
4546 measConfig->quantityConfig.filterCoefficientRSRP = 5;
4547 break;
4548 case 6:
4549 measConfig->quantityConfig.filterCoefficientRSRP = 6;
4550 break;
4551 case 7:
4552 measConfig->quantityConfig.filterCoefficientRSRP = 7;
4553 break;
4554 case 8:
4555 measConfig->quantityConfig.filterCoefficientRSRP = 8;
4556 break;
4557 case 9:
4558 measConfig->quantityConfig.filterCoefficientRSRP = 9;
4559 break;
4560 case 10:
4561 measConfig->quantityConfig.filterCoefficientRSRP = 11;
4562 break;
4563 case 11:
4564 measConfig->quantityConfig.filterCoefficientRSRP = 13;
4565 break;
4566 case 12:
4567 measConfig->quantityConfig.filterCoefficientRSRP = 15;
4568 break;
4569 case 13:
4570 measConfig->quantityConfig.filterCoefficientRSRP = 17;
4571 break;
4572 case 14:
4573 measConfig->quantityConfig.filterCoefficientRSRP = 19;
4574 break;
4575 case 15:
4576 measConfig->quantityConfig.filterCoefficientRSRP = 0;
4577 break;
4578 default:
4579 measConfig->quantityConfig.filterCoefficientRSRP = 4;
4580 }
4581 bIterator = DeserializeEnum(16, &n, bIterator);
4582 switch (n)
4583 {
4584 case 0:
4585 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
4586 break;
4587 case 1:
4588 measConfig->quantityConfig.filterCoefficientRSRQ = 1;
4589 break;
4590 case 2:
4591 measConfig->quantityConfig.filterCoefficientRSRQ = 2;
4592 break;
4593 case 3:
4594 measConfig->quantityConfig.filterCoefficientRSRQ = 3;
4595 break;
4596 case 4:
4597 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
4598 break;
4599 case 5:
4600 measConfig->quantityConfig.filterCoefficientRSRQ = 5;
4601 break;
4602 case 6:
4603 measConfig->quantityConfig.filterCoefficientRSRQ = 6;
4604 break;
4605 case 7:
4606 measConfig->quantityConfig.filterCoefficientRSRQ = 7;
4607 break;
4608 case 8:
4609 measConfig->quantityConfig.filterCoefficientRSRQ = 8;
4610 break;
4611 case 9:
4612 measConfig->quantityConfig.filterCoefficientRSRQ = 9;
4613 break;
4614 case 10:
4615 measConfig->quantityConfig.filterCoefficientRSRQ = 11;
4616 break;
4617 case 11:
4618 measConfig->quantityConfig.filterCoefficientRSRQ = 13;
4619 break;
4620 case 12:
4621 measConfig->quantityConfig.filterCoefficientRSRQ = 15;
4622 break;
4623 case 13:
4624 measConfig->quantityConfig.filterCoefficientRSRQ = 17;
4625 break;
4626 case 14:
4627 measConfig->quantityConfig.filterCoefficientRSRQ = 19;
4628 break;
4629 case 15:
4630 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
4631 break;
4632 default:
4633 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
4634 }
4635 }
4636 if (quantityConfigOpts[2])
4637 {
4638 // quantityConfigUTRA
4639 // ...
4640 }
4641 if (quantityConfigOpts[1])
4642 {
4643 // quantityConfigGERAN
4644 // ...
4645 }
4646 if (quantityConfigOpts[0])
4647 {
4648 // quantityConfigCDMA2000
4649 // ...
4650 }
4651 }
4652
4653 measConfig->haveMeasGapConfig = bitset11[3];
4654 if (measConfig->haveMeasGapConfig)
4655 {
4656 // measGapConfig
4657 int measGapConfigChoice;
4658 bIterator = DeserializeChoice(2, false, &measGapConfigChoice, bIterator);
4659 switch (measGapConfigChoice)
4660 {
4661 case 0:
4663 bIterator = DeserializeNull(bIterator);
4664 break;
4665 case 1:
4666 default:
4668 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4669
4670 int gapOffsetChoice;
4671 bIterator = DeserializeChoice(2, true, &gapOffsetChoice, bIterator);
4672 switch (gapOffsetChoice)
4673 {
4674 case 0:
4676 bIterator = DeserializeInteger(&n, 0, 39, bIterator);
4677 measConfig->measGapConfig.gapOffsetValue = n;
4678 break;
4679 case 1:
4680 default:
4682 bIterator = DeserializeInteger(&n, 0, 79, bIterator);
4683 measConfig->measGapConfig.gapOffsetValue = n;
4684 }
4685 }
4686 }
4687
4688 measConfig->haveSmeasure = bitset11[2];
4689 if (measConfig->haveSmeasure)
4690 {
4691 // s-Measure
4692 bIterator = DeserializeInteger(&n, 0, 97, bIterator);
4693 measConfig->sMeasure = n;
4694 }
4695
4696 if (bitset11[1])
4697 {
4698 // preRegistrationInfoHRPD
4699 // ...
4700 }
4701
4702 measConfig->haveSpeedStatePars = bitset11[0];
4703 if (measConfig->haveSpeedStatePars)
4704 {
4705 // speedStatePars
4706 int speedStateParsChoice;
4707 bIterator = DeserializeChoice(2, false, &speedStateParsChoice, bIterator);
4708 switch (speedStateParsChoice)
4709 {
4710 case 0:
4712 bIterator = DeserializeNull(bIterator);
4713 break;
4714 case 1:
4715 default:
4717 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4718
4719 // Deserialize mobilityStateParameters
4720 // Deserialize t-Evaluation
4721 bIterator = DeserializeEnum(8, &n, bIterator);
4722 switch (n)
4723 {
4724 case 0:
4726 break;
4727 case 1:
4729 break;
4730 case 2:
4732 break;
4733 case 3:
4735 break;
4736 case 4:
4738 break;
4739 default:
4741 }
4742 // Deserialize t-HystNormal
4743 bIterator = DeserializeEnum(8, &n, bIterator);
4744 switch (n)
4745 {
4746 case 0:
4748 break;
4749 case 1:
4751 break;
4752 case 2:
4754 break;
4755 case 3:
4757 break;
4758 case 4:
4760 break;
4761 default:
4763 }
4764
4765 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
4767
4768 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
4770
4771 // Deserialize timeToTriggerSf
4772 bIterator = DeserializeEnum(4, &n, bIterator);
4773 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25;
4774 bIterator = DeserializeEnum(4, &n, bIterator);
4775 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25;
4776 }
4777 }
4778 return bIterator;
4779}
4780
4782
4783// Constructor
4786{
4787 m_mmec = std::bitset<8>(0UL);
4788 m_mTmsi = std::bitset<32>(0UL);
4790 m_spare = std::bitset<1>(0UL);
4791}
4792
4793// Destructor
4795{
4796}
4797
4798TypeId
4800{
4801 static TypeId tid =
4802 TypeId("ns3::RrcConnectionRequestHeader").SetParent<Header>().SetGroupName("Lte");
4803 return tid;
4804}
4805
4806void
4808{
4809 os << "MMEC:" << m_mmec << std::endl;
4810 os << "MTMSI:" << m_mTmsi << std::endl;
4811 os << "EstablishmentCause:" << m_establishmentCause << std::endl;
4812 os << "Spare: " << m_spare << std::endl;
4813}
4814
4815void
4817{
4819
4821
4822 // Serialize RRCConnectionRequest sequence:
4823 // no default or optional fields. Extension marker not present.
4824 SerializeSequence(std::bitset<0>(), false);
4825
4826 // Serialize criticalExtensions choice:
4827 // 2 options, selected: 0 (option: rrcConnectionRequest-r8)
4828 SerializeChoice(2, 0, false);
4829
4830 // Serialize RRCConnectionRequest-r8-IEs sequence:
4831 // no default or optional fields. Extension marker not present.
4832 SerializeSequence(std::bitset<0>(), false);
4833
4834 // Serialize InitialUE-Identity choice:
4835 // 2 options, selected: 0 (option: s-TMSI)
4836 SerializeChoice(2, 0, false);
4837
4838 // Serialize S-TMSI sequence:
4839 // no default or optional fields. Extension marker not present.
4840 SerializeSequence(std::bitset<0>(), false);
4841
4842 // Serialize mmec : MMEC ::= BIT STRING (SIZE (8))
4844
4845 // Serialize m-TMSI ::= BIT STRING (SIZE (32))
4847
4848 // Serialize establishmentCause : EstablishmentCause ::= ENUMERATED
4850
4851 // Serialize spare : BIT STRING (SIZE (1))
4852 SerializeBitstring(std::bitset<1>());
4853
4854 // Finish serialization
4856}
4857
4860{
4861 std::bitset<1> dummy;
4862 std::bitset<0> optionalOrDefaultMask;
4863 int selectedOption;
4864
4865 bIterator = DeserializeUlCcchMessage(bIterator);
4866
4867 // Deserialize RCConnectionRequest sequence
4868 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4869
4870 // Deserialize criticalExtensions choice:
4871 bIterator = DeserializeChoice(2, false, &selectedOption, bIterator);
4872
4873 // Deserialize RRCConnectionRequest-r8-IEs sequence
4874 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4875
4876 // Deserialize InitialUE-Identity choice
4877 bIterator = DeserializeChoice(2, false, &selectedOption, bIterator);
4878
4879 // Deserialize S-TMSI sequence
4880 bIterator = DeserializeSequence(&optionalOrDefaultMask, false, bIterator);
4881
4882 // Deserialize mmec
4883 bIterator = DeserializeBitstring(&m_mmec, bIterator);
4884
4885 // Deserialize m-TMSI
4886 bIterator = DeserializeBitstring(&m_mTmsi, bIterator);
4887
4888 // Deserialize establishmentCause
4889 bIterator = DeserializeEnum(8, &selectedOption, bIterator);
4890
4891 // Deserialize spare
4892 bIterator = DeserializeBitstring(&dummy, bIterator);
4893
4894 return GetSerializedSize();
4895}
4896
4897void
4899{
4900 m_mTmsi = std::bitset<32>((uint32_t)msg.ueIdentity);
4901 m_mmec = std::bitset<8>((uint32_t)(msg.ueIdentity >> 32));
4902 m_isDataSerialized = false;
4903}
4904
4907{
4909 msg.ueIdentity = (((uint64_t)m_mmec.to_ulong()) << 32) | (m_mTmsi.to_ulong());
4910
4911 return msg;
4912}
4913
4914std::bitset<8>
4916{
4917 return m_mmec;
4918}
4919
4920std::bitset<32>
4922{
4923 return m_mTmsi;
4924}
4925
4928{
4929}
4930
4932{
4933}
4934
4935void
4936RrcConnectionSetupHeader::Print(std::ostream& os) const
4937{
4938 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
4939 os << "radioResourceConfigDedicated:" << std::endl;
4941}
4942
4943void
4945{
4947
4949
4950 SerializeInteger(15, 0, 15);
4951
4952 // Serialize RRCConnectionSetup sequence:
4953 // no default or optional fields. Extension marker not present.
4954 SerializeSequence(std::bitset<0>(), false);
4955
4956 // Serialize rrc-TransactionIdentifier ::=INTEGER (0..3)
4958
4959 // Serialize criticalExtensions choice:
4960 // 2 options, selected: 0 (option: c1)
4961 SerializeChoice(2, 0, false);
4962
4963 // Serialize c1 choice:
4964 // 8 options, selected: 0 (option: rrcConnectionSetup-r8)
4965 SerializeChoice(8, 0, false);
4966
4967 // Serialize rrcConnectionSetup-r8 sequence
4968 // 1 optional fields (not present). Extension marker not present.
4969 SerializeSequence(std::bitset<1>(0), false);
4970
4971 // Serialize RadioResourceConfigDedicated sequence
4973
4974 // Serialize nonCriticalExtension sequence
4975 // 2 optional fields, none present. No extension marker.
4976 SerializeSequence(std::bitset<2>(0), false);
4977
4978 // Finish serialization
4980}
4981
4984{
4985 int n;
4986
4987 std::bitset<0> bitset0;
4988 std::bitset<1> bitset1;
4989 std::bitset<2> bitset2;
4990
4991 bIterator = DeserializeDlCcchMessage(bIterator);
4992
4993 bIterator = DeserializeInteger(&n, 0, 15, bIterator);
4994
4995 // Deserialize RRCConnectionSetup sequence
4996 bIterator = DeserializeSequence(&bitset0, false, bIterator);
4997
4998 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3)
4999 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5001
5002 // Deserialize criticalExtensions choice
5003 int criticalExtensionChoice;
5004 bIterator = DeserializeChoice(2, false, &criticalExtensionChoice, bIterator);
5005 if (criticalExtensionChoice == 1)
5006 {
5007 // Deserialize criticalExtensionsFuture
5008 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5009 }
5010 else if (criticalExtensionChoice == 0)
5011 {
5012 // Deserialize c1
5013 int c1;
5014 bIterator = DeserializeChoice(8, false, &c1, bIterator);
5015
5016 if (c1 > 0)
5017 {
5018 // Deserialize spareX , X:=7..1
5019 bIterator = DeserializeNull(bIterator);
5020 }
5021 else if (c1 == 0)
5022 {
5023 // Deserialize rrcConnectionSetup-r8
5024 // 1 optional fields, no extension marker.
5025 bIterator = DeserializeSequence(&bitset1, false, bIterator);
5026
5027 // Deserialize radioResourceConfigDedicated
5028 bIterator =
5030
5031 if (bitset1[0])
5032 {
5033 // Deserialize nonCriticalExtension
5034 // 2 optional fields, no extension marker.
5035 bIterator = DeserializeSequence(&bitset2, false, bIterator);
5036
5037 // Deserialization of lateR8NonCriticalExtension and nonCriticalExtension
5038 // ...
5039 }
5040 }
5041 }
5042 return GetSerializedSize();
5043}
5044
5045void
5047{
5050 m_isDataSerialized = false;
5051}
5052
5055{
5059 return msg;
5060}
5061
5062uint8_t
5064{
5066}
5067
5068bool
5070{
5072}
5073
5074std::list<LteRrcSap::SrbToAddMod>
5076{
5078}
5079
5080std::list<LteRrcSap::DrbToAddMod>
5082{
5084}
5085
5086std::list<uint8_t>
5088{
5090}
5091
5094{
5096}
5097
5100{
5102}
5103
5105
5107{
5108}
5109
5111{
5112}
5113
5114void
5116{
5118
5119 // Serialize DCCH message
5121
5122 // Serialize RRCConnectionSetupComplete sequence:
5123 // no default or optional fields. Extension marker not present.
5124 SerializeSequence(std::bitset<0>(), false);
5125
5126 // Serialize rrc-TransactionIdentifier
5128
5129 // Serialize criticalExtensions choice
5130 // 2 options, selected 0 (c1)
5131 SerializeChoice(2, 0, false);
5132
5133 // Choose spare3 NULL
5134 SerializeChoice(4, 1, false);
5135
5136 // Serialize spare3 NULL
5137 SerializeNull();
5138
5139 // Finish serialization
5141}
5142
5145{
5146 std::bitset<0> bitset0;
5147
5148 bIterator = DeserializeUlDcchMessage(bIterator);
5149
5150 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5151
5152 int n;
5153 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5155
5156 bIterator = DeserializeChoice(2, false, &n, bIterator);
5157
5158 if (n == 1)
5159 {
5160 // Deserialize criticalExtensionsFuture
5161 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5162 }
5163 else if (n == 0)
5164 {
5165 // Deserialize c1
5166 int c1Chosen;
5167 bIterator = DeserializeChoice(4, false, &c1Chosen, bIterator);
5168
5169 if (c1Chosen == 0)
5170 {
5171 // Deserialize rrcConnectionSetupComplete-r8
5172 // ...
5173 }
5174 else
5175 {
5176 bIterator = DeserializeNull(bIterator);
5177 }
5178 }
5179
5180 return GetSerializedSize();
5181}
5182
5183void
5185{
5186 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5187}
5188
5189void
5191{
5193 m_isDataSerialized = false;
5194}
5195
5196uint8_t
5198{
5200}
5201
5204{
5207 return msg;
5208}
5209
5211
5213{
5214}
5215
5217{
5218}
5219
5220void
5222{
5224
5225 // Serialize DCCH message
5227
5228 // Serialize RRCConnectionSetupComplete sequence:
5229 // no default or optional fields. Extension marker not present.
5230 SerializeSequence(std::bitset<0>(), false);
5231
5232 // Serialize rrc-TransactionIdentifier
5234
5235 // Serialize criticalExtensions choice
5236 // 2 options, selected 1 (criticalExtensionsFuture)
5237 SerializeChoice(2, 1, false);
5238
5239 // Choose criticalExtensionsFuture
5240 SerializeSequence(std::bitset<0>(), false);
5241
5242 // Finish serialization
5244}
5245
5248{
5249 std::bitset<0> bitset0;
5250 int n;
5251
5252 bIterator = DeserializeUlDcchMessage(bIterator);
5253 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5254
5255 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5257
5258 bIterator = DeserializeChoice(2, false, &n, bIterator);
5259
5260 if (n == 1)
5261 {
5262 // Deserialize criticalExtensionsFuture
5263 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5264 }
5265 else if (n == 0)
5266 {
5267 // Deserialize rrcConnectionReconfigurationComplete-r8
5268 // ...
5269 }
5270
5271 return GetSerializedSize();
5272}
5273
5274void
5276{
5277 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5278}
5279
5280void
5283{
5285 m_isDataSerialized = false;
5286}
5287
5290{
5293 return msg;
5294}
5295
5296uint8_t
5298{
5300}
5301
5303
5305{
5306}
5307
5309{
5310}
5311
5312void
5314{
5316
5318
5319 // Serialize RRCConnectionSetupComplete sequence:
5320 // no default or optional fields. Extension marker not present.
5321 SerializeSequence(std::bitset<0>(), false);
5322
5323 // Serialize rrc-TransactionIdentifier
5325
5326 // Serialize criticalExtensions choice
5327 // 2 options, selected 0 (c1)
5328 SerializeChoice(2, 0, false);
5329
5330 // Serialize c1 choice
5331 // 8 options, selected 0 (rrcConnectionReconfiguration-r8)
5332 SerializeChoice(8, 0, false);
5333
5334 // Serialize RRCConnectionReconfiguration-r8-IEs sequence:
5335 // 6 optional fields. Extension marker not present.
5336 std::bitset<6> options;
5337 options.set(5, m_haveMeasConfig);
5338 options.set(4, m_haveMobilityControlInfo);
5339 options.set(3, 0); // No dedicatedInfoNASList
5340 options.set(2, m_haveRadioResourceConfigDedicated);
5341 options.set(1, 0); // No securityConfigHO
5342 options.set(0, m_haveNonCriticalExtension); // Implemented nonCriticalExtension because
5343 // compatibility with R10 - CA
5344 SerializeSequence(options, false);
5345
5346 if (m_haveMeasConfig)
5347 {
5349 }
5350
5352 {
5353 // Serialize MobilityControlInfo
5354
5355 // 4 optional fields, extension marker present.
5356 std::bitset<4> mobCtrlIntoOptional;
5357 mobCtrlIntoOptional.set(3, m_mobilityControlInfo.haveCarrierFreq);
5358 mobCtrlIntoOptional.set(2, m_mobilityControlInfo.haveCarrierBandwidth);
5359 mobCtrlIntoOptional.set(1, 0); // No additionalSpectrumEmission
5360 mobCtrlIntoOptional.set(0, m_mobilityControlInfo.haveRachConfigDedicated);
5361 SerializeSequence(mobCtrlIntoOptional, true);
5362
5363 // Serialize targetPhysCellId
5365
5367 {
5368 SerializeSequence(std::bitset<1>(1), false);
5371 }
5372
5374 {
5375 SerializeSequence(std::bitset<1>(1), false);
5376
5377 // Serialize dl-Bandwidth
5379
5380 // Serialize ul-Bandwidth
5382 }
5383
5384 // Serialize t304
5385 SerializeEnum(8, 0);
5386
5387 // Serialize newUE-Identity
5389
5390 // Serialize radioResourceConfigCommon
5392
5394 {
5395 SerializeSequence(std::bitset<0>(), false);
5398 }
5399 }
5400
5402 {
5403 // Serialize RadioResourceConfigDedicated
5405 }
5406
5408 {
5409 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v890-IEs sequence:
5410 // 2 optional fields. Extension marker not present.
5411 std::bitset<2> noncriticalExtension_v890;
5412 noncriticalExtension_v890.set(1, 0); // No lateNonCriticalExtension
5413 noncriticalExtension_v890.set(
5414 0,
5415 m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility
5416 // with R10 - CA
5417 // Enable RRCCoonectionReconfiguration-v920-IEs
5418 SerializeSequence(noncriticalExtension_v890, false);
5419
5420 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v920-IEs sequence:
5421 // 3 optional fields. Extension marker not present.
5422 std::bitset<3> noncriticalExtension_v920;
5423 noncriticalExtension_v920.set(1, 0); // No otherConfig-r9
5424 noncriticalExtension_v920.set(1, 0); // No fullConfig-r9
5425 // Enable RRCCoonectionReconfiguration-v1020-IEs
5426 noncriticalExtension_v920.set(
5427 0,
5428 m_haveNonCriticalExtension); // Implemented nonCriticalExtension because compatibility
5429 // with R10 - CA
5430 SerializeSequence(noncriticalExtension_v920, false);
5431
5433 m_nonCriticalExtension); // Serializing RRCConnectionReconfiguration-r8-IEs
5434 }
5435
5436 // Finish serialization
5438}
5439
5442{
5443 std::bitset<0> bitset0;
5444
5445 bIterator = DeserializeDlDcchMessage(bIterator);
5446
5447 // RRCConnectionReconfiguration sequence
5448 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5449
5450 // rrc-TransactionIdentifier
5451 int n;
5452 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
5454
5455 // criticalExtensions
5456 int sel;
5457 bIterator = DeserializeChoice(2, false, &sel, bIterator);
5458 if (sel == 1)
5459 {
5460 // criticalExtensionsFuture
5461 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5462 }
5463 else if (sel == 0)
5464 {
5465 // c1
5466 int c1Chosen;
5467 bIterator = DeserializeChoice(8, false, &c1Chosen, bIterator);
5468 if (c1Chosen > 0)
5469 {
5470 bIterator = DeserializeNull(bIterator);
5471 }
5472 else if (c1Chosen == 0)
5473 {
5474 // rrcConnectionReconfiguration-r8
5475 std::bitset<6> rrcConnRecOpts;
5476 bIterator = DeserializeSequence(&rrcConnRecOpts, false, bIterator);
5477
5478 m_haveMeasConfig = rrcConnRecOpts[5];
5479 if (m_haveMeasConfig)
5480 {
5481 bIterator = DeserializeMeasConfig(&m_measConfig, bIterator);
5482 }
5483
5484 m_haveMobilityControlInfo = rrcConnRecOpts[4];
5486 {
5487 // mobilityControlInfo
5488 std::bitset<4> mobCtrlOpts;
5489 bIterator = DeserializeSequence(&mobCtrlOpts, true, bIterator);
5490
5491 // PhysCellId
5492 bIterator = DeserializeInteger(&n, 0, 503, bIterator);
5494
5495 // carrierFreq
5496 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3];
5498 {
5499 std::bitset<1> ulCarrierFreqPresent;
5500 bIterator = DeserializeSequence(&ulCarrierFreqPresent, false, bIterator);
5501
5502 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
5504
5505 if (ulCarrierFreqPresent[0])
5506 {
5507 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
5509 }
5510 }
5511
5512 // carrierBandwidth
5515 {
5516 std::bitset<1> ulBandwidthPresent;
5517 bIterator = DeserializeSequence(&ulBandwidthPresent, false, bIterator);
5518
5519 bIterator = DeserializeEnum(16, &n, bIterator);
5521
5522 if (ulBandwidthPresent[0])
5523 {
5524 bIterator = DeserializeEnum(16, &n, bIterator);
5526 }
5527 }
5528
5529 // additionalSpectrumEmission
5530 if (mobCtrlOpts[1])
5531 {
5532 // ...
5533 }
5534
5535 // t304
5536 bIterator = DeserializeEnum(8, &n, bIterator);
5537
5538 // newUE-Identity
5539 std::bitset<16> cRnti;
5540 bIterator = DeserializeBitstring(&cRnti, bIterator);
5541 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong();
5542
5543 // radioResourceConfigCommon
5546 bIterator);
5547
5550 {
5551 bIterator = DeserializeSequence(&bitset0, false, bIterator);
5552 bIterator = DeserializeInteger(&n, 0, 63, bIterator);
5554 bIterator = DeserializeInteger(&n, 0, 15, bIterator);
5556 }
5557 }
5558
5559 // dedicatedInfoNASList
5560 if (rrcConnRecOpts[3])
5561 {
5562 // ...
5563 }
5564
5565 // radioResourceConfigDedicated
5566 m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2];
5568 {
5570 bIterator);
5571 }
5572
5573 // securityConfigHO
5574 if (rrcConnRecOpts[1])
5575 {
5576 // ...
5577 }
5578
5579 // nonCriticalExtension
5580 m_haveNonCriticalExtension = rrcConnRecOpts[0];
5582 {
5583 bIterator =
5585 // ...
5586 }
5587 }
5588 }
5589
5590 return GetSerializedSize();
5591}
5592
5593void
5595{
5596 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5597 os << "haveMeasConfig: " << m_haveMeasConfig << std::endl;
5598 if (m_haveMeasConfig)
5599 {
5601 {
5602 os << " measObjectToRemoveList: ";
5603 std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
5604 std::list<uint8_t>::iterator it = auxList.begin();
5605 for (; it != auxList.end(); it++)
5606 {
5607 os << (int)*it << ", ";
5608 }
5609 os << std::endl;
5610 }
5612 {
5613 os << " reportConfigToRemoveList: ";
5614 std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
5615 std::list<uint8_t>::iterator it = auxList.begin();
5616 for (; it != auxList.end(); it++)
5617 {
5618 os << (int)*it << ", ";
5619 }
5620 os << std::endl;
5621 }
5622 if (!m_measConfig.measIdToRemoveList.empty())
5623 {
5624 os << " measIdToRemoveList: ";
5625 std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
5626 std::list<uint8_t>::iterator it = auxList.begin();
5627 for (; it != auxList.end(); it++)
5628 {
5629 os << (int)*it << ", ";
5630 }
5631 os << std::endl;
5632 }
5633
5635 {
5636 os << " measObjectToAddMod: " << std::endl;
5637 std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.measObjectToAddModList;
5638 std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = auxList.begin();
5639 for (; it != auxList.end(); it++)
5640 {
5641 os << " measObjectId: " << (int)it->measObjectId << std::endl;
5642 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl;
5643 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth
5644 << std::endl;
5645 os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1
5646 << std::endl;
5647 os << " neighCellConfig: " << (int)it->measObjectEutra.neighCellConfig
5648 << std::endl;
5649 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl;
5650
5651 if (!it->measObjectEutra.cellsToRemoveList.empty())
5652 {
5653 os << " cellsToRemoveList: ";
5654 std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemoveList;
5655 std::list<uint8_t>::iterator it = auxList.begin();
5656 for (; it != auxList.end(); it++)
5657 {
5658 os << (int)*it << ", ";
5659 }
5660 os << std::endl;
5661 }
5662
5663 if (!it->measObjectEutra.blackCellsToRemoveList.empty())
5664 {
5665 os << " blackCellsToRemoveList: ";
5666 std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToRemoveList;
5667 std::list<uint8_t>::iterator it = auxList.begin();
5668 for (; it != auxList.end(); it++)
5669 {
5670 os << (int)*it << ", ";
5671 }
5672 os << std::endl;
5673 }
5674
5675 if (!it->measObjectEutra.cellsToAddModList.empty())
5676 {
5677 os << " cellsToAddModList: " << std::endl;
5678 std::list<LteRrcSap::CellsToAddMod> auxList =
5679 it->measObjectEutra.cellsToAddModList;
5680 std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.begin();
5681 for (; it != auxList.end(); it++)
5682 {
5683 os << " cellIndex: " << (int)it->cellIndex << std::endl;
5684 os << " physCellId: " << (int)it->physCellId << std::endl;
5685 os << " cellIndividualOffset: " << (int)it->cellIndividualOffset
5686 << std::endl;
5687 os << " ------ " << std::endl;
5688 }
5689 }
5690
5691 if (!it->measObjectEutra.blackCellsToAddModList.empty())
5692 {
5693 os << " blackCellsToAddModList: " << std::endl;
5694 std::list<LteRrcSap::BlackCellsToAddMod> auxList =
5695 it->measObjectEutra.blackCellsToAddModList;
5696 std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxList.begin();
5697 for (; it != auxList.end(); it++)
5698 {
5699 os << " cellIndex: " << (int)it->cellIndex << std::endl;
5700 os << " physCellIdRange.start: " << (int)it->physCellIdRange.start
5701 << std::endl;
5702 os << " physCellIdRange.haveRange: " << it->physCellIdRange.haveRange
5703 << std::endl;
5704 os << " physCellIdRange.range: " << (int)it->physCellIdRange.range
5705 << std::endl;
5706 os << " ------ " << std::endl;
5707 }
5708 }
5709
5710 os << " haveCellForWhichToReportCGI: "
5711 << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl;
5712 os << " cellForWhichToReportCGI: "
5713 << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl;
5714 os << " ------------- " << std::endl;
5715 }
5716 }
5717
5719 {
5720 os << " reportConfigToAddModList: " << std::endl;
5721 std::list<LteRrcSap::ReportConfigToAddMod> auxList =
5723 std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = auxList.begin();
5724 for (; it != auxList.end(); it++)
5725 {
5726 os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
5727 os << " reportConfigEutra.triggerType "
5728 << (int)it->reportConfigEutra.triggerType << std::endl;
5729 if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEutra::EVENT)
5730 {
5731 os << " reportConfigEutra.eventId " << (int)it->reportConfigEutra.eventId
5732 << std::endl;
5733 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A3)
5734 {
5735 os << " reportConfigEutra.reportOnLeave "
5736 << (int)it->reportConfigEutra.reportOnLeave << std::endl;
5737 os << " reportConfigEutra.a3Offset "
5738 << (int)it->reportConfigEutra.a3Offset << std::endl;
5739 }
5740 else
5741 {
5742 os << " reportConfigEutra.threshold1.choice "
5743 << (int)it->reportConfigEutra.threshold1.choice << std::endl;
5744 os << " reportConfigEutra.threshold1.range "
5745 << (int)it->reportConfigEutra.threshold1.range << std::endl;
5746 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::EVENT_A5)
5747 {
5748 os << " reportConfigEutra.threshold2.choice "
5749 << (int)it->reportConfigEutra.threshold2.choice << std::endl;
5750 os << " reportConfigEutra.threshold2.range "
5751 << (int)it->reportConfigEutra.threshold2.range << std::endl;
5752 }
5753 }
5754 os << " reportConfigEutra.hysteresis "
5755 << (int)it->reportConfigEutra.hysteresis << std::endl;
5756 os << " reportConfigEutra.timeToTrigger "
5757 << (int)it->reportConfigEutra.timeToTrigger << std::endl;
5758 }
5759 else
5760 {
5761 os << " reportConfigEutra.purpose " << (int)it->reportConfigEutra.purpose
5762 << std::endl;
5763 }
5764 os << " reportConfigEutra.triggerQuantity "
5765 << (int)it->reportConfigEutra.triggerQuantity << std::endl;
5766 os << " reportConfigEutra.reportQuantity "
5767 << (int)it->reportConfigEutra.reportQuantity << std::endl;
5768 os << " reportConfigEutra.maxReportCells "
5769 << (int)it->reportConfigEutra.maxReportCells << std::endl;
5770 os << " reportConfigEutra.reportInterval "
5771 << (int)it->reportConfigEutra.reportInterval << std::endl;
5772 os << " reportConfigEutra.reportAmount "
5773 << (int)it->reportConfigEutra.reportAmount << std::endl;
5774 }
5775 }
5776
5777 if (!m_measConfig.measIdToAddModList.empty())
5778 {
5779 os << " measIdToAddModList: " << std::endl;
5780 std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdToAddModList;
5781 std::list<LteRrcSap::MeasIdToAddMod>::iterator it = auxList.begin();
5782 for (; it != auxList.end(); it++)
5783 {
5784 os << " measId: " << (int)it->measId << std::endl;
5785 os << " measObjectId: " << (int)it->measObjectId << std::endl;
5786 os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
5787 os << " ------ " << std::endl;
5788 }
5789 }
5790
5791 os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl;
5793 {
5794 os << " filterCoefficientRSRP: "
5796 os << " filterCoefficientRSRQ:"
5798 }
5799
5800 os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl;
5802 {
5803 os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl;
5804 os << " measGapConfig.gap (gap0/1,value): ("
5806 << (int)m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl;
5807 }
5808
5809 os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl;
5811 {
5812 os << " sMeasure: " << (int)m_measConfig.sMeasure << std::endl;
5813 }
5814
5815 os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl;
5817 {
5818 os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl;
5819 os << " speedStatePars.mobilityStateParameters.tEvaluation: "
5821 os << " speedStatePars.mobilityStateParameters.tHystNormal: "
5823 os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: "
5825 << std::endl;
5826 os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: "
5828 << std::endl;
5829 os << " speedStatePars.timeToTriggerSf.sfMedium: "
5831 os << " speedStatePars.timeToTriggerSf.sfHigh: "
5833 }
5834 }
5835
5836 os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl;
5838 {
5839 os << "targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellId << std::endl;
5840 os << "haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << std::endl;
5842 {
5843 os << " carrierFreq.dlCarrierFreq: "
5844 << (int)m_mobilityControlInfo.carrierFreq.dlCarrierFreq << std::endl;
5845 os << " carrierFreq.dlCarrierFreq: "
5846 << (int)m_mobilityControlInfo.carrierFreq.ulCarrierFreq << std::endl;
5847 }
5848 os << "haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandwidth << std::endl;
5850 {
5851 os << " carrierBandwidth.dlBandwidth: "
5853 os << " carrierBandwidth.ulBandwidth: "
5855 }
5856 os << "newUeIdentity: " << (int)m_mobilityControlInfo.newUeIdentity << std::endl;
5857 os << "haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfigDedicated
5858 << std::endl;
5860 {
5861 os << "raPreambleIndex: "
5863 os << "raPrachMaskIndex: "
5865 }
5866 }
5867 os << "haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedicated << std::endl;
5869 {
5871 }
5872}
5873
5874void
5876{
5886
5887 m_isDataSerialized = false;
5888}
5889
5892{
5894
5904
5905 return msg;
5906}
5907
5908uint8_t
5910{
5912}
5913
5914bool
5916{
5917 return m_haveMeasConfig;
5918}
5919
5922{
5923 return m_measConfig;
5924}
5925
5926bool
5928{
5930}
5931
5934{
5935 return m_mobilityControlInfo;
5936}
5937
5938bool
5940{
5942}
5943
5946{
5948}
5949
5950bool
5952{
5954}
5955
5958{
5960}
5961
5962bool
5964{
5966}
5967
5968std::list<LteRrcSap::SrbToAddMod>
5970{
5972}
5973
5974std::list<LteRrcSap::DrbToAddMod>
5976{
5978}
5979
5980std::list<uint8_t>
5982{
5984}
5985
5988{
5990}
5991
5993
5995{
5996}
5997
5998void
6000{
6002
6003 // Serialize HandoverPreparationInformation sequence:
6004 // no default or optional fields. Extension marker not present.
6005 SerializeSequence(std::bitset<0>(), false);
6006
6007 // Serialize criticalExtensions choice
6008 // 2 options, selected 0 (c1)
6009 SerializeChoice(2, 0, false);
6010
6011 // Serialize c1 choice
6012 // 8 options, selected 0 (handoverPreparationInformation-r8)
6013 SerializeChoice(8, 0, false);
6014
6015 // Serialize HandoverPreparationInformation-r8-IEs sequence
6016 // 4 optional fields, no extension marker.
6017 std::bitset<4> handoverPrepInfoOpts;
6018 handoverPrepInfoOpts.set(3, 1); // as-Config present
6019 handoverPrepInfoOpts.set(2, 0); // rrm-Config not present
6020 handoverPrepInfoOpts.set(1, 0); // as-Context not present
6021 handoverPrepInfoOpts.set(0, 0); // nonCriticalExtension not present
6022 SerializeSequence(handoverPrepInfoOpts, false);
6023
6024 // Serialize ue-RadioAccessCapabilityInfo
6026
6027 // Serialize as-Config
6028 SerializeSequence(std::bitset<0>(), true);
6029
6030 // Serialize sourceMeasConfig
6032
6033 // Serialize sourceRadioResourceConfig
6035
6036 // Serialize sourceSecurityAlgorithmConfig
6037 SerializeSequence(std::bitset<0>(), false);
6038 // cipheringAlgorithm
6039 SerializeEnum(8, 0);
6040 // integrityProtAlgorithm
6041 SerializeEnum(8, 0);
6042
6043 // Serialize sourceUE-Identity
6045
6046 // Serialize sourceMasterInformationBlock
6047 SerializeSequence(std::bitset<0>(), false);
6049 6,
6051 SerializeSequence(std::bitset<0>(), false); // phich-Config sequence
6052 SerializeEnum(2, 0); // phich-Duration
6053 SerializeEnum(4, 0); // phich-Resource
6054 SerializeBitstring(std::bitset<8>(
6056 SerializeBitstring(std::bitset<10>(321)); // spare
6057
6058 // Serialize sourceSystemInformationBlockType1 sequence
6060
6061 // Serialize sourceSystemInformationBlockType2
6063
6064 // Serialize AntennaInfoCommon
6065 SerializeSequence(std::bitset<0>(0), false);
6066 SerializeEnum(4, 0); // antennaPortsCount
6067
6068 // Serialize sourceDlCarrierFreq
6070
6071 // Finish serialization
6073}
6074
6077{
6078 std::bitset<0> bitset0;
6079 int n;
6080
6081 // Deserialize HandoverPreparationInformation sequence
6082 // 0 optional fields, no extension marker
6083 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6084
6085 // Deserialize criticalExtensions choice
6086 int criticalExtensionsChosen;
6087 bIterator = DeserializeChoice(2, false, &criticalExtensionsChosen, bIterator);
6088
6089 if (criticalExtensionsChosen == 1)
6090 {
6091 // Deserialize criticalExtensionsFuture
6092 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6093 }
6094 else if (criticalExtensionsChosen == 0)
6095 {
6096 // Deserialize c1 choice
6097 int c1Chosen;
6098 bIterator = DeserializeChoice(8, false, &c1Chosen, bIterator);
6099 if (c1Chosen > 0)
6100 {
6101 bIterator = DeserializeNull(bIterator);
6102 }
6103 else if (c1Chosen == 0)
6104 {
6105 // Deserialize handoverPreparationInformation-r8
6106 std::bitset<4> handoverPrepInfoOpts;
6107 bIterator = DeserializeSequence(&handoverPrepInfoOpts, false, bIterator);
6108
6109 // Deserialize ue-RadioAccessCapabilityInfo
6110 bIterator = DeserializeSequenceOf(&n, MAX_RAT_CAPABILITIES, 0, bIterator);
6111 for (int i = 0; i < n; i++)
6112 {
6113 // Deserialize UE-CapabilityRAT-Container
6114 // ...
6115 }
6116
6117 if (handoverPrepInfoOpts[3])
6118 {
6119 // Deserialize as-Config sequence
6120 bIterator = DeserializeSequence(&bitset0, true, bIterator);
6121
6122 // Deserialize sourceMeasConfig
6123 bIterator = DeserializeMeasConfig(&m_asConfig.sourceMeasConfig, bIterator);
6124
6125 // Deserialize sourceRadioResourceConfig
6126 bIterator =
6128 bIterator);
6129
6130 // Deserialize sourceSecurityAlgorithmConfig
6131 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6132 bIterator = DeserializeEnum(8, &n, bIterator); // cipheringAlgorithm
6133 bIterator = DeserializeEnum(8, &n, bIterator); // integrityProtAlgorithm
6134
6135 // Deserialize sourceUE-Identity
6136 std::bitset<16> cRnti;
6137 bIterator = DeserializeBitstring(&cRnti, bIterator);
6138 m_asConfig.sourceUeIdentity = cRnti.to_ulong();
6139
6140 // Deserialize sourceMasterInformationBlock
6141 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6142 bIterator = DeserializeEnum(6, &n, bIterator); // dl-Bandwidth
6144
6145 // phich-Config
6146 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6147 bIterator = DeserializeEnum(2, &n, bIterator); // phich-Duration
6148 bIterator = DeserializeEnum(4, &n, bIterator); // phich-Resource
6149
6150 // systemFrameNumber
6151 std::bitset<8> systemFrameNumber;
6152 bIterator = DeserializeBitstring(&systemFrameNumber, bIterator);
6154 systemFrameNumber.to_ulong();
6155 // spare
6156 std::bitset<10> spare;
6157 bIterator = DeserializeBitstring(&spare, bIterator);
6158
6159 // Deserialize sourceSystemInformationBlockType1
6162 bIterator);
6163
6164 // Deserialize sourceSystemInformationBlockType2
6167 bIterator);
6168
6169 // Deserialize antennaInfoCommon
6170 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6171 bIterator = DeserializeEnum(4, &n, bIterator); // antennaPortsCount
6172
6173 // Deserialize sourceDl-CarrierFreq
6174 bIterator = DeserializeInteger(&n, 0, MAX_EARFCN, bIterator);
6176 }
6177 if (handoverPrepInfoOpts[2])
6178 {
6179 // Deserialize rrm-Config
6180 // ...
6181 }
6182 if (handoverPrepInfoOpts[1])
6183 {
6184 // Deserialize as-Context
6185 // ...
6186 }
6187 if (handoverPrepInfoOpts[0])
6188 {
6189 // Deserialize nonCriticalExtension
6190 // ...
6191 }
6192 }
6193 }
6194
6195 return GetSerializedSize();
6196}
6197
6198void
6200{
6202 os << "sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl;
6203 os << "dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBandwidth << std::endl;
6204 os << "systemFrameNumber: " << (int)m_asConfig.sourceMasterInformationBlock.systemFrameNumber
6205 << std::endl;
6206 os << "plmnIdentityInfo.plmnIdentity: "
6209 << std::endl;
6210 os << "cellAccessRelatedInfo.cellIdentity "
6212 << std::endl;
6213 os << "cellAccessRelatedInfo.csgIndication: "
6215 << std::endl;
6216 os << "cellAccessRelatedInfo.csgIdentity: "
6218 << std::endl;
6219 os << "sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl;
6220}
6221
6222void
6224{
6225 m_asConfig = msg.asConfig;
6226 m_isDataSerialized = false;
6227}
6228
6231{
6233 msg.asConfig = m_asConfig;
6234
6235 return msg;
6236}
6237
6240{
6241 return m_asConfig;
6242}
6243
6245
6247{
6248}
6249
6251{
6252}
6253
6254void
6256{
6258
6260
6261 // Serialize RrcConnectionReestablishmentRequest sequence:
6262 // no default or optional fields. Extension marker not present.
6263 SerializeSequence(std::bitset<0>(), false);
6264
6265 // Serialize criticalExtensions choice
6266 // chosen: rrcConnectionReestablishmentRequest-r8
6267 SerializeChoice(2, 0, false);
6268
6269 // Serialize RRCConnectionReestablishmentRequest-r8-IEs sequence
6270 // no default or optional fields. Extension marker not present.
6271 SerializeSequence(std::bitset<0>(), false);
6272
6273 // Serialize ue-Identity
6274 SerializeSequence(std::bitset<0>(), false);
6275 // Serialize c-RNTI
6276 SerializeBitstring(std::bitset<16>(m_ueIdentity.cRnti));
6277 // Serialize physCellId
6279 // Serialize shortMAC-I
6280 SerializeBitstring(std::bitset<16>(0));
6281
6282 // Serialize ReestablishmentCause
6283 switch (m_reestablishmentCause)
6284 {
6286 SerializeEnum(4, 0);
6287 break;
6289 SerializeEnum(4, 1);
6290 break;
6292 SerializeEnum(4, 2);
6293 break;
6294 default:
6295 SerializeEnum(4, 3);
6296 }
6297
6298 // Serialize spare
6299 SerializeBitstring(std::bitset<2>(0));
6300
6301 // Finish serialization
6303}
6304
6307{
6308 std::bitset<0> bitset0;
6309 int n;
6310
6311 bIterator = DeserializeUlCcchMessage(bIterator);
6312
6313 // Deserialize RrcConnectionReestablishmentRequest sequence
6314 // 0 optional fields, no extension marker
6315 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6316
6317 // Deserialize criticalExtensions choice
6318 bIterator = DeserializeChoice(2, false, &n, bIterator);
6319 if (n == 1)
6320 {
6321 // Deserialize criticalExtensionsFuture
6322 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6323 }
6324 else if (n == 0)
6325 {
6326 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs
6327 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6328
6329 // Deserialize ReestabUE-Identity sequence
6330 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6331
6332 // Deserialize c-RNTI
6333 std::bitset<16> cRnti;
6334 bIterator = DeserializeBitstring(&cRnti, bIterator);
6335 m_ueIdentity.cRnti = cRnti.to_ulong();
6336
6337 // Deserialize physCellId
6338 int physCellId;
6339 bIterator = DeserializeInteger(&physCellId, 0, 503, bIterator);
6340 m_ueIdentity.physCellId = physCellId;
6341
6342 // Deserialize shortMAC-I
6343 std::bitset<16> shortMacI;
6344 bIterator = DeserializeBitstring(&shortMacI, bIterator);
6345
6346 // Deserialize ReestablishmentCause
6347 int reestCs;
6348 bIterator = DeserializeEnum(4, &reestCs, bIterator);
6349 switch (reestCs)
6350 {
6351 case 0:
6353 break;
6354 case 1:
6356 break;
6357 case 2:
6359 break;
6360 case 3:
6361 break;
6362 }
6363
6364 // Deserialize spare
6365 std::bitset<2> spare;
6366 bIterator = DeserializeBitstring(&spare, bIterator);
6367 }
6368
6369 return GetSerializedSize();
6370}
6371
6372void
6374{
6375 os << "ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl;
6376 os << "ueIdentity.physCellId: " << (int)m_ueIdentity.physCellId << std::endl;
6377 os << "m_reestablishmentCause: " << m_reestablishmentCause << std::endl;
6378}
6379
6380void
6383{
6386 m_isDataSerialized = false;
6387}
6388
6391{
6395
6396 return msg;
6397}
6398
6401{
6402 return m_ueIdentity;
6403}
6404
6407{
6409}
6410
6412
6414{
6415}
6416
6418{
6419}
6420
6421void
6423{
6425
6427
6428 // Serialize RrcConnectionReestablishment sequence:
6429 // no default or optional fields. Extension marker not present.
6430 SerializeSequence(std::bitset<0>(), false);
6431
6432 // Serialize rrc-TransactionIdentifier
6434
6435 // Serialize criticalExtensions choice
6436 SerializeChoice(2, 0, false);
6437
6438 // Serialize c1 choice
6439 SerializeChoice(8, 0, false);
6440
6441 // Serialize RRCConnectionReestablishment-r8-IEs sequence
6442 // 1 optional field, no extension marker
6443 SerializeSequence(std::bitset<1>(0), false);
6444
6445 // Serialize radioResourceConfigDedicated
6447
6448 // Serialize nextHopChainingCount
6449 SerializeInteger(0, 0, 7);
6450
6451 // Finish serialization
6453}
6454
6457{
6458 std::bitset<0> bitset0;
6459 int n;
6460
6461 bIterator = DeserializeDlCcchMessage(bIterator);
6462
6463 // Deserialize RrcConnectionReestablishment sequence
6464 // 0 optional fields, no extension marker
6465 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6466
6467 // Deserialize rrc-TransactionIdentifier
6468 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6470
6471 // Deserialize criticalExtensions choice
6472 int criticalExtensionsChoice;
6473 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6474 if (criticalExtensionsChoice == 1)
6475 {
6476 // Deserialize criticalExtensionsFuture
6477 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6478 }
6479 else if (criticalExtensionsChoice == 0)
6480 {
6481 // Deserialize c1
6482 int c1;
6483 bIterator = DeserializeChoice(8, false, &c1, bIterator);
6484 if (c1 > 0)
6485 {
6486 bIterator = DeserializeNull(bIterator);
6487 }
6488 else if (c1 == 0)
6489 {
6490 // Deserialize rrcConnectionReestablishment-r8
6491 // 1 optional field
6492 std::bitset<1> nonCriticalExtensionPresent;
6493 bIterator = DeserializeSequence(&nonCriticalExtensionPresent, false, bIterator);
6494
6495 // Deserialize RadioResourceConfigDedicated
6496 bIterator =
6498
6499 // Deserialize nextHopChainingCount
6500 bIterator = DeserializeInteger(&n, 0, 7, bIterator);
6501 }
6502 }
6503
6504 return GetSerializedSize();
6505}
6506
6507void
6509{
6510 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
6511 os << "RadioResourceConfigDedicated: " << std::endl;
6513}
6514
6515void
6517{
6520 m_isDataSerialized = false;
6521}
6522
6525{
6529 return msg;
6530}
6531
6532uint8_t
6534{
6536}
6537
6540{
6542}
6543
6545
6547{
6548}
6549
6550void
6552{
6554
6555 // Serialize DCCH message
6557
6558 // Serialize RrcConnectionReestablishmentComplete sequence:
6559 // no default or optional fields. Extension marker not present.
6560 SerializeSequence(std::bitset<0>(), false);
6561
6562 // Serialize rrc-TransactionIdentifier
6564
6565 // Serialize criticalExtensions choice
6566 SerializeChoice(2, 0, false);
6567
6568 // Serialize rrcConnectionReestablishmentComplete-r8 sequence
6569 // 1 optional field (not present), no extension marker.
6570 SerializeSequence(std::bitset<1>(0), false);
6571
6572 // Finish serialization
6574}
6575
6578{
6579 std::bitset<0> bitset0;
6580 int n;
6581
6582 bIterator = DeserializeUlDcchMessage(bIterator);
6583
6584 // Deserialize RrcConnectionReestablishmentComplete sequence
6585 // 0 optional fields, no extension marker
6586 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6587
6588 // Deserialize rrc-TransactionIdentifier
6589 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6591
6592 // Deserialize criticalExtensions choice
6593 int criticalExtensionsChoice;
6594 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6595 if (criticalExtensionsChoice == 1)
6596 {
6597 // Deserialize criticalExtensionsFuture
6598 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6599 }
6600 else if (criticalExtensionsChoice == 0)
6601 {
6602 // Deserialize rrcConnectionReestablishmentComplete-r8
6603 std::bitset<1> opts;
6604 bIterator = DeserializeSequence(&opts, false, bIterator);
6605 if (opts[0])
6606 {
6607 // Deserialize RRCConnectionReestablishmentComplete-v920-IEs
6608 // ...
6609 }
6610 }
6611
6612 return GetSerializedSize();
6613}
6614
6615void
6617{
6618 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
6619}
6620
6621void
6624{
6626 m_isDataSerialized = false;
6627}
6628
6631{
6634 return msg;
6635}
6636
6637uint8_t
6639{
6641}
6642
6644
6646{
6647}
6648
6650{
6651}
6652
6653void
6655{
6657
6658 // Serialize CCCH message
6660
6661 // Serialize RrcConnectionReestablishmentReject sequence:
6662 // no default or optional fields. Extension marker not present.
6663 SerializeSequence(std::bitset<0>(), false);
6664
6665 // Serialize criticalExtensions choice
6666 SerializeChoice(2, 0, false);
6667
6668 // Serialize RRCConnectionReestablishmentReject-r8-IEs sequence
6669 // 1 optional field (not present), no extension marker.
6670 SerializeSequence(std::bitset<1>(0), false);
6671
6672 // Finish serialization
6674}
6675
6678{
6679 std::bitset<0> bitset0;
6680
6681 bIterator = DeserializeDlCcchMessage(bIterator);
6682
6683 // Deserialize RrcConnectionReestablishmentReject sequence
6684 // 0 optional fields, no extension marker
6685 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6686
6687 // Deserialize criticalExtensions choice
6688 int criticalExtensionsChoice;
6689 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6690 if (criticalExtensionsChoice == 1)
6691 {
6692 // Deserialize criticalExtensionsFuture
6693 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6694 }
6695 else if (criticalExtensionsChoice == 0)
6696 {
6697 // Deserialize rrcConnectionReestablishmentReject-r8
6698 std::bitset<1> opts;
6699 bIterator = DeserializeSequence(&opts, false, bIterator);
6700 if (opts[0])
6701 {
6702 // Deserialize RRCConnectionReestablishmentReject-v8a0-IEs
6703 // ...
6704 }
6705 }
6706
6707 return GetSerializedSize();
6708}
6709
6710void
6712{
6713}
6714
6715void
6718{
6720 m_isDataSerialized = false;
6721}
6722
6725{
6727}
6728
6730
6732{
6733}
6734
6736{
6737}
6738
6739void
6741{
6743
6744 // Serialize DCCH message
6746
6747 // Serialize RrcConnectionRelease sequence:
6748 // no default or optional fields. Extension marker not present.
6749 SerializeSequence(std::bitset<0>(), false);
6750
6751 // Serialize rrc-TransactionIdentifier
6753
6754 // Serialize criticalExtensions choice
6755 SerializeChoice(2, 0, false);
6756
6757 // Serialize c1 choice
6758 SerializeChoice(4, 0, false);
6759
6760 // Serialize RRCConnectionRelease-r8-IEs sequence
6761 // 3 optional field (not present), no extension marker.
6762 SerializeSequence(std::bitset<3>(0), false);
6763
6764 // Serialize ReleaseCause
6765 SerializeEnum(4, 1);
6766
6767 // Finish serialization
6769}
6770
6773{
6774 std::bitset<0> bitset0;
6775 int n;
6776
6777 bIterator = DeserializeDlDcchMessage(bIterator);
6778
6779 // Deserialize RrcConnectionRelease sequence
6780 // 0 optional fields, no extension marker
6781 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6782
6783 // Deserialize rrc-TransactionIdentifier
6784 bIterator = DeserializeInteger(&n, 0, 3, bIterator);
6786
6787 // Deserialize criticalExtensions choice
6788 int criticalExtensionsChoice;
6789 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6790 if (criticalExtensionsChoice == 1)
6791 {
6792 // Deserialize criticalExtensionsFuture
6793 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6794 }
6795 else if (criticalExtensionsChoice == 0)
6796 {
6797 // Deserialize c1
6798 int c1Choice;
6799 bIterator = DeserializeChoice(4, false, &c1Choice, bIterator);
6800
6801 if (c1Choice == 0)
6802 {
6803 // Deserialize RRCConnectionRelease-r8-IEs
6804 std::bitset<3> opts;
6805 bIterator = DeserializeSequence(&opts, false, bIterator);
6806
6807 // Deserialize releaseCause
6808 bIterator = DeserializeEnum(4, &n, bIterator);
6809
6810 if (opts[2])
6811 {
6812 // Deserialize redirectedCarrierInfo
6813 // ...
6814 }
6815 if (opts[1])
6816 {
6817 // Deserialize idleModeMobilityControlInfo
6818 // ...
6819 }
6820 if (opts[0])
6821 {
6822 // Deserialize nonCriticalExtension
6823 // ...
6824 }
6825 }
6826
6827 else
6828 {
6829 bIterator = DeserializeNull(bIterator);
6830 }
6831 }
6832
6833 return GetSerializedSize();
6834}
6835
6836void
6838{
6839}
6840
6841void
6843{
6845 m_isDataSerialized = false;
6846}
6847
6850{
6852}
6853
6855
6857{
6858}
6859
6861{
6862}
6863
6864void
6866{
6868
6869 // Serialize CCCH message
6871
6872 // Serialize RrcConnectionReject sequence:
6873 // no default or optional fields. Extension marker not present.
6874 SerializeSequence(std::bitset<0>(), false);
6875
6876 // Serialize criticalExtensions choice
6877 SerializeChoice(2, 0, false);
6878
6879 // Serialize c1 choice
6880 SerializeChoice(4, 0, false);
6881
6882 // Serialize rrcConnectionReject-r8 sequence
6883 // 1 optional field (not present), no extension marker.
6884 SerializeSequence(std::bitset<1>(0), false);
6885
6886 // Serialize waitTime
6888
6889 // Finish serialization
6891}
6892
6895{
6896 std::bitset<0> bitset0;
6897 int n;
6898
6899 bIterator = DeserializeDlCcchMessage(bIterator);
6900
6901 // Deserialize RrcConnectionReject sequence
6902 // 0 optional fields, no extension marker
6903 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6904
6905 // Deserialize criticalExtensions choice
6906 int criticalExtensionsChoice;
6907 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
6908 if (criticalExtensionsChoice == 1)
6909 {
6910 // Deserialize criticalExtensionsFuture
6911 bIterator = DeserializeSequence(&bitset0, false, bIterator);
6912 }
6913 else if (criticalExtensionsChoice == 0)
6914 {
6915 // Deserialize c1 choice
6916 int c1Choice;
6917 bIterator = DeserializeChoice(4, false, &c1Choice, bIterator);
6918
6919 if (c1Choice > 0)
6920 {
6921 bIterator = DeserializeNull(bIterator);
6922 }
6923 else if (c1Choice == 0)
6924 {
6925 // Deserialize rrcConnectionReject-r8
6926 std::bitset<1> opts;
6927 bIterator = DeserializeSequence(&opts, false, bIterator);
6928
6929 bIterator = DeserializeInteger(&n, 1, 16, bIterator);
6931
6932 if (opts[0])
6933 {
6934 // Deserialize RRCConnectionReject-v8a0-IEs
6935 // ...
6936 }
6937 }
6938 }
6939
6940 return GetSerializedSize();
6941}
6942
6943void
6945{
6946 os << "wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl;
6947}
6948
6949void
6951{
6953 m_isDataSerialized = false;
6954}
6955
6958{
6959 return m_rrcConnectionReject;
6960}
6961
6963
6965{
6966}
6967
6969{
6970}
6971
6972void
6974{
6976
6977 // Serialize DCCH message
6979
6980 // Serialize MeasurementReport sequence:
6981 // no default or optional fields. Extension marker not present.
6982 SerializeSequence(std::bitset<0>(), false);
6983
6984 // Serialize criticalExtensions choice:
6985 // c1 chosen
6986 SerializeChoice(2, 0, false);
6987
6988 // Serialize c1 choice
6989 // measurementReport-r8 chosen
6990 SerializeChoice(8, 0, false);
6991
6992 // Serialize MeasurementReport-r8-IEs sequence:
6993 // 1 optional fields, not present. Extension marker not present.
6994 SerializeSequence(std::bitset<1>(0), false);
6995
6996 // Serialize measResults
6998
6999 // Finish serialization
7001}
7002
7005{
7006 std::bitset<0> bitset0;
7007
7008 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7009
7010 bIterator = DeserializeUlDcchMessage(bIterator);
7011
7012 int criticalExtensionsChoice;
7013 bIterator = DeserializeChoice(2, false, &criticalExtensionsChoice, bIterator);
7014
7015 if (criticalExtensionsChoice == 1)
7016 {
7017 // Deserialize criticalExtensionsFuture
7018 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7019 }
7020 else if (criticalExtensionsChoice == 0)
7021 {
7022 // Deserialize c1
7023 int c1Choice;
7024 bIterator = DeserializeChoice(8, false, &c1Choice, bIterator);
7025
7026 if (c1Choice > 0)
7027 {
7028 bIterator = DeserializeNull(bIterator);
7029 }
7030 else
7031 {
7032 // Deserialize measurementReport-r8
7033 std::bitset<1> isNonCriticalExtensionPresent;
7034 bIterator = DeserializeSequence(&isNonCriticalExtensionPresent, false, bIterator);
7035
7036 // Deserialize measResults
7038
7039 if (isNonCriticalExtensionPresent[0])
7040 {
7041 // Deserialize nonCriticalExtension MeasurementReport-v8a0-IEs
7042 // ...
7043 }
7044 }
7045 }
7046
7047 return GetSerializedSize();
7048}
7049
7050void
7051MeasurementReportHeader::Print(std::ostream& os) const
7052{
7053 os << "measId = " << (int)m_measurementReport.measResults.measId << std::endl;
7054 os << "rsrpResult = " << (int)m_measurementReport.measResults.measResultPCell.rsrpResult
7055 << std::endl;
7056 os << "rsrqResult = " << (int)m_measurementReport.measResults.measResultPCell.rsrqResult
7057 << std::endl;
7058 os << "haveMeasResultNeighCells = "
7060
7062 {
7063 std::list<LteRrcSap::MeasResultEutra> measResultListEutra =
7065 std::list<LteRrcSap::MeasResultEutra>::iterator it = measResultListEutra.begin();
7066 for (; it != measResultListEutra.end(); it++)
7067 {
7068 os << " physCellId =" << (int)it->physCellId << std::endl;
7069 os << " haveCgiInfo =" << it->haveCgiInfo << std::endl;
7070 if (it->haveCgiInfo)
7071 {
7072 os << " plmnIdentity = " << (int)it->cgiInfo.plmnIdentity << std::endl;
7073 os << " cellIdentity = " << (int)it->cgiInfo.cellIdentity << std::endl;
7074 os << " trackingAreaCode = " << (int)it->cgiInfo.trackingAreaCode << std::endl;
7075 os << " havePlmnIdentityList = " << !it->cgiInfo.plmnIdentityList.empty()
7076 << std::endl;
7077 if (!it->cgiInfo.plmnIdentityList.empty())
7078 {
7079 for (std::list<uint32_t>::iterator it2 = it->cgiInfo.plmnIdentityList.begin();
7080 it2 != it->cgiInfo.plmnIdentityList.end();
7081 it2++)
7082 {
7083 os << " plmnId : " << *it2 << std::endl;
7084 }
7085 }
7086 }
7087
7088 os << " haveRsrpResult =" << it->haveRsrpResult << std::endl;
7089 if (it->haveRsrpResult)
7090 {
7091 os << " rsrpResult =" << (int)it->rsrpResult << std::endl;
7092 }
7093
7094 os << " haveRsrqResult =" << it->haveRsrqResult << std::endl;
7095 if (it->haveRsrqResult)
7096 {
7097 os << " rsrqResult =" << (int)it->rsrqResult << std::endl;
7098 }
7099 }
7100 }
7101}
7102
7103void
7105{
7106 m_measurementReport = msg;
7107 m_isDataSerialized = false;
7108}
7109
7112{
7114 msg = m_measurementReport;
7115 return msg;
7116}
7117
7120 : RrcAsn1Header()
7121{
7122}
7123
7125{
7126}
7127
7130{
7131 DeserializeUlDcchMessage(bIterator);
7132 return 1;
7133}
7134
7135void
7136RrcUlDcchMessage::Print(std::ostream& os) const
7137{
7138 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl;
7139}
7140
7141void
7143{
7145}
7146
7149{
7150 std::bitset<0> bitset0;
7151 int n;
7152
7153 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7154 bIterator = DeserializeChoice(2, false, &n, bIterator);
7155 if (n == 1)
7156 {
7157 // Deserialize messageClassExtension
7158 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7159 m_messageType = -1;
7160 }
7161 else if (n == 0)
7162 {
7163 // Deserialize c1
7164 bIterator = DeserializeChoice(16, false, &m_messageType, bIterator);
7165 }
7166
7167 return bIterator;
7168}
7169
7170void
7172{
7173 SerializeSequence(std::bitset<0>(), false);
7174 // Choose c1
7175 SerializeChoice(2, 0, false);
7176 // Choose message type
7177 SerializeChoice(16, messageType, false);
7178}
7179
7182 : RrcAsn1Header()
7183{
7184}
7185
7187{
7188}
7189
7192{
7193 DeserializeDlDcchMessage(bIterator);
7194 return 1;
7195}
7196
7197void
7198RrcDlDcchMessage::Print(std::ostream& os) const
7199{
7200 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl;
7201}
7202
7203void
7205{
7207}
7208
7211{
7212 std::bitset<0> bitset0;
7213 int n;
7214
7215 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7216 bIterator = DeserializeChoice(2, false, &n, bIterator);
7217 if (n == 1)
7218 {
7219 // Deserialize messageClassExtension
7220 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7221 m_messageType = -1;
7222 }
7223 else if (n == 0)
7224 {
7225 // Deserialize c1
7226 bIterator = DeserializeChoice(16, false, &m_messageType, bIterator);
7227 }
7228
7229 return bIterator;
7230}
7231
7232void
7234{
7235 SerializeSequence(std::bitset<0>(), false);
7236 // Choose c1
7237 SerializeChoice(2, 0, false);
7238 // Choose message type
7239 SerializeChoice(16, messageType, false);
7240}
7241
7244 : RrcAsn1Header()
7245{
7246}
7247
7249{
7250}
7251
7254{
7255 DeserializeUlCcchMessage(bIterator);
7256 return 1;
7257}
7258
7259void
7260RrcUlCcchMessage::Print(std::ostream& os) const
7261{
7262 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl;
7263}
7264
7265void
7267{
7269}
7270
7273{
7274 std::bitset<0> bitset0;
7275 int n;
7276
7277 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7278 bIterator = DeserializeChoice(2, false, &n, bIterator);
7279 if (n == 1)
7280 {
7281 // Deserialize messageClassExtension
7282 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7283 m_messageType = -1;
7284 }
7285 else if (n == 0)
7286 {
7287 // Deserialize c1
7288 bIterator = DeserializeChoice(2, false, &m_messageType, bIterator);
7289 }
7290
7291 return bIterator;
7292}
7293
7294void
7296{
7297 SerializeSequence(std::bitset<0>(), false);
7298 // Choose c1
7299 SerializeChoice(2, 0, false);
7300 // Choose message type
7301 SerializeChoice(2, messageType, false);
7302}
7303
7306 : RrcAsn1Header()
7307{
7308}
7309
7311{
7312}
7313
7316{
7317 DeserializeDlCcchMessage(bIterator);
7318 return 1;
7319}
7320
7321void
7322RrcDlCcchMessage::Print(std::ostream& os) const
7323{
7324 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl;
7325}
7326
7327void
7329{
7331}
7332
7335{
7336 std::bitset<0> bitset0;
7337 int n;
7338
7339 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7340 bIterator = DeserializeChoice(2, false, &n, bIterator);
7341 if (n == 1)
7342 {
7343 // Deserialize messageClassExtension
7344 bIterator = DeserializeSequence(&bitset0, false, bIterator);
7345 m_messageType = -1;
7346 }
7347 else if (n == 0)
7348 {
7349 // Deserialize c1
7350 bIterator = DeserializeChoice(4, false, &m_messageType, bIterator);
7351 }
7352
7353 return bIterator;
7354}
7355
7356void
7358{
7359 SerializeSequence(std::bitset<0>(), false);
7360 // Choose c1
7361 SerializeChoice(2, 0, false);
7362 // Choose message type
7363 SerializeChoice(4, messageType, false);
7364}
7365
7366} // namespace ns3
Buffer::Iterator DeserializeChoice(int numOptions, bool isExtensionMarkerPresent, int *selectedOption, Buffer::Iterator bIterator)
Deserialize a Choice (set of options)
Buffer::Iterator DeserializeSequenceOf(int *numElems, int nMax, int nMin, Buffer::Iterator bIterator)
Deserialize a Sequence.
Buffer::Iterator DeserializeNull(Buffer::Iterator bIterator)
Deserialize nothing (null op)
Buffer::Iterator DeserializeInteger(int *n, int nmin, int nmax, Buffer::Iterator bIterator)
Deserialize an integer.
void SerializeBitstring(std::bitset< N > bitstring) const
Serialize a bitstring.
Buffer::Iterator DeserializeEnum(int numElems, int *selectedElem, Buffer::Iterator bIterator)
Deserialize an Enum.
Buffer::Iterator DeserializeSequence(std::bitset< N > *optionalOrDefaultMask, bool isExtensionMarkerPresent, Buffer::Iterator bIterator)
Deserialize a sequence.
void SerializeSequence(std::bitset< N > optionalOrDefaultMask, bool isExtensionMarkerPresent) const
Serialize a sequence.
void SerializeChoice(int numOptions, int selectedOption, bool isExtensionMarkerPresent) const
Serialize a Choice (set of options)
Buffer m_serializationResult
serialization result
void FinalizeSerialization() const
Finalizes an in progress serialization.
void SerializeInteger(int n, int nmin, int nmax) const
Serialize an Integer.
Buffer::Iterator DeserializeBoolean(bool *value, Buffer::Iterator bIterator)
Deserialize a boolean.
uint32_t GetSerializedSize() const override
void SerializeBoolean(bool value) const
Serialize a bool.
Buffer::Iterator DeserializeBitstring(std::bitset< N > *bitstring, Buffer::Iterator bIterator)
Deserialize a bitstring.
void SerializeNull() const
Serialize nothing (null op)
bool m_isDataSerialized
true if data is serialized
void SerializeSequenceOf(int numElems, int nMax, int nMin) const
Serialize a Sequence.
void SerializeEnum(int numElems, int selectedElem) const
Serialize an Enum.
iterator in a Buffer instance
Definition: buffer.h:100
automatically resized byte buffer
Definition: buffer.h:94
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void SetMessage(LteRrcSap::HandoverPreparationInfo msg)
Receives a HandoverPreparationInfo IE and stores the contents into the class attributes.
LteRrcSap::HandoverPreparationInfo GetMessage() const
Returns a HandoverPreparationInfo IE from the values in the class attributes.
LteRrcSap::AsConfig m_asConfig
AS config.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::AsConfig GetAsConfig() const
Getter for m_asConfig.
Protocol header serialization and deserialization.
Definition: header.h:44
ReestablishmentCause
ReestablishmentCause enumeration.
Definition: lte-rrc-sap.h:614
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::MeasurementReport m_measurementReport
measurement report
LteRrcSap::MeasurementReport GetMessage() const
Returns a MeasurementReport IE from the values in the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::MeasurementReport msg)
Receives a MeasurementReport IE and stores the contents into the class attributes.
This class extends Asn1Header functions, adding serialization/deserialization of some Information ele...
void SerializeNonCriticalExtensionConfiguration(LteRrcSap::NonCriticalExtensionConfiguration nonCriticalExtensionConfiguration) const
Serialize non critical extension config function.
void SerializeSrbToAddModList(std::list< LteRrcSap::SrbToAddMod > srbToAddModList) const
Serialize SRB to add mod list function.
void SerializeSystemInformationBlockType2(LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2) const
Serialize system information block type 2 function.
void SerializeRadioResourceConfigCommonSCell(LteRrcSap::RadioResourceConfigCommonSCell rrccsc) const
Serialize radio resource config common SCell function.
void SerializeMeasResults(LteRrcSap::MeasResults measResults) const
Serialize measure results function.
void SerializePhysicalConfigDedicated(LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const
Serialize physical config dedicated function.
Buffer::Iterator DeserializeCellIdentification(LteRrcSap::CellIdentification *ci, Buffer::Iterator bIterator)
Deserialize cell identification function.
Buffer::Iterator DeserializeLogicalChannelConfig(LteRrcSap::LogicalChannelConfig *logicalChannelConfig, Buffer::Iterator bIterator)
Deserialize logical channel config function.
void SerializeRachConfigCommon(LteRrcSap::RachConfigCommon rachConfigCommon) const
Serialize RACH config common function.
Buffer::Iterator DeserializeMeasConfig(LteRrcSap::MeasConfig *measConfig, Buffer::Iterator bIterator)
Deserialize measure config function.
int GetMessageType() const
Get message type.
Buffer::Iterator DeserializePhysicalConfigDedicated(LteRrcSap::PhysicalConfigDedicated *physicalConfigDedicated, Buffer::Iterator bIterator)
Deserialize physical config dedicated function.
Buffer::Iterator DeserializeNonCriticalExtensionConfig(LteRrcSap::NonCriticalExtensionConfiguration *nonCriticalExtension, Buffer::Iterator bIterator)
Deserialize non critical extension config function.
void SerializeRadioResourceConfigCommonSib(LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const
Serialize radio resource config common SIB function.
void SerializeSystemInformationBlockType1(LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const
Serialize system information block type 1 function.
Buffer::Iterator DeserializeRachConfigCommon(LteRrcSap::RachConfigCommon *rachConfigCommon, Buffer::Iterator bIterator)
Deserialize RACH config common function.
Buffer::Iterator DeserializePlmnIdentity(uint32_t *plmnId, Buffer::Iterator bIterator)
Deserialize PLMN identity function.
uint16_t EnumToBandwidth(int n) const
Convert from ENUMERATED value to bandwidth (in RBs)
void SerializeDrbToAddModList(std::list< LteRrcSap::DrbToAddMod > drbToAddModList) const
Serialize DRB to add mod list function.
Buffer::Iterator DeserializeMeasResults(LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator)
Deserialize measure results function.
Buffer::Iterator DeserializeRadioResourceConfigCommonSCell(LteRrcSap::RadioResourceConfigCommonSCell *rrccsc, Buffer::Iterator bIterator)
Deserialize radio resource config common SCell function.
void SerializeRadioResourceDedicatedSCell(LteRrcSap::RadioResourceConfigDedicatedSCell rrcdsc) const
Serialize radio resource dedicated SCell function.
void SerializePhysicalConfigDedicatedSCell(LteRrcSap::PhysicalConfigDedicatedSCell pcdsc) const
Serialize physical config dedicated function.
TypeId GetInstanceTypeId() const override
Get the most derived TypeId for this Object.
Buffer::Iterator DeserializePhysicalConfigDedicatedSCell(LteRrcSap::PhysicalConfigDedicatedSCell *pcdsc, Buffer::Iterator bIterator)
Deserialize physical config dedicated SCell function.
Buffer::Iterator DeserializeThresholdEutra(LteRrcSap::ThresholdEutra *thresholdEutra, Buffer::Iterator bIterator)
Deserialize threshold eutra function.
void SerializeRadioResourceConfigDedicated(LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const
Serialize radio resource config function.
void SerializeThresholdEutra(LteRrcSap::ThresholdEutra thresholdEutra) const
Serialize threshold eutra function.
void SerializeQoffsetRange(int8_t qOffsetRange) const
Serialize Q offset range function.
Buffer::Iterator DeserializeRadioResourceConfigDedicated(LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator)
Deserialize radio resource config dedicated function.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
int m_messageType
Stores RRC message type, according to 3GPP TS 36.331.
Buffer::Iterator DeserializeSystemInformationBlockType1(LteRrcSap::SystemInformationBlockType1 *systemInformationBlockType1, Buffer::Iterator bIterator)
Deserialize system information block type 1 function.
void SerializeLogicalChannelConfig(LteRrcSap::LogicalChannelConfig logicalChannelConfig) const
Serialize logicala channel config function.
static TypeId GetTypeId()
Get the type ID.
Buffer::Iterator DeserializeSystemInformationBlockType2(LteRrcSap::SystemInformationBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator)
Deserialize system information block type 2 function.
Buffer::Iterator DeserializeQoffsetRange(int8_t *qOffsetRange, Buffer::Iterator bIterator)
Deserialize Qoffset range function.
int BandwidthToEnum(uint16_t bandwidth) const
Convert from bandwidth (in RBs) to ENUMERATED value.
Buffer::Iterator DeserializeDrbToAddModList(std::list< LteRrcSap::DrbToAddMod > *drbToAddModLis, Buffer::Iterator bIterator)
Deserialize DRB to add mod list function.
void SerializePlmnIdentity(uint32_t plmnId) const
Serialize PLMN identity function.
Buffer::Iterator DeserializeRadioResourceConfigCommon(LteRrcSap::RadioResourceConfigCommon *radioResourceConfigCommon, Buffer::Iterator bIterator)
Deserialize radio resource config common function.
Buffer::Iterator DeserializeRadioResourceConfigDedicatedSCell(LteRrcSap::RadioResourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator)
Deserialize radio resource config dedicated SCell function.
void SerializeRadioResourceConfigCommon(LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const
Serialize system information block type 2 function.
void SerializeMeasConfig(LteRrcSap::MeasConfig measConfig) const
Serialize measure config function.
Buffer::Iterator DeserializeSrbToAddModList(std::list< LteRrcSap::SrbToAddMod > *srbToAddModList, Buffer::Iterator bIterator)
Deserialize SRB to add mod list function.
Buffer::Iterator DeserializeRadioResourceConfigCommonSib(LteRrcSap::RadioResourceConfigCommonSib *radioResourceConfigCommonSib, Buffer::Iterator bIterator)
Deserialize radio resource config common SIB function.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::RrcConnectionReconfigurationCompleted GetMessage() const
Returns a RrcConnectionReconfigurationCompleted IE from the values in the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReconfigurationCompleted msg)
Receives a RrcConnectionReconfigurationCompleted IE and stores the contents into the class attributes...
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
bool m_haveNonCriticalExtension
Have non-critical extension.
std::list< LteRrcSap::SrbToAddMod > GetSrbToAddModList() const
Gets m_radioResourceConfigDedicated.srbToAddModList.
bool m_haveMeasConfig
have measure config?
std::list< LteRrcSap::DrbToAddMod > GetDrbToAddModList() const
Gets m_radioResourceConfigDedicated.drbToAddModList.
LteRrcSap::RrcConnectionReconfiguration GetMessage() const
Returns a RrcConnectionReconfiguration IE from the values in the class attributes.
LteRrcSap::NonCriticalExtensionConfiguration GetNonCriticalExtensionConfig()
Getter for m_nonCriticalExtension.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated()
Getter for m_radioResourceConfigDedicated.
bool HavePhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.havePhysicalConfigDedicated.
LteRrcSap::MobilityControlInfo m_mobilityControlInfo
the modility control info
LteRrcSap::MeasConfig m_measConfig
the measure config
std::list< uint8_t > GetDrbToReleaseList() const
Gets m_radioResourceConfigDedicated.drbToReleaseList.
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
the radio resource config dedicated
bool GetHaveNonCriticalExtensionConfig() const
Getter for m_haveNonCriticalExtension.
LteRrcSap::PhysicalConfigDedicated GetPhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.physicalConfigDedicated.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
bool m_haveMobilityControlInfo
have mobility control info?
bool GetHaveRadioResourceConfigDedicated() const
Getter for m_haveRadioResourceConfigDedicated.
bool GetHaveMobilityControlInfo() const
Getter for m_haveMobilityControlInfo.
void SetMessage(LteRrcSap::RrcConnectionReconfiguration msg)
Receives a RrcConnectionReconfiguration IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::NonCriticalExtensionConfiguration m_nonCriticalExtension
the non-critical extension
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
bool m_haveRadioResourceConfigDedicated
have radio resource config dedicated?
bool GetHaveMeasConfig() const
Getter for m_haveMeasConfig.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
LteRrcSap::MeasConfig GetMeasConfig()
Getter for m_measConfig.
LteRrcSap::MobilityControlInfo GetMobilityControlInfo()
Getter for m_mobilityControlInfo.
void SetMessage(LteRrcSap::RrcConnectionReestablishmentComplete msg)
Receives a RrcConnectionReestablishmentComplete IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RrcConnectionReestablishmentComplete GetMessage() const
Returns a RrcConnectionReestablishmentComplete IE from the values in the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier attribute.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
radio resource config dedicated
LteRrcSap::RrcConnectionReestablishment GetMessage() const
Returns a RrcConnectionReestablishment IE from the values in the class attributes.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier attribute.
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated() const
Getter for m_radioResourceConfigDedicated attribute.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReestablishment msg)
Receives a RrcConnectionReestablishment IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void SetMessage(LteRrcSap::RrcConnectionReestablishmentReject msg)
Receives a RrcConnectionReestablishmentReject IE and stores the contents into the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
LteRrcSap::RrcConnectionReestablishmentReject m_rrcConnectionReestablishmentReject
RRC connection reestablishmnet reject.
LteRrcSap::RrcConnectionReestablishmentReject GetMessage() const
Returns a RrcConnectionReestablishmentReject IE from the values in the class attributes.
LteRrcSap::RrcConnectionReestablishmentRequest GetMessage() const
Returns a RrcConnectionReestablishmentRequest IE from the values in the class attributes.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::ReestablishmentCause m_reestablishmentCause
reestablishment cause
LteRrcSap::ReestablishmentCause GetReestablishmentCause() const
Getter for m_reestablishmentCause.
LteRrcSap::ReestabUeIdentity m_ueIdentity
UE identity.
void SetMessage(LteRrcSap::RrcConnectionReestablishmentRequest msg)
Receives a RrcConnectionReestablishmentRequest IE and stores the contents into the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
LteRrcSap::ReestabUeIdentity GetUeIdentity() const
Getter for m_ueIdentity.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::RrcConnectionReject GetMessage() const
Returns a RrcConnectionReject IE from the values in the class attributes.
LteRrcSap::RrcConnectionReject m_rrcConnectionReject
RRC connection reject.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SetMessage(LteRrcSap::RrcConnectionReject msg)
Receives a RrcConnectionReject IE and stores the contents into the class attributes.
LteRrcSap::RrcConnectionRelease GetMessage() const
Returns a RrcConnectionRelease IE from the values in the class attributes.
void SetMessage(LteRrcSap::RrcConnectionRelease msg)
Receives a RrcConnectionRelease IE and stores the contents into the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RrcConnectionRelease m_rrcConnectionRelease
RRC connection release.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
std::bitset< 8 > GetMmec() const
Get MMEC attribute.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
enum ns3::RrcConnectionRequestHeader::@59 m_establishmentCause
EstablishmentCause enumeration.
void SetMessage(LteRrcSap::RrcConnectionRequest msg)
Receives a RrcConnectionRequest IE and stores the contents into the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
std::bitset< 1 > m_spare
spare bit
LteRrcSap::RrcConnectionRequest GetMessage() const
Returns a RrcConnectionRequest IE from the values in the class attributes.
static TypeId GetTypeId()
Get the type ID.
std::bitset< 32 > GetMtmsi() const
Get M-TMSI attribute.
std::bitset< 8 > m_mmec
MMEC.
std::bitset< 32 > m_mTmsi
TMSI.
LteRrcSap::RrcConnectionSetupCompleted GetMessage() const
Returns a RrcConnectionSetupCompleted IE from the values in the class attributes.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void SetMessage(LteRrcSap::RrcConnectionSetupCompleted msg)
Receives a RrcConnectionSetupCompleted IE and stores the contents into the class attributes.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
uint32_t Deserialize(Buffer::Iterator bIterator) override
LteRrcSap::RadioResourceConfigDedicated m_radioResourceConfigDedicated
radio resource config dedicated
void SetMessage(LteRrcSap::RrcConnectionSetup msg)
Receives a RrcConnectionSetup IE and stores the contents into the class attributes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
std::list< LteRrcSap::DrbToAddMod > GetDrbToAddModList() const
Gets m_radioResourceConfigDedicated.drbToAddModList.
LteRrcSap::RrcConnectionSetup GetMessage() const
Returns a RrcConnectionSetup IE from the values in the class attributes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
std::list< uint8_t > GetDrbToReleaseList() const
Gets m_radioResourceConfigDedicated.drbToReleaseList.
uint8_t m_rrcTransactionIdentifier
RRC transaction identifier.
std::list< LteRrcSap::SrbToAddMod > GetSrbToAddModList() const
Gets m_radioResourceConfigDedicated.srbToAddModList.
bool HavePhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.havePhysicalConfigDedicated.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
LteRrcSap::PhysicalConfigDedicated GetPhysicalConfigDedicated() const
Gets m_radioResourceConfigDedicated.physicalConfigDedicated.
uint8_t GetRrcTransactionIdentifier() const
Getter for m_rrcTransactionIdentifier.
LteRrcSap::RadioResourceConfigDedicated GetRadioResourceConfigDedicated() const
Getter for m_radioResourceConfigDedicated.
Buffer::Iterator DeserializeDlCcchMessage(Buffer::Iterator bIterator)
Deserialize DL CCCH message function.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SerializeDlCcchMessage(int msgType) const
Serialize DL CCCH message function.
void SerializeDlDcchMessage(int msgType) const
Serialize DL DCCH message function.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
Buffer::Iterator DeserializeDlDcchMessage(Buffer::Iterator bIterator)
Deserialize DL DCCH message function.
This class only serves to discriminate which message type has been received in uplink (ue to eNb) for...
void SerializeUlCcchMessage(int msgType) const
Serialize UL CCCH message function.
Buffer::Iterator DeserializeUlCcchMessage(Buffer::Iterator bIterator)
Deserialize DL CCCH message function.
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
Buffer::Iterator DeserializeUlDcchMessage(Buffer::Iterator bIterator)
Deserialize UL DCCH message function.
uint32_t Deserialize(Buffer::Iterator bIterator) override
void Print(std::ostream &os) const override
This function prints the object, for debugging purposes.
void PreSerialize() const override
This function serializes class attributes to m_serializationResult local Buffer.
void SerializeUlDcchMessage(int msgType) const
Serialize UL DCCH message function.
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:936
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define MAX_CELL_REPORT
#define MAX_CELL_MEAS
#define MAX_DRB
#define MAX_SIB
#define MAX_EARFCN
#define MAX_SI_MESSAGE
#define MAX_MEAS_ID
#define MAX_OBJECT_ID
#define MAX_RAT_CAPABILITIES
#define MAX_REPORT_CONFIG_ID
#define MAX_SCELL_REPORT
Every class exported by the ns3 library is enclosed in the ns3 namespace.
uint16_t antennaPortsCount
antenna ports count
Definition: lte-rrc-sap.h:758
uint8_t transmissionMode
transmission mode
Definition: lte-rrc-sap.h:151
AsConfig structure.
Definition: lte-rrc-sap.h:650
RadioResourceConfigDedicated sourceRadioResourceConfig
source radio resource config
Definition: lte-rrc-sap.h:652
MasterInformationBlock sourceMasterInformationBlock
source master information block
Definition: lte-rrc-sap.h:654
uint16_t sourceUeIdentity
source UE identity
Definition: lte-rrc-sap.h:653
MeasConfig sourceMeasConfig
source measure config
Definition: lte-rrc-sap.h:651
uint32_t sourceDlCarrierFreq
source DL carrier frequency
Definition: lte-rrc-sap.h:659
SystemInformationBlockType1 sourceSystemInformationBlockType1
source system information block type 1
Definition: lte-rrc-sap.h:656
SystemInformationBlockType2 sourceSystemInformationBlockType2
source system information block type 2
Definition: lte-rrc-sap.h:658
BlackCellsToAddMod structure.
Definition: lte-rrc-sap.h:329
PhysCellIdRange physCellIdRange
Phy cell ID range.
Definition: lte-rrc-sap.h:331
uint16_t dlBandwidth
DL bandwidth.
Definition: lte-rrc-sap.h:580
uint16_t ulBandwidth
UL bandwidth.
Definition: lte-rrc-sap.h:581
uint32_t dlCarrierFreq
DL carrier frequency.
Definition: lte-rrc-sap.h:573
uint32_t ulCarrierFreq
UL carrier frequency.
Definition: lte-rrc-sap.h:574
CellIdentification structure.
Definition: lte-rrc-sap.h:750
uint32_t dlCarrierFreq
ARFCN - valueEUTRA.
Definition: lte-rrc-sap.h:752
uint32_t physCellId
physical cell ID
Definition: lte-rrc-sap.h:751
CellsToAddMod structure.
Definition: lte-rrc-sap.h:313
int8_t cellIndividualOffset
cell individual offset
Definition: lte-rrc-sap.h:316
uint8_t cellIndex
cell index
Definition: lte-rrc-sap.h:314
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:315
uint32_t cellIdentity
cell identity
Definition: lte-rrc-sap.h:666
uint32_t plmnIdentity
PLMN identity.
Definition: lte-rrc-sap.h:665
std::list< uint32_t > plmnIdentityList
PLMN identity list.
Definition: lte-rrc-sap.h:668
uint16_t trackingAreaCode
tracking area code
Definition: lte-rrc-sap.h:667
DrbToAddMod structure.
Definition: lte-rrc-sap.h:245
uint8_t epsBearerIdentity
EPS bearer identity.
Definition: lte-rrc-sap.h:246
RlcConfig rlcConfig
RLC config.
Definition: lte-rrc-sap.h:248
uint8_t logicalChannelIdentity
logical channel identify
Definition: lte-rrc-sap.h:249
uint8_t drbIdentity
DRB identity.
Definition: lte-rrc-sap.h:247
LogicalChannelConfig logicalChannelConfig
logical channel config
Definition: lte-rrc-sap.h:250
uint32_t ulCarrierFreq
UL carrier frequency.
Definition: lte-rrc-sap.h:88
uint16_t ulBandwidth
UL bandwidth.
Definition: lte-rrc-sap.h:89
HandoverPreparationInfo structure.
Definition: lte-rrc-sap.h:942
LogicalChannelConfig structure.
Definition: lte-rrc-sap.h:109
uint16_t bucketSizeDurationMs
bucket size duration ms
Definition: lte-rrc-sap.h:112
uint16_t prioritizedBitRateKbps
prioritized bit rate Kbps
Definition: lte-rrc-sap.h:111
uint8_t logicalChannelGroup
logical channel group
Definition: lte-rrc-sap.h:113
uint16_t systemFrameNumber
system frame number
Definition: lte-rrc-sap.h:624
MeasConfig structure.
Definition: lte-rrc-sap.h:553
std::list< uint8_t > measIdToRemoveList
measure ID to remove list
Definition: lte-rrc-sap.h:558
uint8_t sMeasure
S measure.
Definition: lte-rrc-sap.h:565
std::list< MeasObjectToAddMod > measObjectToAddModList
measure object to add mod list
Definition: lte-rrc-sap.h:555
std::list< uint8_t > reportConfigToRemoveList
report config to remove list
Definition: lte-rrc-sap.h:556
std::list< uint8_t > measObjectToRemoveList
measure object to remove list
Definition: lte-rrc-sap.h:554
SpeedStatePars speedStatePars
speed state parameters
Definition: lte-rrc-sap.h:567
bool haveMeasGapConfig
have measure gap config?
Definition: lte-rrc-sap.h:562
QuantityConfig quantityConfig
quantity config
Definition: lte-rrc-sap.h:561
bool haveSmeasure
have S measure?
Definition: lte-rrc-sap.h:564
bool haveSpeedStatePars
have speed state parameters?
Definition: lte-rrc-sap.h:566
std::list< ReportConfigToAddMod > reportConfigToAddModList
report config to add mod list
Definition: lte-rrc-sap.h:557
MeasGapConfig measGapConfig
measure gap config
Definition: lte-rrc-sap.h:563
std::list< MeasIdToAddMod > measIdToAddModList
measure ID to add mod list
Definition: lte-rrc-sap.h:559
bool haveQuantityConfig
have quantity config?
Definition: lte-rrc-sap.h:560
uint8_t gapOffsetValue
gap offset value
Definition: lte-rrc-sap.h:515
MeasIdToAddMod structure.
Definition: lte-rrc-sap.h:488
uint8_t measObjectId
measure object ID
Definition: lte-rrc-sap.h:490
uint8_t reportConfigId
report config ID
Definition: lte-rrc-sap.h:491
std::list< uint8_t > cellsToRemoveList
cells to remove list
Definition: lte-rrc-sap.h:342
bool haveCellForWhichToReportCGI
have cell for which to report CGI?
Definition: lte-rrc-sap.h:346
std::list< CellsToAddMod > cellsToAddModList
cells to add mod list
Definition: lte-rrc-sap.h:343
uint16_t allowedMeasBandwidth
allowed measure bandwidth
Definition: lte-rrc-sap.h:338
int8_t offsetFreq
offset frequency
Definition: lte-rrc-sap.h:341
uint8_t neighCellConfig
neighbor cell config
Definition: lte-rrc-sap.h:340
uint16_t cellForWhichToReportCGI
cell for which to report CGI
Definition: lte-rrc-sap.h:347
bool presenceAntennaPort1
antenna port 1 present?
Definition: lte-rrc-sap.h:339
std::list< uint8_t > blackCellsToRemoveList
black cells to remove list
Definition: lte-rrc-sap.h:344
std::list< BlackCellsToAddMod > blackCellsToAddModList
black cells to add mod list
Definition: lte-rrc-sap.h:345
uint32_t carrierFreq
carrier frequency
Definition: lte-rrc-sap.h:337
MeasObjectToAddMod structure.
Definition: lte-rrc-sap.h:474
uint8_t measObjectId
measure object ID
Definition: lte-rrc-sap.h:475
MeasObjectEutra measObjectEutra
measure object eutra
Definition: lte-rrc-sap.h:476
uint16_t physCellId
physical cell ID
Definition: lte-rrc-sap.h:700
MeasResultEutra structure.
Definition: lte-rrc-sap.h:680
uint8_t rsrqResult
RSRQ result.
Definition: lte-rrc-sap.h:687
uint8_t rsrpResult
RSRP result.
Definition: lte-rrc-sap.h:685
bool haveRsrpResult
have RSRP result
Definition: lte-rrc-sap.h:684
bool haveRsrqResult
have RSRQ result?
Definition: lte-rrc-sap.h:686
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:681
bool haveCgiInfo
have CGI info?
Definition: lte-rrc-sap.h:682
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:675
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:674
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:693
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:694
MeasResultServFreq structure.
Definition: lte-rrc-sap.h:707
bool haveMeasResultSCell
have measResultSCell?
Definition: lte-rrc-sap.h:709
MeasResultBestNeighCell measResultBestNeighCell
best neighbor cell measurement results
Definition: lte-rrc-sap.h:712
bool haveMeasResultBestNeighCell
have measResultBestNeighCell?
Definition: lte-rrc-sap.h:711
uint16_t servFreqId
serving cell index
Definition: lte-rrc-sap.h:708
MeasResultSCell measResultSCell
SCell measurement results.
Definition: lte-rrc-sap.h:710
MeasResults structure.
Definition: lte-rrc-sap.h:717
uint8_t measId
measure ID
Definition: lte-rrc-sap.h:718
bool haveMeasResultNeighCells
have measure result neighbor cells
Definition: lte-rrc-sap.h:720
std::list< MeasResultEutra > measResultListEutra
measure result list eutra
Definition: lte-rrc-sap.h:721
bool haveMeasResultServFreqList
has measResultServFreqList-r10
Definition: lte-rrc-sap.h:722
std::list< MeasResultServFreq > measResultServFreqList
MeasResultServFreqList-r10.
Definition: lte-rrc-sap.h:723
MeasResultPCell measResultPCell
measurement result primary cell
Definition: lte-rrc-sap.h:719
MeasurementReport structure.
Definition: lte-rrc-sap.h:948
MeasResults measResults
measure results
Definition: lte-rrc-sap.h:949
MobilityControlInfo structure.
Definition: lte-rrc-sap.h:593
RadioResourceConfigCommon radioResourceConfigCommon
radio resource config common
Definition: lte-rrc-sap.h:600
RachConfigDedicated rachConfigDedicated
RACH config dedicated.
Definition: lte-rrc-sap.h:602
bool haveRachConfigDedicated
Have RACH config dedicated?
Definition: lte-rrc-sap.h:601
uint16_t newUeIdentity
new UE identity
Definition: lte-rrc-sap.h:599
bool haveCarrierBandwidth
have carrier bandwidth?
Definition: lte-rrc-sap.h:597
bool haveCarrierFreq
have carrier frequency?
Definition: lte-rrc-sap.h:595
CarrierBandwidthEutra carrierBandwidth
carrier bandwidth
Definition: lte-rrc-sap.h:598
CarrierFreqEutra carrierFreq
carrier frequency
Definition: lte-rrc-sap.h:596
uint16_t targetPhysCellId
target Phy cell ID
Definition: lte-rrc-sap.h:594
uint8_t nCellChangeHigh
cell change high
Definition: lte-rrc-sap.h:524
uint8_t nCellChangeMedium
cell change medium
Definition: lte-rrc-sap.h:523
NonCriticalExtensionConfiguration structure.
Definition: lte-rrc-sap.h:874
std::list< uint8_t > sCellToReleaseList
SCell to release list.
Definition: lte-rrc-sap.h:876
std::list< SCellToAddMod > sCellToAddModList
SCell to add mod list.
Definition: lte-rrc-sap.h:875
AntennaInfoCommon antennaInfoCommon
2: Physical configuration, general antennaInfoCommon-r10
Definition: lte-rrc-sap.h:780
PdschConfigCommon pdschConfigCommon
4: Physical configuration, physical channels pdsch-ConfigCommon-r10
Definition: lte-rrc-sap.h:784
uint16_t dlBandwidth
1: Cell characteristics
Definition: lte-rrc-sap.h:778
int8_t referenceSignalPower
INTEGER (-60..50),.
Definition: lte-rrc-sap.h:157
int8_t pb
INTEGER (0..3),.
Definition: lte-rrc-sap.h:158
uint16_t start
starting cell ID
Definition: lte-rrc-sap.h:322
PhysicalConfigDedicated structure.
Definition: lte-rrc-sap.h:226
PdschConfigDedicated pdschConfigDedicated
PDSCH config dedicated.
Definition: lte-rrc-sap.h:233
bool haveAntennaInfoDedicated
have antenna info dedicated?
Definition: lte-rrc-sap.h:230
SoundingRsUlConfigDedicated soundingRsUlConfigDedicated
sounding RS UL config dedicated
Definition: lte-rrc-sap.h:229
bool haveSoundingRsUlConfigDedicated
have sounding RS UL config dedicated?
Definition: lte-rrc-sap.h:227
bool havePdschConfigDedicated
have PDSCH config dedicated?
Definition: lte-rrc-sap.h:232
AntennaInfoDedicated antennaInfo
antenna info
Definition: lte-rrc-sap.h:231
PhysicalConfigDedicatedSCell structure.
Definition: lte-rrc-sap.h:821
AntennaInfoDedicated antennaInfoUl
antenna info UL
Definition: lte-rrc-sap.h:835
SoundingRsUlConfigDedicated soundingRsUlConfigDedicated
sounding RS UL config dedicated
Definition: lte-rrc-sap.h:841
PdschConfigDedicated pdschConfigDedicated
PDSCH config dedicated.
Definition: lte-rrc-sap.h:830
bool haveSoundingRsUlConfigDedicated
have sounding RS UL config dedicated?
Definition: lte-rrc-sap.h:839
bool haveUlConfiguration
have UL configuration?
Definition: lte-rrc-sap.h:833
bool haveAntennaInfoUlDedicated
have antenna info UL dedicated?
Definition: lte-rrc-sap.h:834
bool havePdschConfigDedicated
have PDSCH config dedicated?
Definition: lte-rrc-sap.h:829
bool haveNonUlConfiguration
have non UL configuration?
Definition: lte-rrc-sap.h:823
AntennaInfoDedicated antennaInfo
antenna info dedicated
Definition: lte-rrc-sap.h:825
bool haveAntennaInfoDedicated
have antenna info dedicated?
Definition: lte-rrc-sap.h:824
uint32_t plmnIdentity
PLMN identity.
Definition: lte-rrc-sap.h:66
uint8_t numberOfRaPreambles
number of RA preambles
Definition: lte-rrc-sap.h:256
uint8_t filterCoefficientRSRQ
filter coefficient RSRQ
Definition: lte-rrc-sap.h:308
uint8_t filterCoefficientRSRP
filter coefficient RSRP
Definition: lte-rrc-sap.h:307
uint8_t raResponseWindowSize
RA response window size.
Definition: lte-rrc-sap.h:263
uint8_t preambleTransMax
preamble transmit maximum
Definition: lte-rrc-sap.h:262
RachConfigCommon structure.
Definition: lte-rrc-sap.h:275
TxFailParam txFailParam
txFailParams
Definition: lte-rrc-sap.h:278
PreambleInfo preambleInfo
preamble info
Definition: lte-rrc-sap.h:276
RaSupervisionInfo raSupervisionInfo
RA supervision info.
Definition: lte-rrc-sap.h:277
uint8_t raPreambleIndex
RA preamble index.
Definition: lte-rrc-sap.h:587
uint8_t raPrachMaskIndex
RA PRACH mask index.
Definition: lte-rrc-sap.h:588
RadioResourceConfigCommon structure.
Definition: lte-rrc-sap.h:283
RachConfigCommon rachConfigCommon
RACH config common.
Definition: lte-rrc-sap.h:284
RadioResourceConfigCommonSCell.
Definition: lte-rrc-sap.h:846
NonUlConfiguration nonUlConfiguration
non UL configuration
Definition: lte-rrc-sap.h:848
bool haveUlConfiguration
have UL configuration
Definition: lte-rrc-sap.h:849
bool haveNonUlConfiguration
have non UL configuration?
Definition: lte-rrc-sap.h:847
UlConfiguration ulConfiguration
UL configuration.
Definition: lte-rrc-sap.h:850
RadioResourceConfigCommonSib structure.
Definition: lte-rrc-sap.h:289
RachConfigCommon rachConfigCommon
RACH config common.
Definition: lte-rrc-sap.h:290
RadioResourceConfigDedicated structure.
Definition: lte-rrc-sap.h:296
PhysicalConfigDedicated physicalConfigDedicated
physical config dedicated
Definition: lte-rrc-sap.h:301
std::list< uint8_t > drbToReleaseList
DRB to release list.
Definition: lte-rrc-sap.h:299
bool havePhysicalConfigDedicated
have physical config dedicated?
Definition: lte-rrc-sap.h:300
std::list< DrbToAddMod > drbToAddModList
DRB to add mod list.
Definition: lte-rrc-sap.h:298
std::list< SrbToAddMod > srbToAddModList
SRB to add mod list.
Definition: lte-rrc-sap.h:297
RadioResourceConfigDedicatedSCell structure.
Definition: lte-rrc-sap.h:855
PhysicalConfigDedicatedSCell physicalConfigDedicatedSCell
physical config dedicated SCell
Definition: lte-rrc-sap.h:857
ReestabUeIdentity structure.
Definition: lte-rrc-sap.h:607
uint16_t physCellId
Phy cell ID.
Definition: lte-rrc-sap.h:609
bool reportOnLeave
Indicates whether or not the UE shall initiate the measurement reporting procedure when the leaving c...
Definition: lte-rrc-sap.h:399
uint8_t maxReportCells
Maximum number of cells, excluding the serving cell, to be included in the measurement report.
Definition: lte-rrc-sap.h:441
enum ns3::LteRrcSap::ReportConfigEutra::@62 eventId
Event enumeration.
enum ns3::LteRrcSap::ReportConfigEutra::@61 triggerType
Trigger enumeration.
uint8_t hysteresis
Parameter used within the entry and leave condition of an event triggered reporting condition.
Definition: lte-rrc-sap.h:407
@ RSRP
Reference Signal Received Power.
Definition: lte-rrc-sap.h:425
@ RSRQ
Reference Signal Received Quality.
Definition: lte-rrc-sap.h:426
@ EVENT_A2
Event A2: Serving becomes worse than absolute threshold.
Definition: lte-rrc-sap.h:385
@ EVENT_A3
Event A3: Neighbour becomes amount of offset better than PCell.
Definition: lte-rrc-sap.h:386
@ EVENT_A4
Event A4: Neighbour becomes better than absolute threshold.
Definition: lte-rrc-sap.h:387
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:384
@ EVENT_A5
Event A5: PCell becomes worse than absolute threshold1 AND Neighbour becomes better than another abso...
Definition: lte-rrc-sap.h:388
uint8_t reportAmount
Number of measurement reports applicable, always assumed to be infinite.
Definition: lte-rrc-sap.h:465
enum ns3::LteRrcSap::ReportConfigEutra::@65 reportInterval
Report interval enumeration.
ThresholdEutra threshold2
Threshold for event A5.
Definition: lte-rrc-sap.h:394
enum ns3::LteRrcSap::ReportConfigEutra::@63 triggerQuantity
Trigger type enumeration.
@ BOTH
Both the RSRP and RSRQ quantities are to be included in the measurement report.
Definition: lte-rrc-sap.h:434
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
Definition: lte-rrc-sap.h:393
enum ns3::LteRrcSap::ReportConfigEutra::@64 reportQuantity
Report type enumeration.
int8_t a3Offset
Offset value for Event A3.
Definition: lte-rrc-sap.h:403
uint16_t timeToTrigger
Time during which specific criteria for the event needs to be met in order to trigger a measurement r...
Definition: lte-rrc-sap.h:411
ReportConfigToAddMod structure.
Definition: lte-rrc-sap.h:481
uint8_t reportConfigId
report config ID
Definition: lte-rrc-sap.h:482
ReportConfigEutra reportConfigEutra
report config eutra
Definition: lte-rrc-sap.h:483
Direction choice
direction choice
Definition: lte-rrc-sap.h:104
RrcConnectionReconfigurationCompleted structure.
Definition: lte-rrc-sap.h:898
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:899
RrcConnectionReconfiguration structure.
Definition: lte-rrc-sap.h:881
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:882
bool haveMobilityControlInfo
have mobility control info
Definition: lte-rrc-sap.h:885
NonCriticalExtensionConfiguration nonCriticalExtension
3GPP TS 36.331 v.11.10 R11 Sec.
Definition: lte-rrc-sap.h:893
bool haveRadioResourceConfigDedicated
have radio resource config dedicated
Definition: lte-rrc-sap.h:887
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:889
bool haveNonCriticalExtension
have critical extension?
Definition: lte-rrc-sap.h:890
MobilityControlInfo mobilityControlInfo
mobility control info
Definition: lte-rrc-sap.h:886
RrcConnectionReestablishmentComplete structure.
Definition: lte-rrc-sap.h:919
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:920
RrcConnectionReestablishment structure.
Definition: lte-rrc-sap.h:911
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:914
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:912
RrcConnectionReestablishmentReject structure.
Definition: lte-rrc-sap.h:925
RrcConnectionReestablishmentRequest structure.
Definition: lte-rrc-sap.h:904
ReestablishmentCause reestablishmentCause
reestablishment cause
Definition: lte-rrc-sap.h:906
RrcConnectionReject structure.
Definition: lte-rrc-sap.h:936
RrcConnectionRelease structure.
Definition: lte-rrc-sap.h:930
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:931
RrcConnectionRequest structure.
Definition: lte-rrc-sap.h:730
RrcConnectionSetupCompleted structure.
Definition: lte-rrc-sap.h:744
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:745
RrcConnectionSetup structure.
Definition: lte-rrc-sap.h:736
uint8_t rrcTransactionIdentifier
RRC transaction identifier.
Definition: lte-rrc-sap.h:737
RadioResourceConfigDedicated radioResourceConfigDedicated
radio resource config dedicated
Definition: lte-rrc-sap.h:739
SCellToAddMod structure.
Definition: lte-rrc-sap.h:862
RadioResourceConfigDedicatedSCell radioResourceConfigDedicatedSCell
radio resource config dedicated SCell
Definition: lte-rrc-sap.h:869
uint32_t sCellIndex
SCell index.
Definition: lte-rrc-sap.h:863
bool haveRadioResourceConfigDedicatedSCell
have radio resource config dedicated SCell?
Definition: lte-rrc-sap.h:867
CellIdentification cellIdentification
cell identification
Definition: lte-rrc-sap.h:864
RadioResourceConfigCommonSCell radioResourceConfigCommonSCell
radio resource config common SCell
Definition: lte-rrc-sap.h:866
uint16_t srsConfigIndex
SRS config index.
Definition: lte-rrc-sap.h:145
SpeedStateScaleFactors timeToTriggerSf
time to trigger scale factors
Definition: lte-rrc-sap.h:548
MobilityStateParameters mobilityStateParameters
mobility state parameters
Definition: lte-rrc-sap.h:547
uint8_t sfHigh
scale factor high
Definition: lte-rrc-sap.h:532
uint8_t sfMedium
scale factor medium
Definition: lte-rrc-sap.h:531
SrbToAddMod structure.
Definition: lte-rrc-sap.h:238
LogicalChannelConfig logicalChannelConfig
logical channel config
Definition: lte-rrc-sap.h:240
uint8_t srbIdentity
SB identity.
Definition: lte-rrc-sap.h:239
SystemInformationBlockType1 structure.
Definition: lte-rrc-sap.h:629
CellAccessRelatedInfo cellAccessRelatedInfo
cell access related info
Definition: lte-rrc-sap.h:630
SystemInformationBlockType2 structure.
Definition: lte-rrc-sap.h:636
RadioResourceConfigCommonSib radioResourceConfigCommon
radio resource config common
Definition: lte-rrc-sap.h:637
Threshold for event evaluation.
Definition: lte-rrc-sap.h:360
@ THRESHOLD_RSRP
RSRP is used for the threshold.
Definition: lte-rrc-sap.h:364
@ THRESHOLD_RSRQ
RSRQ is used for the threshold.
Definition: lte-rrc-sap.h:365
enum ns3::LteRrcSap::ThresholdEutra::@60 choice
Threshold enumeration.
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:368
uint8_t connEstFailCount
Number of times that the UE detects T300 expiry on the same cell.
Definition: lte-rrc-sap.h:269
UlPowerControlCommonSCell ulPowerControlCommonSCell
3GPP TS 36.331 v.11.10 R11 pag.223
Definition: lte-rrc-sap.h:793
FreqInfo ulFreqInfo
UL frequency info.
Definition: lte-rrc-sap.h:792
PrachConfigSCell prachConfigSCell
PRACH config SCell.
Definition: lte-rrc-sap.h:795