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