22 #include "ns3/lte-rrc-header.h"
27 #define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331
28 #define MAX_EARFCN 65535
29 #define MAX_RAT_CAPABILITIES 8
30 #define MAX_SI_MESSAGE 32
33 #define MAX_REPORT_CONFIG_ID 32
34 #define MAX_OBJECT_ID 32
35 #define MAX_MEAS_ID 32
36 #define MAX_CELL_MEAS 32
37 #define MAX_CELL_REPORT 8
44 RrcAsn1Header::RrcAsn1Header ()
49 RrcAsn1Header::GetTypeId (
void)
51 static TypeId tid = TypeId (
"ns3::RrcAsn1Header")
64 RrcAsn1Header::GetMessageType ()
70 RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbToAddModList)
const
73 SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1);
76 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin ();
77 for (; it != drbToAddModList.end (); it++)
81 std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5> ();
82 drbToAddModListOptionalFieldsPresent.set (4,1);
83 drbToAddModListOptionalFieldsPresent.set (3,0);
84 drbToAddModListOptionalFieldsPresent.set (2,1);
85 drbToAddModListOptionalFieldsPresent.set (1,1);
86 drbToAddModListOptionalFieldsPresent.set (0,1);
87 SerializeSequence (drbToAddModListOptionalFieldsPresent,
true);
90 SerializeInteger (it->epsBearerIdentity,0,15);
93 SerializeInteger (it->drbIdentity,1,32);
95 switch (it->rlcConfig.choice)
97 case LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL:
99 SerializeChoice (4,1,
true);
102 SerializeSequence (std::bitset<0> (),
false);
106 SerializeSequence (std::bitset<0> (),
false);
108 SerializeEnum (32,0);
111 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL:
113 SerializeChoice (4,2,
true);
116 SerializeSequence (std::bitset<0> (),
false);
120 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL:
122 SerializeChoice (4,3,
true);
125 SerializeSequence (std::bitset<0> (),
false);
127 SerializeEnum (32,0);
130 case LteRrcSap::RlcConfig::AM:
133 SerializeChoice (4,0,
true);
136 SerializeSequence (std::bitset<0> (),
false);
137 SerializeEnum (64,0);
139 SerializeEnum (16,0);
143 SerializeSequence (std::bitset<0> (),
false);
144 SerializeEnum (32,0);
145 SerializeEnum (64,0);
150 SerializeInteger (it->logicalChannelIdentity,3,10);
153 SerializeLogicalChannelConfig (it->logicalChannelConfig);
158 RrcAsn1Header::SerializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> srbToAddModList)
const
161 SerializeSequenceOf (srbToAddModList.size (),2,1);
164 std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin ();
165 for (; it != srbToAddModList.end (); it++)
169 std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2> ();
170 srbToAddModListOptionalFieldsPresent.set (1,0);
171 srbToAddModListOptionalFieldsPresent.set (0,1);
172 SerializeSequence (srbToAddModListOptionalFieldsPresent,
true);
175 SerializeInteger (it->srbIdentity,1,2);
179 SerializeChoice (2,0,
false);
182 SerializeLogicalChannelConfig (it->logicalChannelConfig);
187 RrcAsn1Header::SerializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig logicalChannelConfig)
const
191 SerializeSequence (std::bitset<1> (1),
true);
195 SerializeSequence (std::bitset<1> (1),
false);
198 SerializeInteger (logicalChannelConfig.priority,1,16);
201 int prioritizedBitRate;
202 switch (logicalChannelConfig.prioritizedBitRateKbps)
205 prioritizedBitRate = 0;
208 prioritizedBitRate = 1;
211 prioritizedBitRate = 2;
214 prioritizedBitRate = 3;
217 prioritizedBitRate = 4;
220 prioritizedBitRate = 5;
223 prioritizedBitRate = 6;
226 prioritizedBitRate = 7;
228 SerializeEnum (16,prioritizedBitRate);
231 int bucketSizeDuration;
232 switch (logicalChannelConfig.bucketSizeDurationMs)
235 bucketSizeDuration = 0;
238 bucketSizeDuration = 1;
241 bucketSizeDuration = 2;
244 bucketSizeDuration = 3;
247 bucketSizeDuration = 4;
250 bucketSizeDuration = 5;
253 bucketSizeDuration = 5;
255 SerializeEnum (8,bucketSizeDuration);
258 SerializeInteger (logicalChannelConfig.logicalChannelGroup,0,3);
262 RrcAsn1Header::SerializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated)
const
265 std::bitset<10> optionalFieldsPhysicalConfigDedicated;
266 optionalFieldsPhysicalConfigDedicated.set (9,0);
267 optionalFieldsPhysicalConfigDedicated.set (8,0);
268 optionalFieldsPhysicalConfigDedicated.set (7,0);
269 optionalFieldsPhysicalConfigDedicated.set (6,0);
270 optionalFieldsPhysicalConfigDedicated.set (5,0);
271 optionalFieldsPhysicalConfigDedicated.set (4,0);
272 optionalFieldsPhysicalConfigDedicated.set (3,0);
273 optionalFieldsPhysicalConfigDedicated.set (2,physicalConfigDedicated.haveSoundingRsUlConfigDedicated);
274 optionalFieldsPhysicalConfigDedicated.set (1,physicalConfigDedicated.haveAntennaInfoDedicated);
275 optionalFieldsPhysicalConfigDedicated.set (0,0);
276 SerializeSequence (optionalFieldsPhysicalConfigDedicated,
true);
278 if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
281 switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type)
283 case LteRrcSap::SoundingRsUlConfigDedicated::RESET:
284 SerializeChoice (2,0,
false);
288 case LteRrcSap::SoundingRsUlConfigDedicated::SETUP:
291 SerializeChoice (2,1,
false);
295 SerializeSequence (std::bitset<0> (),
false);
298 SerializeEnum (4,physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth);
304 SerializeInteger (0,0,23);
307 SerializeBoolean (
false);
310 SerializeInteger (physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex,0,1023);
313 SerializeInteger (0,0,1);
322 if (physicalConfigDedicated.haveAntennaInfoDedicated)
326 SerializeChoice (2,0,
false);
330 SerializeSequence (std::bitset<1> (0),
false);
334 SerializeEnum (8,physicalConfigDedicated.antennaInfo.transmissionMode);
337 SerializeChoice (2,0,
false);
345 RrcAsn1Header::SerializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated)
const
347 bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.empty ();
348 bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.empty ();
349 bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseList.empty ();
352 std::bitset<6> optionalFieldsPresent = std::bitset<6> ();
353 optionalFieldsPresent.set (5,isSrbToAddModListPresent);
354 optionalFieldsPresent.set (4,isDrbToAddModListPresent);
355 optionalFieldsPresent.set (3,isDrbToReleaseListPresent);
356 optionalFieldsPresent.set (2,0);
357 optionalFieldsPresent.set (1,0);
358 optionalFieldsPresent.set (0,(radioResourceConfigDedicated.havePhysicalConfigDedicated) ? 1 : 0);
359 SerializeSequence (optionalFieldsPresent,
true);
362 if (isSrbToAddModListPresent)
364 SerializeSrbToAddModList (radioResourceConfigDedicated.srbToAddModList);
368 if (isDrbToAddModListPresent)
370 SerializeDrbToAddModList (radioResourceConfigDedicated.drbToAddModList);
374 if (isDrbToReleaseListPresent)
376 SerializeSequenceOf (radioResourceConfigDedicated.drbToReleaseList.size (),MAX_DRB,1);
377 std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToReleaseList.begin ();
378 for (; it != radioResourceConfigDedicated.drbToReleaseList.end (); it++)
381 SerializeInteger (*it,1,32);
385 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
387 SerializePhysicalConfigDedicated (radioResourceConfigDedicated.physicalConfigDedicated);
392 RrcAsn1Header::SerializeSystemInformationBlockType1 (LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1)
const
395 std::bitset<3> sysInfoBlk1Opts;
396 sysInfoBlk1Opts.set (2,0);
397 sysInfoBlk1Opts.set (1,0);
398 sysInfoBlk1Opts.set (0,0);
399 SerializeSequence (sysInfoBlk1Opts,
false);
403 SerializeSequence (std::bitset<1> (1),
false);
406 SerializeSequenceOf (1,6,1);
409 SerializeSequence (std::bitset<0> (),
false);
411 SerializePlmnIdentity (systemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity);
414 SerializeBitstring (std::bitset<16> (0));
416 SerializeBitstring (std::bitset<28> (systemInformationBlockType1.cellAccessRelatedInfo.cellIdentity));
422 SerializeBoolean (systemInformationBlockType1.cellAccessRelatedInfo.csgIndication);
424 SerializeBitstring (std::bitset<27> (systemInformationBlockType1.cellAccessRelatedInfo.csgIdentity));
427 SerializeSequence (std::bitset<1> (0),
false);
429 SerializeInteger (-50,-70,-22);
432 SerializeInteger (1,1,64);
435 SerializeSequenceOf (1,MAX_SI_MESSAGE,1);
437 SerializeSequence (std::bitset<0> (),
false);
441 SerializeSequenceOf (0,MAX_SIB - 1,0);
447 SerializeInteger (0,0,31);
451 RrcAsn1Header::SerializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon)
const
454 std::bitset<9> rrCfgCmmOpts;
455 rrCfgCmmOpts.set (8,1);
456 rrCfgCmmOpts.set (7,0);
457 rrCfgCmmOpts.set (6,0);
458 rrCfgCmmOpts.set (5,0);
459 rrCfgCmmOpts.set (4,0);
460 rrCfgCmmOpts.set (3,0);
461 rrCfgCmmOpts.set (2,0);
462 rrCfgCmmOpts.set (1,0);
463 rrCfgCmmOpts.set (0,0);
465 SerializeSequence (rrCfgCmmOpts,
true);
470 SerializeRachConfigCommon (radioResourceConfigCommon.rachConfigCommon);
475 SerializeSequence (std::bitset<1> (0),
false);
478 SerializeInteger (0,0,1023);
481 SerializeSequence (std::bitset<0> (),
false);
484 SerializeSequence (std::bitset<0> (),
false);
485 SerializeInteger (1,1,4);
487 SerializeInteger (0,0,98);
488 SerializeBoolean (
false);
491 SerializeSequence (std::bitset<0> (),
false);
492 SerializeBoolean (
false);
493 SerializeInteger (0,0,29);
494 SerializeBoolean (
false);
495 SerializeInteger (4,0,7);
502 RrcAsn1Header::SerializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib)
const
504 SerializeSequence (std::bitset<0> (0),
true);
507 SerializeRachConfigCommon (radioResourceConfigCommonSib.rachConfigCommon);
510 SerializeSequence (std::bitset<0> (0),
false);
513 SerializeSequence (std::bitset<0> (0),
false);
517 SerializeSequence (std::bitset<1> (0),
false);
518 SerializeInteger (0,0,1023);
520 SerializeSequence (std::bitset<0> (0),
false);
521 SerializeInteger (0,-60,50);
522 SerializeInteger (0,0,3);
524 SerializeSequence (std::bitset<0> (0),
false);
525 SerializeSequence (std::bitset<0> (0),
false);
526 SerializeInteger (1,1,4);
528 SerializeInteger (0,0,98);
529 SerializeBoolean (
false);
530 SerializeSequence (std::bitset<0> (0),
false);
531 SerializeBoolean (
false);
532 SerializeInteger (0,0,29);
533 SerializeBoolean (
false);
534 SerializeInteger (0,0,7);
536 SerializeSequence (std::bitset<0> (0),
false);
538 SerializeInteger (0,0,98);
539 SerializeInteger (0,0,7);
540 SerializeInteger (0,0,2047);
542 SerializeChoice (2,0,
false);
545 SerializeSequence (std::bitset<0> (0),
false);
546 SerializeInteger (0,-126,24);
548 SerializeInteger (-50,-127,-96);
549 SerializeSequence (std::bitset<0> (0),
false);
555 SerializeInteger (0,-1,6);
561 RrcAsn1Header::SerializeSystemInformationBlockType2 (LteRrcSap::SystemInformationBlockType2 systemInformationBlockType2)
const
563 SerializeSequence (std::bitset<2> (0),
true);
566 SerializeRadioResourceConfigCommonSib (systemInformationBlockType2.radioResourceConfigCommon);
569 SerializeSequence (std::bitset<0> (0),
true);
578 SerializeSequence (std::bitset<2> (3),
false);
579 SerializeInteger ((
int) systemInformationBlockType2.freqInfo.ulCarrierFreq, 0, MAX_EARFCN);
580 switch (systemInformationBlockType2.freqInfo.ulBandwidth)
604 SerializeInteger (29,1,32);
610 RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults)
const
613 if (measResults.measResultListEutra.empty ())
615 measResults.haveMeasResultNeighCells =
false;
619 SerializeSequence (std::bitset<1> (measResults.haveMeasResultNeighCells),
true);
622 SerializeInteger (measResults.measId,1,MAX_MEAS_ID);
625 SerializeSequence (std::bitset<0> (0),
false);
628 SerializeInteger (measResults.rsrpResult,0,97);
631 SerializeInteger (measResults.rsrqResult,0,34);
633 if (measResults.haveMeasResultNeighCells)
636 SerializeChoice (4,0,
false);
639 SerializeSequenceOf (measResults.measResultListEutra.size (),MAX_CELL_REPORT,1);
642 std::list<LteRrcSap::MeasResultEutra>::iterator it;
643 for (it = measResults.measResultListEutra.begin (); it != measResults.measResultListEutra.end (); it++)
645 SerializeSequence (std::bitset<1> (it->haveCgiInfo),
false);
648 SerializeInteger (it->physCellId, 0, 503);
653 SerializeSequence (std::bitset<1> (it->cgiInfo.plmnIdentityList.size ()),
false);
656 SerializeSequence (std::bitset<0> (0),
false);
657 SerializePlmnIdentity (it->cgiInfo.plmnIdentity);
658 SerializeBitstring (std::bitset<28> (it->cgiInfo.cellIdentity));
661 SerializeBitstring (std::bitset<16> (it->cgiInfo.trackingAreaCode));
664 if (!it->cgiInfo.plmnIdentityList.empty ())
666 SerializeSequenceOf (it->cgiInfo.plmnIdentityList.size (),5,1);
667 std::list<uint32_t>::iterator it2;
668 for (it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it->cgiInfo.plmnIdentityList.end (); it2++)
670 SerializePlmnIdentity (*it2);
676 std::bitset<2> measResultFieldsPresent;
677 measResultFieldsPresent[1] = it->haveRsrpResult;
678 measResultFieldsPresent[0] = it->haveRsrqResult;
679 SerializeSequence (measResultFieldsPresent,
true);
681 if (it->haveRsrpResult)
683 SerializeInteger (it->rsrpResult,0,97);
686 if (it->haveRsrqResult)
688 SerializeInteger (it->rsrqResult,0,34);
695 RrcAsn1Header::SerializePlmnIdentity (uint32_t plmnId)
const
698 SerializeSequence (std::bitset<1> (0),
false);
701 int nDig = (plmnId > 99) ? 3 : 2;
703 SerializeSequenceOf (nDig,3,2);
704 for (
int i = nDig - 1; i >= 0; i--)
706 int n = floor (plmnId / pow (10,i));
707 SerializeInteger (n,0,9);
708 plmnId -= n * pow (10,i);
716 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfigCommon)
const
719 SerializeSequence (std::bitset<0> (0),
true);
722 SerializeSequence (std::bitset<1> (0),
false);
725 switch (rachConfigCommon.preambleInfo.numberOfRaPreambles)
728 SerializeEnum (16,0);
731 SerializeEnum (16,1);
734 SerializeEnum (16,2);
737 SerializeEnum (16,3);
740 SerializeEnum (16,4);
743 SerializeEnum (16,5);
746 SerializeEnum (16,6);
749 SerializeEnum (16,7);
752 SerializeEnum (16,8);
755 SerializeEnum (16,9);
758 SerializeEnum (16,10);
761 SerializeEnum (16,11);
764 SerializeEnum (16,12);
767 SerializeEnum (16,13);
770 SerializeEnum (16,14);
773 SerializeEnum (16,15);
776 SerializeEnum (16,0);
779 SerializeSequence (std::bitset<0> (0),
false);
781 SerializeEnum (16,0);
782 SerializeSequence (std::bitset<0> (0),
false);
785 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax)
788 SerializeEnum (11,0);
791 SerializeEnum (11,1);
794 SerializeEnum (11,2);
797 SerializeEnum (11,3);
800 SerializeEnum (11,4);
803 SerializeEnum (11,5);
806 SerializeEnum (11,6);
809 SerializeEnum (11,7);
812 SerializeEnum (11,8);
815 SerializeEnum (11,9);
818 SerializeEnum (11,10);
821 SerializeEnum (11,0);
825 switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize)
856 SerializeInteger (1,1,8);
860 RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange)
const
862 switch (qOffsetRange)
865 SerializeEnum (32,0);
868 SerializeEnum (32,1);
871 SerializeEnum (32,2);
874 SerializeEnum (32,3);
877 SerializeEnum (32,4);
880 SerializeEnum (32,5);
883 SerializeEnum (32,6);
886 SerializeEnum (32,7);
889 SerializeEnum (32,8);
892 SerializeEnum (32,9);
895 SerializeEnum (32,10);
898 SerializeEnum (32,11);
901 SerializeEnum (32,12);
904 SerializeEnum (32,13);
907 SerializeEnum (32,14);
910 SerializeEnum (32,15);
913 SerializeEnum (32,16);
916 SerializeEnum (32,17);
919 SerializeEnum (32,18);
922 SerializeEnum (32,19);
925 SerializeEnum (32,20);
928 SerializeEnum (32,21);
931 SerializeEnum (32,22);
934 SerializeEnum (32,23);
937 SerializeEnum (32,24);
940 SerializeEnum (32,25);
943 SerializeEnum (32,26);
946 SerializeEnum (32,27);
949 SerializeEnum (32,28);
952 SerializeEnum (32,29);
955 SerializeEnum (32,30);
958 SerializeEnum (32,15);
963 RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra)
const
965 switch (thresholdEutra.choice)
967 case LteRrcSap::ThresholdEutra::thresholdRsrp:
968 SerializeInteger (thresholdEutra.range, 0, 97);
970 case LteRrcSap::ThresholdEutra::thresholdRsrq:
972 SerializeInteger (thresholdEutra.range, 0, 34);
977 RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig)
const
981 std::bitset<11> measConfigOptional;
982 measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () );
983 measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () );
984 measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () );
985 measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () );
986 measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () );
987 measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () );
988 measConfigOptional.set (4, measConfig.haveQuantityConfig );
989 measConfigOptional.set (3, measConfig.haveMeasGapConfig );
990 measConfigOptional.set (2, measConfig.haveSmeasure );
991 measConfigOptional.set (1,
false );
992 measConfigOptional.set (0, measConfig.haveSpeedStatePars );
993 SerializeSequence (measConfigOptional,
true);
995 if (!measConfig.measObjectToRemoveList.empty ())
997 SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_ID,1);
998 for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList.begin (); it != measConfig.measObjectToRemoveList.end (); it++)
1000 SerializeInteger (*it, 1, MAX_OBJECT_ID);
1004 if (!measConfig.measObjectToAddModList.empty ())
1006 SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_ID,1);
1007 for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = measConfig.measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); it++)
1009 SerializeSequence (std::bitset<0> (),
false);
1010 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
1011 SerializeChoice (4, 0,
true);
1014 std::bitset<5> measObjOpts;
1015 measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () );
1016 measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () );
1017 measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty () );
1018 measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty () );
1019 measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI);
1020 SerializeSequence (measObjOpts,
true);
1023 SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN);
1026 switch (it->measObjectEutra.allowedMeasBandwidth)
1029 SerializeEnum (6,0);
1032 SerializeEnum (6,1);
1035 SerializeEnum (6,2);
1038 SerializeEnum (6,3);
1041 SerializeEnum (6,4);
1044 SerializeEnum (6,5);
1047 SerializeEnum (6,0);
1050 SerializeBoolean (it->measObjectEutra.presenceAntennaPort1);
1051 SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfig));
1052 SerializeQoffsetRange (it->measObjectEutra.offsetFreq);
1054 if (!it->measObjectEutra.cellsToRemoveList.empty ())
1056 SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size (),MAX_CELL_MEAS,1);
1057 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++)
1059 SerializeInteger (*it2, 1, MAX_CELL_MEAS);
1063 if (!it->measObjectEutra.cellsToAddModList.empty ())
1065 SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size (), MAX_CELL_MEAS, 1);
1066 for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 = it->measObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModList.end (); it2++)
1068 SerializeSequence (std::bitset<0> (),
false);
1071 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
1075 SerializeSequence (std::bitset<1> (0),
false);
1076 SerializeInteger (it2->physCellId,0,503);
1079 SerializeQoffsetRange (it2->cellIndividualOffset);
1083 if (!it->measObjectEutra.blackCellsToRemoveList.empty () )
1085 SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.size (),MAX_CELL_MEAS,1);
1086 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.blackCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end (); it2++)
1088 SerializeInteger (*it2, 1, MAX_CELL_MEAS);
1092 if (!it->measObjectEutra.blackCellsToAddModList.empty () )
1094 SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.size (), MAX_CELL_MEAS, 1);
1095 for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = it->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blackCellsToAddModList.end (); it2++)
1097 SerializeSequence (std::bitset<0> (),
false);
1098 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
1102 std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdRange.haveRange);
1103 SerializeSequence (rangePresent,
false);
1104 SerializeInteger (it2->physCellIdRange.start,0,503);
1105 if (it2->physCellIdRange.haveRange)
1107 switch (it2->physCellIdRange.range)
1110 SerializeEnum (16, 0);
1113 SerializeEnum (16, 1);
1116 SerializeEnum (16, 2);
1119 SerializeEnum (16, 3);
1122 SerializeEnum (16, 4);
1125 SerializeEnum (16, 5);
1128 SerializeEnum (16, 6);
1131 SerializeEnum (16, 7);
1134 SerializeEnum (16, 8);
1137 SerializeEnum (16, 9);
1140 SerializeEnum (16, 10);
1143 SerializeEnum (16, 11);
1146 SerializeEnum (16, 12);
1149 SerializeEnum (16, 13);
1152 SerializeEnum (16, 0);
1159 if (it->measObjectEutra.haveCellForWhichToReportCGI)
1161 SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,503);
1167 if (!measConfig.reportConfigToRemoveList.empty () )
1169 SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPORT_CONFIG_ID,1);
1170 for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveList.begin (); it != measConfig.reportConfigToRemoveList.end (); it++)
1172 SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID);
1176 if (!measConfig.reportConfigToAddModList.empty () )
1178 SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPORT_CONFIG_ID,1);
1179 for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = measConfig.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end (); it++)
1181 SerializeSequence (std::bitset<0> (),
false);
1182 SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID);
1183 SerializeChoice (2,0,
false);
1186 SerializeSequence (std::bitset<0> (),
true);
1187 switch (it->reportConfigEutra.triggerType)
1189 case LteRrcSap::ReportConfigEutra::periodical:
1190 SerializeChoice (2, 1,
false);
1191 SerializeSequence (std::bitset<0> (),
false);
1192 switch (it->reportConfigEutra.purpose)
1194 case LteRrcSap::ReportConfigEutra::reportCgi:
1195 SerializeEnum (2,1);
1197 case LteRrcSap::ReportConfigEutra::reportStrongestCells:
1199 SerializeEnum (2,0);
1202 case LteRrcSap::ReportConfigEutra::event:
1204 SerializeChoice (2, 0,
false);
1205 SerializeSequence (std::bitset<0> (),
true);
1206 switch (it->reportConfigEutra.eventId)
1208 case LteRrcSap::ReportConfigEutra::eventA1:
1209 SerializeChoice (5, 0,
true);
1210 SerializeSequence (std::bitset<0> (),
false);
1211 SerializeThresholdEutra (it->reportConfigEutra.threshold1);
1213 case LteRrcSap::ReportConfigEutra::eventA2:
1214 SerializeChoice (5, 1,
true);
1215 SerializeSequence (std::bitset<0> (),
false);
1216 SerializeThresholdEutra (it->reportConfigEutra.threshold1);
1218 case LteRrcSap::ReportConfigEutra::eventA3:
1219 SerializeChoice (5, 2,
true);
1220 SerializeSequence (std::bitset<0> (),
false);
1221 SerializeInteger (it->reportConfigEutra.a3Offset,-30,30);
1222 SerializeBoolean (it->reportConfigEutra.reportOnLeave);
1224 case LteRrcSap::ReportConfigEutra::eventA4:
1225 SerializeChoice (5, 3,
true);
1226 SerializeSequence (std::bitset<0> (),
false);
1227 SerializeThresholdEutra (it->reportConfigEutra.threshold1);
1229 case LteRrcSap::ReportConfigEutra::eventA5:
1231 SerializeChoice (5, 4,
true);
1232 SerializeSequence (std::bitset<0> (),
false);
1233 SerializeThresholdEutra (it->reportConfigEutra.threshold1);
1234 SerializeThresholdEutra (it->reportConfigEutra.threshold2);
1237 SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30);
1239 switch (it->reportConfigEutra.timeToTrigger)
1242 SerializeEnum (16, 0);
1245 SerializeEnum (16, 1);
1248 SerializeEnum (16, 2);
1251 SerializeEnum (16, 3);
1254 SerializeEnum (16, 4);
1257 SerializeEnum (16, 5);
1260 SerializeEnum (16, 6);
1263 SerializeEnum (16, 7);
1266 SerializeEnum (16, 8);
1269 SerializeEnum (16, 9);
1272 SerializeEnum (16, 10);
1275 SerializeEnum (16, 11);
1278 SerializeEnum (16, 12);
1281 SerializeEnum (16, 13);
1284 SerializeEnum (16, 14);
1288 SerializeEnum (16, 15);
1293 if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::rsrp)
1295 SerializeEnum (2, 0);
1299 SerializeEnum (2, 1);
1303 if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity)
1305 SerializeEnum (2, 0);
1309 SerializeEnum (2, 1);
1313 SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT);
1316 switch (it->reportConfigEutra.reportInterval)
1318 case LteRrcSap::ReportConfigEutra::ms120:
1319 SerializeEnum (16, 0);
1321 case LteRrcSap::ReportConfigEutra::ms240:
1322 SerializeEnum (16, 1);
1324 case LteRrcSap::ReportConfigEutra::ms480:
1325 SerializeEnum (16, 2);
1327 case LteRrcSap::ReportConfigEutra::ms640:
1328 SerializeEnum (16, 3);
1330 case LteRrcSap::ReportConfigEutra::ms1024:
1331 SerializeEnum (16, 4);
1333 case LteRrcSap::ReportConfigEutra::ms2048:
1334 SerializeEnum (16, 5);
1336 case LteRrcSap::ReportConfigEutra::ms5120:
1337 SerializeEnum (16, 6);
1339 case LteRrcSap::ReportConfigEutra::ms10240:
1340 SerializeEnum (16, 7);
1342 case LteRrcSap::ReportConfigEutra::min1:
1343 SerializeEnum (16, 8);
1345 case LteRrcSap::ReportConfigEutra::min6:
1346 SerializeEnum (16, 9);
1348 case LteRrcSap::ReportConfigEutra::min12:
1349 SerializeEnum (16, 10);
1351 case LteRrcSap::ReportConfigEutra::min30:
1352 SerializeEnum (16, 11);
1354 case LteRrcSap::ReportConfigEutra::min60:
1355 SerializeEnum (16, 12);
1357 case LteRrcSap::ReportConfigEutra::spare3:
1358 SerializeEnum (16, 13);
1360 case LteRrcSap::ReportConfigEutra::spare2:
1361 SerializeEnum (16, 14);
1363 case LteRrcSap::ReportConfigEutra::spare1:
1365 SerializeEnum (16, 15);
1369 switch (it->reportConfigEutra.reportAmount)
1372 SerializeEnum (8, 0);
1375 SerializeEnum (8, 1);
1378 SerializeEnum (8, 2);
1381 SerializeEnum (8, 3);
1384 SerializeEnum (8, 4);
1387 SerializeEnum (8, 5);
1390 SerializeEnum (8, 6);
1393 SerializeEnum (8, 7);
1398 if (!measConfig.measIdToRemoveList.empty () )
1400 SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1);
1401 for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.begin (); it != measConfig.measIdToRemoveList.end (); it++)
1403 SerializeInteger (*it, 1, MAX_MEAS_ID);
1407 if (!measConfig.measIdToAddModList.empty () )
1409 SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID, 1);
1410 for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it = measConfig.measIdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++)
1412 SerializeInteger (it->measId, 1, MAX_MEAS_ID);
1413 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
1414 SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
1418 if (measConfig.haveQuantityConfig )
1422 std::bitset<4> quantityConfigOpts (0);
1423 quantityConfigOpts.set (3,1);
1424 SerializeSequence (quantityConfigOpts,
true);
1425 SerializeSequence (std::bitset<0> (),
false);
1427 switch (measConfig.quantityConfig.filterCoefficientRSRP)
1430 SerializeEnum (16, 0);
1433 SerializeEnum (16, 1);
1436 SerializeEnum (16, 2);
1439 SerializeEnum (16, 3);
1442 SerializeEnum (16, 4);
1445 SerializeEnum (16, 5);
1448 SerializeEnum (16, 6);
1451 SerializeEnum (16, 7);
1454 SerializeEnum (16, 8);
1457 SerializeEnum (16, 9);
1460 SerializeEnum (16, 10);
1463 SerializeEnum (16, 11);
1466 SerializeEnum (16, 12);
1469 SerializeEnum (16, 13);
1472 SerializeEnum (16, 14);
1475 SerializeEnum (16, 4);
1478 switch (measConfig.quantityConfig.filterCoefficientRSRQ)
1481 SerializeEnum (16, 0);
1484 SerializeEnum (16, 1);
1487 SerializeEnum (16, 2);
1490 SerializeEnum (16, 3);
1493 SerializeEnum (16, 4);
1496 SerializeEnum (16, 5);
1499 SerializeEnum (16, 6);
1502 SerializeEnum (16, 7);
1505 SerializeEnum (16, 8);
1508 SerializeEnum (16, 9);
1511 SerializeEnum (16, 10);
1514 SerializeEnum (16, 11);
1517 SerializeEnum (16, 12);
1520 SerializeEnum (16, 13);
1523 SerializeEnum (16, 14);
1526 SerializeEnum (16, 4);
1530 if (measConfig.haveMeasGapConfig )
1532 switch (measConfig.measGapConfig.type)
1534 case LteRrcSap::MeasGapConfig::RESET:
1535 SerializeChoice (2, 0,
false);
1538 case LteRrcSap::MeasGapConfig::SETUP:
1540 SerializeChoice (2, 1,
false);
1541 SerializeSequence (std::bitset<0> (),
false);
1542 switch (measConfig.measGapConfig.gapOffsetChoice)
1544 case LteRrcSap::MeasGapConfig::gp0:
1545 SerializeChoice (2, 0,
true);
1546 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39);
1548 case LteRrcSap::MeasGapConfig::gp1:
1550 SerializeChoice (2, 1,
true);
1551 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79);
1556 if (measConfig.haveSmeasure )
1558 SerializeInteger (measConfig.sMeasure, 0, 97);
1563 if (measConfig.haveSpeedStatePars )
1565 switch (measConfig.speedStatePars.type)
1567 case LteRrcSap::SpeedStatePars::RESET:
1568 SerializeChoice (2, 0,
false);
1571 case LteRrcSap::SpeedStatePars::SETUP:
1573 SerializeChoice (2, 1,
false);
1574 SerializeSequence (std::bitset<0> (),
false);
1575 switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation)
1578 SerializeEnum (8, 0);
1581 SerializeEnum (8, 1);
1584 SerializeEnum (8, 2);
1587 SerializeEnum (8, 3);
1590 SerializeEnum (8, 4);
1593 SerializeEnum (8, 5);
1597 switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal)
1600 SerializeEnum (8, 0);
1603 SerializeEnum (8, 1);
1606 SerializeEnum (8, 2);
1609 SerializeEnum (8, 3);
1612 SerializeEnum (8, 4);
1615 SerializeEnum (8, 5);
1619 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium, 1, 16);
1620 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh, 1, 16);
1622 SerializeSequence (std::bitset<0> (),
false);
1623 switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium)
1626 SerializeEnum (4, 0);
1629 SerializeEnum (4, 1);
1632 SerializeEnum (4, 2);
1636 SerializeEnum (4, 3);
1639 switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh)
1642 SerializeEnum (4, 0);
1645 SerializeEnum (4, 1);
1648 SerializeEnum (4, 2);
1652 SerializeEnum (4, 3);
1659 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator)
1661 int thresholdEutraChoice, range;
1662 bIterator = DeserializeChoice (2,
false, &thresholdEutraChoice, bIterator);
1664 switch (thresholdEutraChoice)
1667 thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp;
1668 bIterator = DeserializeInteger (&range, 0, 97, bIterator);
1669 thresholdEutra->range = range;
1673 thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq;
1674 bIterator = DeserializeInteger (&range, 0, 34, bIterator);
1675 thresholdEutra->range = range;
1682 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator)
1685 bIterator = DeserializeEnum (31, &n, bIterator);
1689 *qOffsetRange = -24;
1692 *qOffsetRange = -22;
1695 *qOffsetRange = -20;
1698 *qOffsetRange = -18;
1701 *qOffsetRange = -16;
1704 *qOffsetRange = -14;
1707 *qOffsetRange = -12;
1710 *qOffsetRange = -10;
1786 RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator)
1789 std::bitset<6> optionalFieldsPresent = std::bitset<6> ();
1790 bIterator = DeserializeSequence (&optionalFieldsPresent,
true,bIterator);
1792 if (optionalFieldsPresent[5])
1795 bIterator = DeserializeSrbToAddModList (&(radioResourceConfigDedicated->srbToAddModList),bIterator);
1798 if (optionalFieldsPresent[4])
1801 bIterator = DeserializeDrbToAddModList (&(radioResourceConfigDedicated->drbToAddModList),bIterator);
1804 if (optionalFieldsPresent[3])
1809 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator);
1810 for (
int i = 0; i < n; i++)
1812 bIterator = DeserializeInteger (&val,1,32,bIterator);
1813 radioResourceConfigDedicated->drbToReleaseList.push_back (val);
1817 if (optionalFieldsPresent[2])
1823 if (optionalFieldsPresent[1])
1829 radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPresent[0];
1830 if (optionalFieldsPresent[0])
1833 bIterator = DeserializePhysicalConfigDedicated (&radioResourceConfigDedicated->physicalConfigDedicated,bIterator);
1840 RrcAsn1Header::DeserializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> *srbToAddModList, Buffer::Iterator bIterator)
1843 bIterator = DeserializeSequenceOf (&numElems,2,1,bIterator);
1845 srbToAddModList->clear ();
1848 for (
int i = 0; i < numElems; i++)
1850 LteRrcSap::SrbToAddMod srbToAddMod;
1853 std::bitset<2> optionalFields;
1854 bIterator = DeserializeSequence (&optionalFields,
true,bIterator);
1858 bIterator = DeserializeInteger (&n,1,2,bIterator);
1859 srbToAddMod.srbIdentity = n;
1861 if (optionalFields[1])
1867 if (optionalFields[0])
1871 bIterator = DeserializeChoice (2,
false,&sel,bIterator);
1876 bIterator = DeserializeNull (bIterator);
1882 bIterator = DeserializeLogicalChannelConfig (&srbToAddMod.logicalChannelConfig,bIterator);
1885 srbToAddModList->insert (srbToAddModList->end (),srbToAddMod);
1892 RrcAsn1Header::DeserializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> *drbToAddModList, Buffer::Iterator bIterator)
1896 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator);
1898 drbToAddModList->clear ();
1900 for (
int i = 0; i < n; i++)
1902 LteRrcSap::DrbToAddMod drbToAddMod;
1904 std::bitset<5> optionalFields;
1905 bIterator = DeserializeSequence (&optionalFields,
true,bIterator);
1907 if (optionalFields[4])
1910 bIterator = DeserializeInteger (&val,0,15,bIterator);
1911 drbToAddMod.epsBearerIdentity = val;
1914 bIterator = DeserializeInteger (&val,1,32,bIterator);
1915 drbToAddMod.drbIdentity = val;
1917 if (optionalFields[3])
1923 if (optionalFields[2])
1927 bIterator = DeserializeChoice (4,
true,&chosen,bIterator);
1930 std::bitset<0> bitset0;
1934 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::AM;
1937 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1938 bIterator = DeserializeEnum (64,&sel, bIterator);
1939 bIterator = DeserializeEnum (8,&sel, bIterator);
1940 bIterator = DeserializeEnum (16,&sel, bIterator);
1941 bIterator = DeserializeEnum (8,&sel, bIterator);
1944 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1945 bIterator = DeserializeEnum (32,&sel, bIterator);
1946 bIterator = DeserializeEnum (64,&sel, bIterator);
1950 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL;
1953 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1954 bIterator = DeserializeEnum (2,&sel, bIterator);
1957 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1958 bIterator = DeserializeEnum (2,&sel, bIterator);
1959 bIterator = DeserializeEnum (32,&sel, bIterator);
1963 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL;
1966 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1967 bIterator = DeserializeEnum (2,&sel, bIterator);
1971 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL;
1974 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
1975 bIterator = DeserializeEnum (2,&sel, bIterator);
1976 bIterator = DeserializeEnum (32,&sel, bIterator);
1982 if (optionalFields[1])
1984 bIterator = DeserializeInteger (&val,3,10,bIterator);
1985 drbToAddMod.logicalChannelIdentity = val;
1988 if (optionalFields[0])
1990 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChannelConfig,bIterator);
1993 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod);
1999 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig *logicalChannelConfig, Buffer::Iterator bIterator)
2005 std::bitset<1> bitset1;
2006 bIterator = DeserializeSequence (&bitset1,
true,bIterator);
2011 bIterator = DeserializeSequence (&bitset1,
false,bIterator);
2014 bIterator = DeserializeInteger (&n,1,16,bIterator);
2015 logicalChannelConfig->priority = n;
2018 bIterator = DeserializeEnum (16,&n,bIterator);
2019 uint16_t prioritizedBitRateKbps;
2024 prioritizedBitRateKbps = 0;
2027 prioritizedBitRateKbps = 8;
2030 prioritizedBitRateKbps = 16;
2033 prioritizedBitRateKbps = 32;
2036 prioritizedBitRateKbps = 64;
2039 prioritizedBitRateKbps = 128;
2042 prioritizedBitRateKbps = 256;
2045 prioritizedBitRateKbps = 10000;
2048 prioritizedBitRateKbps = 10000;
2050 logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps;
2053 bIterator = DeserializeEnum (8,&n,bIterator);
2054 uint16_t bucketSizeDurationMs;
2058 bucketSizeDurationMs = 50;
2061 bucketSizeDurationMs = 100;
2064 bucketSizeDurationMs = 150;
2067 bucketSizeDurationMs = 300;
2070 bucketSizeDurationMs = 500;
2073 bucketSizeDurationMs = 1000;
2076 bucketSizeDurationMs = 1000;
2078 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs;
2083 bIterator = DeserializeInteger (&n,0,3,bIterator);
2084 logicalChannelConfig->logicalChannelGroup = n;
2091 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedicated *physicalConfigDedicated, Buffer::Iterator bIterator)
2093 std::bitset<10> optionalFieldPresent;
2094 bIterator = DeserializeSequence (&optionalFieldPresent,
true,bIterator);
2096 if (optionalFieldPresent[9])
2101 if (optionalFieldPresent[8])
2106 if (optionalFieldPresent[7])
2111 if (optionalFieldPresent[6])
2116 if (optionalFieldPresent[5])
2121 if (optionalFieldPresent[4])
2126 if (optionalFieldPresent[3])
2131 physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPresent[2];
2132 if (optionalFieldPresent[2])
2136 bIterator = DeserializeChoice (2,
false,&sel,bIterator);
2140 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::RESET;
2142 bIterator = DeserializeNull (bIterator);
2147 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::SETUP;
2149 std::bitset<0> bitset0;
2150 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2155 bIterator = DeserializeEnum (4,&slct,bIterator);
2156 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = slct;
2159 bIterator = DeserializeEnum (4,&slct,bIterator);
2162 bIterator = DeserializeInteger (&slct,0,23,bIterator);
2166 bIterator = DeserializeBoolean (&duration,bIterator);
2169 bIterator = DeserializeInteger (&slct,0,1023,bIterator);
2170 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex = slct;
2173 bIterator = DeserializeInteger (&slct,0,1,bIterator);
2176 bIterator = DeserializeEnum (8,&slct,bIterator);
2179 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1];
2180 if (optionalFieldPresent[1])
2184 bIterator = DeserializeChoice (2,
false,&sel,bIterator);
2187 bIterator = DeserializeNull (bIterator);
2191 std::bitset<1> codebookSubsetRestrictionPresent;
2192 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,
false,bIterator);
2195 bIterator = DeserializeEnum (8,&txmode,bIterator);
2196 physicalConfigDedicated->antennaInfo.transmissionMode = txmode;
2198 if (codebookSubsetRestrictionPresent[0])
2204 int txantennaselchosen;
2205 bIterator = DeserializeChoice (2,
false,&txantennaselchosen,bIterator);
2206 if (txantennaselchosen == 0)
2209 bIterator = DeserializeNull (bIterator);
2211 else if (txantennaselchosen == 1)
2218 if (optionalFieldPresent[0])
2229 os <<
" srbToAddModList: " << std::endl;
2230 std::list<LteRrcSap::SrbToAddMod>::iterator it = radioResourceConfigDedicated.srbToAddModList.begin ();
2231 for (; it != radioResourceConfigDedicated.srbToAddModList.end (); it++)
2233 os <<
" srbIdentity: " << (int)it->srbIdentity << std::endl;
2234 os <<
" logicalChannelConfig: " << std::endl;
2235 os <<
" priority: " << (
int)it->logicalChannelConfig.priority << std::endl;
2236 os <<
" prioritizedBitRateKbps: " << (int)it->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
2237 os <<
" bucketSizeDurationMs: " << (
int)it->logicalChannelConfig.bucketSizeDurationMs << std::endl;
2238 os <<
" logicalChannelGroup: " << (int)it->logicalChannelConfig.logicalChannelGroup << std::endl;
2242 os <<
" drbToAddModList: " << std::endl;
2243 std::list<LteRrcSap::DrbToAddMod>::iterator it2 = radioResourceConfigDedicated.drbToAddModList.begin ();
2244 for (; it2 != radioResourceConfigDedicated.drbToAddModList.end (); it2++)
2246 os <<
" epsBearerIdentity: " << (int)it2->epsBearerIdentity << std::endl;
2247 os <<
" drbIdentity: " << (
int)it2->drbIdentity << std::endl;
2248 os <<
" rlcConfig: " << it2->rlcConfig.choice << std::endl;
2249 os <<
" logicalChannelIdentity: " << (int)it2->logicalChannelIdentity << std::endl;
2250 os <<
" logicalChannelConfig: " << std::endl;
2251 os <<
" priority: " << (
int)it2->logicalChannelConfig.priority << std::endl;
2252 os <<
" prioritizedBitRateKbps: " << (int)it2->logicalChannelConfig.prioritizedBitRateKbps << std::endl;
2253 os <<
" bucketSizeDurationMs: " << (
int)it2->logicalChannelConfig.bucketSizeDurationMs << std::endl;
2254 os <<
" logicalChannelGroup: " << (int)it2->logicalChannelConfig.logicalChannelGroup << std::endl;
2258 os <<
" drbToReleaseList: ";
2259 std::list<uint8_t>::iterator it3 = radioResourceConfigDedicated.drbToReleaseList.begin ();
2260 for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end (); it3++)
2262 os << (int)*it3 <<
", ";
2266 os <<
" havePhysicalConfigDedicated: " << radioResourceConfigDedicated.havePhysicalConfigDedicated << std::endl;
2268 if (radioResourceConfigDedicated.havePhysicalConfigDedicated)
2270 os <<
" physicalConfigDedicated: " << std::endl;
2272 os <<
" haveSoundingRsUlConfigDedicated: " << radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated << std::endl;
2273 if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated)
2275 os <<
" soundingRsUlConfigDedicated: " << std::endl;
2276 os <<
" type: " << radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.type << std::endl;
2277 os <<
" srsBandwidth: " << (int)radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth << std::endl;
2278 os <<
" srsConfigIndex: " << (
int)radioResourceConfigDedicated.physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex << std::endl;
2281 os <<
" haveAntennaInfoDedicated: " << radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated << std::endl;
2282 if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDedicated)
2284 os <<
" antennaInfo Tx mode: " << (int)radioResourceConfigDedicated.physicalConfigDedicated.antennaInfo.transmissionMode << std::endl;
2292 std::bitset<0> bitset0;
2295 std::bitset<3> sysInfoBlkT1Opts;
2296 bIterator = DeserializeSequence (&sysInfoBlkT1Opts,
false,bIterator);
2299 std::bitset<1> cellAccessRelatedInfoOpts;
2300 bIterator = DeserializeSequence (&cellAccessRelatedInfoOpts,
false,bIterator);
2303 int numPlmnIdentityInfoElements;
2304 bIterator = DeserializeSequenceOf (&numPlmnIdentityInfoElements,6,1,bIterator);
2305 for (
int i = 0; i < numPlmnIdentityInfoElements; i++)
2307 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2310 bIterator = DeserializePlmnIdentity (&systemInformationBlockType1->cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity,bIterator);
2314 std::bitset<16> trackingAreaCode;
2315 bIterator = DeserializeBitstring (&trackingAreaCode,bIterator);
2318 std::bitset<28> cellIdentity;
2319 bIterator = DeserializeBitstring (&cellIdentity,bIterator);
2320 systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdentity.to_ulong ();
2323 bIterator = DeserializeEnum (2,&n,bIterator);
2326 bIterator = DeserializeEnum (2,&n,bIterator);
2329 bIterator = DeserializeBoolean (&systemInformationBlockType1->cellAccessRelatedInfo.csgIndication,bIterator);
2331 if (cellAccessRelatedInfoOpts[0])
2334 std::bitset<27> csgIdentity;
2335 bIterator = DeserializeBitstring (&csgIdentity,bIterator);
2336 systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIdentity.to_ulong ();
2340 std::bitset<1> qRxLevMinOffsetPresent;
2341 bIterator = DeserializeSequence (&qRxLevMinOffsetPresent,
false,bIterator);
2342 bIterator = DeserializeInteger (&n,-70,-22,bIterator);
2343 if (qRxLevMinOffsetPresent[0])
2349 if (sysInfoBlkT1Opts[2])
2356 bIterator = DeserializeInteger (&n,1,64,bIterator);
2359 int numSchedulingInfo;
2360 bIterator = DeserializeSequenceOf (&numSchedulingInfo,MAX_SI_MESSAGE,1,bIterator);
2361 for (
int i = 0; i < numSchedulingInfo; i++)
2363 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2364 bIterator = DeserializeEnum (7,&n,bIterator);
2366 bIterator = DeserializeSequenceOf (&numSibType,MAX_SIB - 1,0, bIterator);
2367 for (
int j = 0; j < numSibType; j++)
2369 bIterator = DeserializeEnum (16,&n,bIterator);
2373 if (sysInfoBlkT1Opts[1])
2380 bIterator = DeserializeEnum (7,&n,bIterator);
2383 bIterator = DeserializeInteger (&n,0,31,bIterator);
2385 if (sysInfoBlkT1Opts[0])
2394 RrcAsn1Header::DeserializeSystemInformationBlockType2 (LteRrcSap::SystemInformationBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator)
2396 std::bitset<0> bitset0;
2399 std::bitset<2> sysInfoBlkT2Opts;
2400 bIterator = DeserializeSequence (&sysInfoBlkT2Opts,
true,bIterator);
2401 if (sysInfoBlkT2Opts[1])
2408 bIterator = DeserializeRadioResourceConfigCommonSib (&systemInformationBlockType2->radioResourceConfigCommon, bIterator);
2411 bIterator = DeserializeSequence (&bitset0,
true,bIterator);
2412 bIterator = DeserializeEnum (8,&n,bIterator);
2413 bIterator = DeserializeEnum (8,&n,bIterator);
2414 bIterator = DeserializeEnum (7,&n,bIterator);
2415 bIterator = DeserializeEnum (8,&n,bIterator);
2416 bIterator = DeserializeEnum (7,&n,bIterator);
2417 bIterator = DeserializeEnum (8,&n,bIterator);
2420 std::bitset<2> freqInfoOpts;
2421 bIterator = DeserializeSequence (&freqInfoOpts,
false,bIterator);
2422 if (freqInfoOpts[1])
2425 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator);
2426 systemInformationBlockType2->freqInfo.ulCarrierFreq = n;
2428 if (freqInfoOpts[0])
2431 bIterator = DeserializeEnum (6, &n, bIterator);
2435 systemInformationBlockType2->freqInfo.ulBandwidth = 6;
2438 systemInformationBlockType2->freqInfo.ulBandwidth = 15;
2441 systemInformationBlockType2->freqInfo.ulBandwidth = 25;
2444 systemInformationBlockType2->freqInfo.ulBandwidth = 50;
2447 systemInformationBlockType2->freqInfo.ulBandwidth = 75;
2450 systemInformationBlockType2->freqInfo.ulBandwidth = 100;
2453 systemInformationBlockType2->freqInfo.ulBandwidth = 6;
2458 bIterator = DeserializeInteger (&n,1,32,bIterator);
2460 if (sysInfoBlkT2Opts[0])
2467 bIterator = DeserializeEnum (8,&n,bIterator);
2474 RrcAsn1Header::DeserializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfigCommon * radioResourceConfigCommon, Buffer::Iterator bIterator)
2476 std::bitset<0> bitset0;
2479 std::bitset<9> rrCfgCommOptions;
2480 bIterator = DeserializeSequence (&rrCfgCommOptions,
true,bIterator);
2483 if (rrCfgCommOptions[8])
2485 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommon->rachConfigCommon, bIterator);
2489 std::bitset<1> prachConfigInfoPresent;
2490 bIterator = DeserializeSequence (&prachConfigInfoPresent,
false,bIterator);
2493 bIterator = DeserializeInteger (&n,0,1023,bIterator);
2496 if (prachConfigInfoPresent[0])
2502 if (rrCfgCommOptions[7])
2508 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2511 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2514 bIterator = DeserializeInteger (&n,1,4,bIterator);
2517 bIterator = DeserializeEnum (2,&n,bIterator);
2520 bIterator = DeserializeInteger (&n,0,98,bIterator);
2524 bIterator = DeserializeBoolean (&enable64QAM,bIterator);
2527 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2531 bIterator = DeserializeBoolean (&dummyBool,bIterator);
2534 bIterator = DeserializeInteger (&n,0,29,bIterator);
2537 bIterator = DeserializeBoolean (&dummyBool,bIterator);
2540 bIterator = DeserializeInteger (&n,0,7,bIterator);
2543 if (rrCfgCommOptions[6])
2549 if (rrCfgCommOptions[5])
2555 if (rrCfgCommOptions[4])
2561 if (rrCfgCommOptions[3])
2567 if (rrCfgCommOptions[2])
2573 if (rrCfgCommOptions[1])
2579 if (rrCfgCommOptions[0])
2585 bIterator = DeserializeEnum (2,&n,bIterator);
2591 RrcAsn1Header::DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rachConfigCommon, Buffer::Iterator bIterator)
2593 std::bitset<0> bitset0;
2596 bIterator = DeserializeSequence (&bitset0,
true,bIterator);
2599 std::bitset<1> preamblesGroupAConfigPresent;
2600 bIterator = DeserializeSequence (&preamblesGroupAConfigPresent,
false,bIterator);
2603 bIterator = DeserializeEnum (16,&n,bIterator);
2607 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4;
2610 rachConfigCommon->preambleInfo.numberOfRaPreambles = 8;
2613 rachConfigCommon->preambleInfo.numberOfRaPreambles = 12;
2616 rachConfigCommon->preambleInfo.numberOfRaPreambles = 16;
2619 rachConfigCommon->preambleInfo.numberOfRaPreambles = 20;
2622 rachConfigCommon->preambleInfo.numberOfRaPreambles = 24;
2625 rachConfigCommon->preambleInfo.numberOfRaPreambles = 28;
2628 rachConfigCommon->preambleInfo.numberOfRaPreambles = 32;
2631 rachConfigCommon->preambleInfo.numberOfRaPreambles = 36;
2634 rachConfigCommon->preambleInfo.numberOfRaPreambles = 40;
2637 rachConfigCommon->preambleInfo.numberOfRaPreambles = 44;
2640 rachConfigCommon->preambleInfo.numberOfRaPreambles = 48;
2643 rachConfigCommon->preambleInfo.numberOfRaPreambles = 52;
2646 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56;
2649 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60;
2652 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64;
2655 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0;
2658 rachConfigCommon->preambleInfo.numberOfRaPreambles = n;
2660 if (preamblesGroupAConfigPresent[0])
2667 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2668 bIterator = DeserializeEnum (4,&n,bIterator);
2669 bIterator = DeserializeEnum (16,&n,bIterator);
2672 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2673 bIterator = DeserializeEnum (11,&n,bIterator);
2677 rachConfigCommon->raSupervisionInfo.preambleTransMax = 3;
2680 rachConfigCommon->raSupervisionInfo.preambleTransMax = 4;
2683 rachConfigCommon->raSupervisionInfo.preambleTransMax = 5;
2686 rachConfigCommon->raSupervisionInfo.preambleTransMax = 6;
2689 rachConfigCommon->raSupervisionInfo.preambleTransMax = 7;
2692 rachConfigCommon->raSupervisionInfo.preambleTransMax = 8;
2695 rachConfigCommon->raSupervisionInfo.preambleTransMax = 10;
2698 rachConfigCommon->raSupervisionInfo.preambleTransMax = 20;
2701 rachConfigCommon->raSupervisionInfo.preambleTransMax = 50;
2704 rachConfigCommon->raSupervisionInfo.preambleTransMax = 100;
2707 rachConfigCommon->raSupervisionInfo.preambleTransMax = 200;
2710 rachConfigCommon->raSupervisionInfo.preambleTransMax = 0;
2714 bIterator = DeserializeEnum (8,&n,bIterator);
2718 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2;
2721 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3;
2724 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4;
2727 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5;
2730 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6;
2733 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7;
2736 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8;
2739 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10;
2742 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0;
2745 bIterator = DeserializeEnum (8,&n,bIterator);
2746 bIterator = DeserializeInteger (&n,1,8,bIterator);
2751 RrcAsn1Header::DeserializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceConfigCommonSib * radioResourceConfigCommonSib, Buffer::Iterator bIterator)
2753 std::bitset<0> bitset0;
2756 bIterator = DeserializeSequence (&bitset0,
true,bIterator);
2759 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommonSib->rachConfigCommon, bIterator);
2762 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2763 bIterator = DeserializeEnum (4,&n,bIterator);
2766 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2767 bIterator = DeserializeEnum (4,&n,bIterator);
2768 bIterator = DeserializeEnum (8,&n,bIterator);
2771 std::bitset<1> prachConfigInfoPresent;
2772 bIterator = DeserializeSequence (&prachConfigInfoPresent,
false,bIterator);
2774 bIterator = DeserializeInteger (&n,0,1023,bIterator);
2776 if (prachConfigInfoPresent[0])
2782 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2783 bIterator = DeserializeInteger (&n,-60,50,bIterator);
2784 bIterator = DeserializeInteger (&n,0,3,bIterator);
2787 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2790 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2793 bIterator = DeserializeInteger (&n,1,4,bIterator);
2796 bIterator = DeserializeEnum (2,&n,bIterator);
2799 bIterator = DeserializeInteger (&n,0,98,bIterator);
2803 bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
2806 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2809 bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
2812 bIterator = DeserializeInteger (&n,0,29,bIterator);
2815 bIterator = DeserializeBoolean (&dummyBoolean,bIterator);
2818 bIterator = DeserializeInteger (&n,0,7,bIterator);
2821 bIterator = DeserializeEnum (3,&n,bIterator);
2822 bIterator = DeserializeInteger (&n,0,98,bIterator);
2823 bIterator = DeserializeInteger (&n,0,7,bIterator);
2824 bIterator = DeserializeInteger (&n,0,2047,bIterator);
2828 bIterator = DeserializeChoice (2,
false,&choice,bIterator);
2831 bIterator = DeserializeNull (bIterator);
2840 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2841 bIterator = DeserializeInteger (&n,-126,24,bIterator);
2842 bIterator = DeserializeEnum (8,&n,bIterator);
2843 bIterator = DeserializeInteger (&n,-127,-96,bIterator);
2845 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
2846 bIterator = DeserializeEnum (3,&n,bIterator);
2847 bIterator = DeserializeEnum (3,&n,bIterator);
2848 bIterator = DeserializeEnum (4,&n,bIterator);
2849 bIterator = DeserializeEnum (3,&n,bIterator);
2850 bIterator = DeserializeEnum (3,&n,bIterator);
2851 bIterator = DeserializeInteger (&n,-1,6,bIterator);
2854 bIterator = DeserializeEnum (2,&n,bIterator);
2860 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buffer::Iterator bIterator)
2864 std::bitset<1> measResultNeighCellsPresent;
2865 bIterator = DeserializeSequence (&measResultNeighCellsPresent,
true,bIterator);
2868 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
2869 measResults->measId = n;
2872 bIterator = DeserializeSequence (&b0,
false,bIterator);
2875 bIterator = DeserializeInteger (&n, 0, 97, bIterator);
2876 measResults->rsrpResult = n;
2879 bIterator = DeserializeInteger (&n, 0, 34, bIterator);
2880 measResults->rsrqResult = n;
2882 measResults->haveMeasResultNeighCells = measResultNeighCellsPresent[0];
2883 if ( measResults->haveMeasResultNeighCells)
2885 int measResultNeighCellsChoice;
2888 bIterator = DeserializeChoice (4,
false,&measResultNeighCellsChoice,bIterator);
2890 if (measResultNeighCellsChoice == 0)
2894 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterator);
2896 for (
int i = 0; i < numElems; i++)
2898 LteRrcSap::MeasResultEutra measResultEutra;
2900 std::bitset<1> isCgiInfoPresent;
2901 bIterator = DeserializeSequence (&isCgiInfoPresent,
false,bIterator);
2904 bIterator = DeserializeInteger (&n,0,503,bIterator);
2905 measResultEutra.physCellId = n;
2907 measResultEutra.haveCgiInfo = isCgiInfoPresent[0];
2908 if (isCgiInfoPresent[0])
2910 std::bitset<1> havePlmnIdentityList;
2911 bIterator = DeserializeSequence (&havePlmnIdentityList,
false,bIterator);
2914 bIterator = DeserializeSequence (&b0,
false,bIterator);
2917 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.plmnIdentity,bIterator);
2920 std::bitset<28> cellId;
2921 bIterator = DeserializeBitstring (&cellId,bIterator);
2922 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong ();
2925 std::bitset<16> trArCo;
2926 bIterator = DeserializeBitstring (&trArCo,bIterator);
2927 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong ();
2930 if (havePlmnIdentityList[0])
2933 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bIterator);
2935 for (
int j = 0; j < numPlmnElems; j++)
2938 bIterator = DeserializePlmnIdentity (&plmnId,bIterator);
2939 measResultEutra.cgiInfo.plmnIdentityList.push_back (plmnId);
2945 std::bitset<2> measResultOpts;
2946 bIterator = DeserializeSequence (&measResultOpts,
true, bIterator);
2948 measResultEutra.haveRsrpResult = measResultOpts[1];
2949 if (measResultOpts[1])
2952 bIterator = DeserializeInteger (&n,0,97,bIterator);
2953 measResultEutra.rsrpResult = n;
2956 measResultEutra.haveRsrqResult = measResultOpts[0];
2957 if (measResultOpts[0])
2960 bIterator = DeserializeInteger (&n,0,34,bIterator);
2961 measResultEutra.rsrqResult = n;
2964 measResults->measResultListEutra.push_back (measResultEutra);
2968 if (measResultNeighCellsChoice == 1)
2974 if (measResultNeighCellsChoice == 2)
2979 if (measResultNeighCellsChoice == 3)
2990 RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIterator)
2993 std::bitset<1> isMccPresent;
2994 bIterator = DeserializeSequence (&isMccPresent,
false,bIterator);
2996 if (isMccPresent[0])
3005 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator);
3007 for (
int j = mncDigits - 1; j >= 0; j--)
3009 bIterator = DeserializeInteger (&n,0,9,bIterator);
3010 mnc += n * pow (10,j);
3016 bIterator = DeserializeEnum (2,&n,bIterator);
3021 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator)
3023 std::bitset<0> bitset0;
3024 std::bitset<2> bitset2;
3025 std::bitset<11> bitset11;
3029 bIterator = DeserializeSequence (&bitset11,
true,bIterator);
3034 int measObjectToRemoveListElems;
3035 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator);
3037 for (
int i = 0; i < measObjectToRemoveListElems; i++)
3039 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
3040 measConfig->measObjectToRemoveList.push_back (n);
3047 int measObjectToAddModListElems;
3048 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator);
3050 for (
int i = 0; i < measObjectToAddModListElems; i++)
3052 LteRrcSap::MeasObjectToAddMod * elem =
new LteRrcSap::MeasObjectToAddMod ();
3054 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3056 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
3057 elem->measObjectId = n;
3059 int measObjectChoice;
3060 bIterator = DeserializeChoice (4,
true, &measObjectChoice, bIterator);
3062 switch (measObjectChoice)
3082 std::bitset<5> measObjectEutraOpts;
3083 bIterator = DeserializeSequence (&measObjectEutraOpts,
true, bIterator);
3086 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator);
3087 elem->measObjectEutra.carrierFreq = n;
3090 bIterator = DeserializeEnum (6, &n, bIterator);
3094 elem->measObjectEutra.allowedMeasBandwidth = 6;
3097 elem->measObjectEutra.allowedMeasBandwidth = 15;
3100 elem->measObjectEutra.allowedMeasBandwidth = 25;
3103 elem->measObjectEutra.allowedMeasBandwidth = 50;
3106 elem->measObjectEutra.allowedMeasBandwidth = 75;
3110 elem->measObjectEutra.allowedMeasBandwidth = 100;
3115 bIterator = DeserializeBoolean (&elem->measObjectEutra.presenceAntennaPort1, bIterator);
3118 bIterator = DeserializeBitstring (&bitset2, bIterator);
3119 elem->measObjectEutra.neighCellConfig = bitset2.to_ulong ();
3122 DeserializeQoffsetRange (&elem->measObjectEutra.offsetFreq, bIterator);
3124 if (measObjectEutraOpts[4])
3128 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
3130 for (
int i = 0; i < numElems; i++)
3132 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
3133 elem->measObjectEutra.cellsToRemoveList.push_back (n);
3137 if (measObjectEutraOpts[3])
3141 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
3143 for (
int i = 0; i < numElems; i++)
3145 LteRrcSap::CellsToAddMod * cellsToAddMod =
new LteRrcSap::CellsToAddMod ();
3147 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3150 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
3151 cellsToAddMod->cellIndex = n;
3154 bIterator = DeserializeInteger (&n, 0, 503, bIterator);
3155 cellsToAddMod->physCellId = n;
3158 bIterator = DeserializeQoffsetRange ( &cellsToAddMod->cellIndividualOffset, bIterator);
3160 elem->measObjectEutra.cellsToAddModList.push_back (*cellsToAddMod);
3164 if (measObjectEutraOpts[2])
3168 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
3170 for (
int i = 0; i < numElems; i++)
3172 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
3173 elem->measObjectEutra.blackCellsToRemoveList.push_back (n);
3178 if (measObjectEutraOpts[1])
3182 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
3184 for (
int i = 0; i < numElems; i++)
3186 LteRrcSap::BlackCellsToAddMod * blackCellsToAddMod =
new LteRrcSap::BlackCellsToAddMod ();
3187 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3189 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
3190 blackCellsToAddMod->cellIndex = n;
3193 std::bitset<1> isRangePresent;
3194 bIterator = DeserializeSequence (&isRangePresent,
false, bIterator);
3197 bIterator = DeserializeInteger (&n, 0, 503, bIterator);
3198 blackCellsToAddMod->physCellIdRange.start = n;
3200 blackCellsToAddMod->physCellIdRange.haveRange = isRangePresent[0];
3201 if (blackCellsToAddMod->physCellIdRange.haveRange)
3204 bIterator = DeserializeEnum (16, &n, bIterator);
3208 blackCellsToAddMod->physCellIdRange.range = 4;
3211 blackCellsToAddMod->physCellIdRange.range = 8;
3214 blackCellsToAddMod->physCellIdRange.range = 12;
3217 blackCellsToAddMod->physCellIdRange.range = 16;
3220 blackCellsToAddMod->physCellIdRange.range = 24;
3223 blackCellsToAddMod->physCellIdRange.range = 32;
3226 blackCellsToAddMod->physCellIdRange.range = 48;
3229 blackCellsToAddMod->physCellIdRange.range = 64;
3232 blackCellsToAddMod->physCellIdRange.range = 84;
3235 blackCellsToAddMod->physCellIdRange.range = 96;
3238 blackCellsToAddMod->physCellIdRange.range = 128;
3241 blackCellsToAddMod->physCellIdRange.range = 168;
3244 blackCellsToAddMod->physCellIdRange.range = 252;
3247 blackCellsToAddMod->physCellIdRange.range = 504;
3250 blackCellsToAddMod->physCellIdRange.range = 0;
3254 elem->measObjectEutra.blackCellsToAddModList.push_back (*blackCellsToAddMod);
3258 elem->measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0];
3259 if (measObjectEutraOpts[0])
3262 bIterator = DeserializeInteger (&n, 0, 503, bIterator);
3263 elem->measObjectEutra.cellForWhichToReportCGI = n;
3266 measConfig->measObjectToAddModList.push_back (*elem);
3273 int reportConfigToRemoveListElems;
3274 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
3276 for (
int i = 0; i < reportConfigToRemoveListElems; i++)
3278 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
3279 measConfig->reportConfigToRemoveList.push_back (n);
3286 int reportConfigToAddModListElems;
3287 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
3289 for (
int i = 0; i < reportConfigToAddModListElems; i++)
3291 LteRrcSap::ReportConfigToAddMod * elem =
new LteRrcSap::ReportConfigToAddMod ();
3293 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3294 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
3295 elem->reportConfigId = n;
3298 int reportConfigChoice;
3299 bIterator = DeserializeChoice (2,
false, &reportConfigChoice, bIterator);
3301 if (reportConfigChoice == 0)
3304 bIterator = DeserializeSequence (&bitset0,
true, bIterator);
3307 int triggerTypeChoice;
3308 bIterator = DeserializeChoice (2,
false, &triggerTypeChoice, bIterator);
3310 if (triggerTypeChoice == 0)
3313 elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event;
3314 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3318 bIterator = DeserializeChoice (5,
true, &eventIdChoice, bIterator);
3320 switch (eventIdChoice)
3323 elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1;
3324 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3325 bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator);
3329 elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2;
3330 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3331 bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator);
3335 elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3;
3336 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3337 bIterator = DeserializeInteger (&n, -30, 30, bIterator);
3338 elem->reportConfigEutra.a3Offset = n;
3339 bIterator = DeserializeBoolean (&elem->reportConfigEutra.reportOnLeave, bIterator);
3343 elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4;
3344 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3345 bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator);
3349 elem->reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5;
3350 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3351 bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold1, bIterator);
3352 bIterator = DeserializeThresholdEutra (&elem->reportConfigEutra.threshold2, bIterator);
3356 bIterator = DeserializeInteger (&n, 0, 30, bIterator);
3357 elem->reportConfigEutra.hysteresis = n;
3359 bIterator = DeserializeEnum (16, &n, bIterator);
3363 elem->reportConfigEutra.timeToTrigger = 0;
3366 elem->reportConfigEutra.timeToTrigger = 40;
3369 elem->reportConfigEutra.timeToTrigger = 64;
3372 elem->reportConfigEutra.timeToTrigger = 80;
3375 elem->reportConfigEutra.timeToTrigger = 100;
3378 elem->reportConfigEutra.timeToTrigger = 128;
3381 elem->reportConfigEutra.timeToTrigger = 160;
3384 elem->reportConfigEutra.timeToTrigger = 256;
3387 elem->reportConfigEutra.timeToTrigger = 320;
3390 elem->reportConfigEutra.timeToTrigger = 480;
3393 elem->reportConfigEutra.timeToTrigger = 512;
3396 elem->reportConfigEutra.timeToTrigger = 640;
3399 elem->reportConfigEutra.timeToTrigger = 1024;
3402 elem->reportConfigEutra.timeToTrigger = 1280;
3405 elem->reportConfigEutra.timeToTrigger = 2560;
3409 elem->reportConfigEutra.timeToTrigger = 5120;
3414 if (triggerTypeChoice == 1)
3417 elem->reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical;
3419 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3420 bIterator = DeserializeEnum (2, &n, bIterator);
3423 elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells;
3427 elem->reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi;
3432 bIterator = DeserializeEnum (2, &n, bIterator);
3435 elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp;
3439 elem->reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq;
3443 bIterator = DeserializeEnum (2, &n, bIterator);
3446 elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity;
3450 elem->reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both;
3454 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator);
3455 elem->reportConfigEutra.maxReportCells = n;
3458 bIterator = DeserializeEnum (16, &n, bIterator);
3462 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120;
3465 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240;
3468 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480;
3471 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640;
3474 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024;
3477 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048;
3480 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120;
3483 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240;
3486 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1;
3489 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6;
3492 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12;
3495 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30;
3498 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60;
3501 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3;
3504 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2;
3508 elem->reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1;
3512 bIterator = DeserializeEnum (8, &n, bIterator);
3516 elem->reportConfigEutra.reportAmount = 1;
3519 elem->reportConfigEutra.reportAmount = 2;
3522 elem->reportConfigEutra.reportAmount = 4;
3525 elem->reportConfigEutra.reportAmount = 8;
3528 elem->reportConfigEutra.reportAmount = 16;
3531 elem->reportConfigEutra.reportAmount = 32;
3534 elem->reportConfigEutra.reportAmount = 64;
3537 elem->reportConfigEutra.reportAmount = 0;
3541 if (reportConfigChoice == 1)
3547 measConfig->reportConfigToAddModList.push_back (*elem);
3554 int measIdToRemoveListElems;
3555 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator);
3557 for (
int i = 0; i < measIdToRemoveListElems; i++)
3559 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
3560 measConfig->measIdToRemoveList.push_back (n);
3567 int measIdToAddModListElems;
3568 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator);
3570 for (
int i = 0; i < measIdToAddModListElems; i++)
3572 LteRrcSap::MeasIdToAddMod * elem =
new LteRrcSap::MeasIdToAddMod ();
3574 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3576 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
3579 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
3580 elem->measObjectId = n;
3582 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
3583 elem->reportConfigId = n;
3585 measConfig->measIdToAddModList.push_back (*elem);
3589 measConfig->haveQuantityConfig = bitset11[4];
3590 if (measConfig->haveQuantityConfig)
3593 std::bitset<4> quantityConfigOpts;
3594 bIterator = DeserializeSequence (&quantityConfigOpts,
true, bIterator);
3596 if (quantityConfigOpts[3])
3599 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
3600 bIterator = DeserializeEnum (16, &n, bIterator);
3604 measConfig->quantityConfig.filterCoefficientRSRP = 0;
3607 measConfig->quantityConfig.filterCoefficientRSRP = 1;
3610 measConfig->quantityConfig.filterCoefficientRSRP = 2;
3613 measConfig->quantityConfig.filterCoefficientRSRP = 3;
3616 measConfig->quantityConfig.filterCoefficientRSRP = 4;
3619 measConfig->quantityConfig.filterCoefficientRSRP = 5;
3622 measConfig->quantityConfig.filterCoefficientRSRP = 6;
3625 measConfig->quantityConfig.filterCoefficientRSRP = 7;
3628 measConfig->quantityConfig.filterCoefficientRSRP = 8;
3631 measConfig->quantityConfig.filterCoefficientRSRP = 9;
3634 measConfig->quantityConfig.filterCoefficientRSRP = 11;
3637 measConfig->quantityConfig.filterCoefficientRSRP = 13;
3640 measConfig->quantityConfig.filterCoefficientRSRP = 15;
3643 measConfig->quantityConfig.filterCoefficientRSRP = 17;
3646 measConfig->quantityConfig.filterCoefficientRSRP = 19;
3649 measConfig->quantityConfig.filterCoefficientRSRP = 0;
3652 measConfig->quantityConfig.filterCoefficientRSRP = 4;
3654 bIterator = DeserializeEnum (16, &n, bIterator);
3658 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
3661 measConfig->quantityConfig.filterCoefficientRSRQ = 1;
3664 measConfig->quantityConfig.filterCoefficientRSRQ = 2;
3667 measConfig->quantityConfig.filterCoefficientRSRQ = 3;
3670 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
3673 measConfig->quantityConfig.filterCoefficientRSRQ = 5;
3676 measConfig->quantityConfig.filterCoefficientRSRQ = 6;
3679 measConfig->quantityConfig.filterCoefficientRSRQ = 7;
3682 measConfig->quantityConfig.filterCoefficientRSRQ = 8;
3685 measConfig->quantityConfig.filterCoefficientRSRQ = 9;
3688 measConfig->quantityConfig.filterCoefficientRSRQ = 11;
3691 measConfig->quantityConfig.filterCoefficientRSRQ = 13;
3694 measConfig->quantityConfig.filterCoefficientRSRQ = 15;
3697 measConfig->quantityConfig.filterCoefficientRSRQ = 17;
3700 measConfig->quantityConfig.filterCoefficientRSRQ = 19;
3703 measConfig->quantityConfig.filterCoefficientRSRQ = 0;
3706 measConfig->quantityConfig.filterCoefficientRSRQ = 4;
3709 if (quantityConfigOpts[2])
3714 if (quantityConfigOpts[1])
3719 if (quantityConfigOpts[0])
3726 measConfig->haveMeasGapConfig = bitset11[3];
3727 if (measConfig->haveMeasGapConfig)
3730 int measGapConfigChoice;
3731 bIterator = DeserializeChoice (2,
false, &measGapConfigChoice, bIterator);
3732 switch (measGapConfigChoice)
3735 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET;
3736 bIterator = DeserializeNull (bIterator);
3740 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP;
3741 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3743 int gapOffsetChoice;
3744 bIterator = DeserializeChoice (2,
true, &gapOffsetChoice, bIterator);
3745 switch (gapOffsetChoice)
3748 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0;
3749 bIterator = DeserializeInteger (&n, 0, 39, bIterator);
3750 measConfig->measGapConfig.gapOffsetValue = n;
3754 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp1;
3755 bIterator = DeserializeInteger (&n, 0, 79, bIterator);
3756 measConfig->measGapConfig.gapOffsetValue = n;
3761 measConfig->haveSmeasure = bitset11[2];
3762 if (measConfig->haveSmeasure)
3765 bIterator = DeserializeInteger (&n, 0, 97, bIterator);
3766 measConfig->sMeasure = n;
3775 measConfig->haveSpeedStatePars = bitset11[0];
3776 if (measConfig->haveSpeedStatePars)
3779 int speedStateParsChoice;
3780 bIterator = DeserializeChoice (2,
false, &speedStateParsChoice, bIterator);
3781 switch (speedStateParsChoice)
3784 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET;
3785 bIterator = DeserializeNull (bIterator);
3789 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP;
3790 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
3794 bIterator = DeserializeEnum (8, &n, bIterator);
3798 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30;
3801 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 60;
3804 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 120;
3807 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 180;
3810 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 240;
3813 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0;
3816 bIterator = DeserializeEnum (8, &n, bIterator);
3820 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30;
3823 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 60;
3826 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 120;
3829 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 180;
3832 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 240;
3835 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0;
3838 bIterator = DeserializeInteger (&n, 1, 16, bIterator);
3839 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n;
3841 bIterator = DeserializeInteger (&n, 1, 16, bIterator);
3842 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n;
3845 bIterator = DeserializeEnum (4, &n, bIterator);
3846 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25;
3847 bIterator = DeserializeEnum (4, &n, bIterator);
3848 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25;
3856 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage ()
3858 m_mmec = std::bitset<8> (0ul);
3859 m_mTmsi = std::bitset<32> (0ul);
3860 m_establishmentCause = MO_SIGNALLING;
3861 m_spare = std::bitset<1> (0ul);
3865 RrcConnectionRequestHeader::~RrcConnectionRequestHeader ()
3870 RrcConnectionRequestHeader::GetTypeId (
void)
3872 static TypeId tid = TypeId (
"ns3::RrcConnectionRequestHeader")
3873 .SetParent<Header> ()
3881 os <<
"MMEC:" << m_mmec << std::endl;
3882 os <<
"MTMSI:" << m_mTmsi << std::endl;
3883 os <<
"EstablishmentCause:" << m_establishmentCause << std::endl;
3884 os <<
"Spare: " << m_spare << std::endl;
3890 m_serializationResult =
Buffer ();
3892 SerializeUlCcchMessage (1);
3896 SerializeSequence (std::bitset<0> (),
false);
3900 SerializeChoice (2,0,
false);
3904 SerializeSequence (std::bitset<0> (),
false);
3908 SerializeChoice (2,0,
false);
3912 SerializeSequence (std::bitset<0> (),
false);
3915 SerializeBitstring (m_mmec);
3918 SerializeBitstring (m_mTmsi);
3921 SerializeEnum (8,m_establishmentCause);
3924 SerializeBitstring (std::bitset<1> ());
3927 FinalizeSerialization ();
3933 std::bitset<1> dummy;
3934 std::bitset<0> optionalOrDefaultMask;
3937 bIterator = DeserializeUlCcchMessage (bIterator);
3940 bIterator = DeserializeSequence (&optionalOrDefaultMask,
false,bIterator);
3943 bIterator = DeserializeChoice (2,
false,&selectedOption,bIterator);
3946 bIterator = DeserializeSequence (&optionalOrDefaultMask,
false,bIterator);
3949 bIterator = DeserializeChoice (2,
false,&selectedOption,bIterator);
3952 bIterator = DeserializeSequence (&optionalOrDefaultMask,
false,bIterator);
3955 bIterator = DeserializeBitstring (&m_mmec,bIterator);
3958 bIterator = DeserializeBitstring (&m_mTmsi,bIterator);
3961 bIterator = DeserializeEnum (8,&selectedOption,bIterator);
3964 bIterator = DeserializeBitstring (&dummy,bIterator);
3972 m_mTmsi = std::bitset<32> ((uint32_t)msg.ueIdentity);
3973 m_mmec = std::bitset<8> ((uint32_t)(msg.ueIdentity >> 32));
3974 m_isDataSerialized =
false;
3981 msg.ueIdentity = (((uint64_t) m_mmec.to_ulong ()) << 32) | (m_mTmsi.to_ulong ());
4000 RrcConnectionSetupHeader::RrcConnectionSetupHeader ()
4004 RrcConnectionSetupHeader::~RrcConnectionSetupHeader ()
4011 os <<
"rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
4012 os <<
"radioResourceConfigDedicated:" << std::endl;
4019 m_serializationResult =
Buffer ();
4021 SerializeDlCcchMessage (3);
4023 SerializeInteger (15,0,15);
4027 SerializeSequence (std::bitset<0> (),
false);
4030 SerializeInteger (m_rrcTransactionIdentifier,0,3);
4034 SerializeChoice (2,0,
false);
4038 SerializeChoice (8,0,
false);
4042 SerializeSequence (std::bitset<1> (0),
false);
4045 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
4049 SerializeSequence (std::bitset<2> (0),
false);
4052 FinalizeSerialization ();
4061 std::bitset<0> bitset0;
4062 std::bitset<1> bitset1;
4063 std::bitset<2> bitset2;
4065 bIterator = DeserializeDlCcchMessage (bIterator);
4067 bIterator = DeserializeInteger (&n,0,15,bIterator);
4070 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4073 bIterator = DeserializeInteger (&n,0,3,bIterator);
4074 m_rrcTransactionIdentifier = n;
4077 int criticalExtensionChoice;
4078 bIterator = DeserializeChoice (2,
false,&criticalExtensionChoice,bIterator);
4079 if (criticalExtensionChoice == 1)
4082 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4084 else if (criticalExtensionChoice == 0)
4088 bIterator = DeserializeChoice (8,
false,&c1,bIterator);
4093 bIterator = DeserializeNull (bIterator);
4099 bIterator = DeserializeSequence (&bitset1,
false,bIterator);
4102 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
4108 bIterator = DeserializeSequence (&bitset2,
false,bIterator);
4121 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
4122 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
4123 m_isDataSerialized =
false;
4130 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
4131 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
4138 return m_rrcTransactionIdentifier;
4144 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated;
4147 std::list<LteRrcSap::SrbToAddMod>
4150 return m_radioResourceConfigDedicated.srbToAddModList;
4153 std::list<LteRrcSap::DrbToAddMod>
4156 return m_radioResourceConfigDedicated.drbToAddModList;
4162 return m_radioResourceConfigDedicated.drbToReleaseList;
4168 return m_radioResourceConfigDedicated.physicalConfigDedicated;
4174 return m_radioResourceConfigDedicated;
4179 RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader ()
4183 RrcConnectionSetupCompleteHeader::~RrcConnectionSetupCompleteHeader ()
4190 m_serializationResult =
Buffer ();
4193 SerializeUlDcchMessage (4);
4197 SerializeSequence (std::bitset<0> (),
false);
4200 SerializeInteger (m_rrcTransactionIdentifier,0,3);
4204 SerializeChoice (2,0,
false);
4207 SerializeChoice (4,1,
false);
4213 FinalizeSerialization ();
4219 std::bitset<0> bitset0;
4221 bIterator = DeserializeUlDcchMessage (bIterator);
4223 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4226 bIterator = DeserializeInteger (&n,0,3,bIterator);
4227 m_rrcTransactionIdentifier = n;
4229 bIterator = DeserializeChoice (2,
false,&n,bIterator);
4234 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4240 bIterator = DeserializeChoice (4,
false,&c1Chosen,bIterator);
4249 bIterator = DeserializeNull (bIterator);
4259 os <<
"rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
4265 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
4266 m_isDataSerialized =
false;
4272 return m_rrcTransactionIdentifier;
4279 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
4285 RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader ()
4289 RrcConnectionReconfigurationCompleteHeader::~RrcConnectionReconfigurationCompleteHeader ()
4296 m_serializationResult =
Buffer ();
4299 SerializeUlDcchMessage (2);
4303 SerializeSequence (std::bitset<0> (),
false);
4306 SerializeInteger (m_rrcTransactionIdentifier,0,3);
4310 SerializeChoice (2,1,
false);
4313 SerializeSequence (std::bitset<0> (),
false);
4316 FinalizeSerialization ();
4322 std::bitset<0> bitset0;
4325 bIterator = DeserializeUlDcchMessage (bIterator);
4326 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4328 bIterator = DeserializeInteger (&n,0,3,bIterator);
4329 m_rrcTransactionIdentifier = n;
4331 bIterator = DeserializeChoice (2,
false,&n,bIterator);
4336 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4350 os <<
"rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
4356 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
4357 m_isDataSerialized =
false;
4364 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
4371 return m_rrcTransactionIdentifier;
4376 RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader ()
4380 RrcConnectionReconfigurationHeader::~RrcConnectionReconfigurationHeader ()
4387 m_serializationResult =
Buffer ();
4389 SerializeDlDcchMessage (4);
4393 SerializeSequence (std::bitset<0> (),
false);
4396 SerializeInteger (m_rrcTransactionIdentifier,0,3);
4400 SerializeChoice (2,0,
false);
4404 SerializeChoice (8,0,
false);
4408 std::bitset<6> options;
4409 options.set (5,m_haveMeasConfig);
4410 options.set (4,m_haveMobilityControlInfo);
4412 options.set (2,m_haveRadioResourceConfigDedicated);
4415 SerializeSequence (options,
false);
4417 if (m_haveMeasConfig)
4419 SerializeMeasConfig (m_measConfig);
4422 if (m_haveMobilityControlInfo)
4427 std::bitset<4> mobCtrlIntoOptional;
4428 mobCtrlIntoOptional.set (3,m_mobilityControlInfo.haveCarrierFreq);
4429 mobCtrlIntoOptional.set (2,m_mobilityControlInfo.haveCarrierBandwidth);
4430 mobCtrlIntoOptional.set (1,0);
4431 mobCtrlIntoOptional.set (0,m_mobilityControlInfo.haveRachConfigDedicated);
4432 SerializeSequence (mobCtrlIntoOptional,
true);
4435 SerializeInteger (m_mobilityControlInfo.targetPhysCellId,0,503);
4437 if (m_mobilityControlInfo.haveCarrierFreq)
4439 SerializeSequence (std::bitset<1> (1),
false);
4440 SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,MAX_EARFCN);
4441 SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,MAX_EARFCN);
4444 if (m_mobilityControlInfo.haveCarrierBandwidth)
4446 SerializeSequence (std::bitset<1> (1),
false);
4449 switch (m_mobilityControlInfo.carrierBandwidth.dlBandwidth)
4452 SerializeEnum (16,0);
4455 SerializeEnum (16,1);
4458 SerializeEnum (16,2);
4461 SerializeEnum (16,3);
4464 SerializeEnum (16,4);
4467 SerializeEnum (16,5);
4470 SerializeEnum (16,6);
4474 switch (m_mobilityControlInfo.carrierBandwidth.ulBandwidth)
4477 SerializeEnum (16,0);
4480 SerializeEnum (16,1);
4483 SerializeEnum (16,2);
4486 SerializeEnum (16,3);
4489 SerializeEnum (16,4);
4492 SerializeEnum (16,5);
4495 SerializeEnum (16,6);
4500 SerializeEnum (8,0);
4503 SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity));
4506 SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceConfigCommon);
4508 if (m_mobilityControlInfo.haveRachConfigDedicated)
4510 SerializeSequence (std::bitset<0> (),
false);
4511 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex,0,63);
4512 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex,0,15);
4516 if (m_haveRadioResourceConfigDedicated)
4519 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
4523 FinalizeSerialization ();
4529 std::bitset<0> bitset0;
4531 bIterator = DeserializeDlDcchMessage (bIterator);
4534 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4538 bIterator = DeserializeInteger (&n,0,3,bIterator);
4539 m_rrcTransactionIdentifier = n;
4543 bIterator = DeserializeChoice (2,
false,&sel,bIterator);
4547 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
4553 bIterator = DeserializeChoice (8,
false,&c1Chosen,bIterator);
4556 bIterator = DeserializeNull (bIterator);
4558 else if (c1Chosen == 0)
4561 std::bitset<6> rrcConnRecOpts;
4562 bIterator = DeserializeSequence (&rrcConnRecOpts,
false,bIterator);
4564 m_haveMeasConfig = rrcConnRecOpts[5];
4565 if (m_haveMeasConfig)
4567 bIterator = DeserializeMeasConfig (&m_measConfig, bIterator);
4570 m_haveMobilityControlInfo = rrcConnRecOpts[4];
4571 if (m_haveMobilityControlInfo)
4574 std::bitset<4> mobCtrlOpts;
4575 bIterator = DeserializeSequence (&mobCtrlOpts,
true,bIterator);
4578 bIterator = DeserializeInteger (&n,0,503,bIterator);
4579 m_mobilityControlInfo.targetPhysCellId = n;
4582 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3];
4583 if (m_mobilityControlInfo.haveCarrierFreq)
4585 std::bitset<1> ulCarrierFreqPresent;
4586 bIterator = DeserializeSequence (&ulCarrierFreqPresent,
false,bIterator);
4588 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
4589 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n;
4591 if (ulCarrierFreqPresent[0])
4593 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
4594 m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n;
4599 m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2];
4600 if (m_mobilityControlInfo.haveCarrierBandwidth)
4602 std::bitset<1> ulBandwidthPresent;
4603 bIterator = DeserializeSequence (&ulBandwidthPresent,
false,bIterator);
4605 bIterator = DeserializeEnum (16,&n,bIterator);
4609 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 6;
4612 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 15;
4615 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 25;
4618 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 50;
4621 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 75;
4624 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 100;
4627 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 0;
4631 if (ulBandwidthPresent[0])
4633 bIterator = DeserializeEnum (16,&n,bIterator);
4637 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 6;
4640 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 15;
4643 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 25;
4646 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 50;
4649 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 75;
4652 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 100;
4655 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 0;
4668 bIterator = DeserializeEnum (8,&n,bIterator);
4671 std::bitset<16> cRnti;
4672 bIterator = DeserializeBitstring (&cRnti, bIterator);
4673 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong ();
4676 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityControlInfo.radioResourceConfigCommon, bIterator);
4678 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0];
4679 if (m_mobilityControlInfo.haveRachConfigDedicated)
4681 bIterator = DeserializeSequence (&bitset0,
false, bIterator);
4682 bIterator = DeserializeInteger (&n,0,63, bIterator);
4683 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = n;
4684 bIterator = DeserializeInteger (&n,0,15, bIterator);
4685 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = n;
4690 if (rrcConnRecOpts[3])
4696 m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2];
4697 if (m_haveRadioResourceConfigDedicated)
4699 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
4703 if (rrcConnRecOpts[1])
4709 if (rrcConnRecOpts[0])
4722 os <<
"rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
4723 os <<
"haveMeasConfig: " << m_haveMeasConfig << std::endl;
4724 if (m_haveMobilityControlInfo)
4726 if (!m_measConfig.measObjectToRemoveList.empty ())
4728 os <<
" measObjectToRemoveList: ";
4729 std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
4730 std::list<uint8_t>::iterator it = auxList.begin ();
4731 for (; it != auxList.end (); it++)
4733 os << (int) *it <<
", ";
4737 if (!m_measConfig.reportConfigToRemoveList.empty ())
4739 os <<
" reportConfigToRemoveList: ";
4740 std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
4741 std::list<uint8_t>::iterator it = auxList.begin ();
4742 for (; it != auxList.end (); it++)
4744 os << (int) *it <<
", ";
4748 if (!m_measConfig.measIdToRemoveList.empty ())
4750 os <<
" measIdToRemoveList: ";
4751 std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
4752 std::list<uint8_t>::iterator it = auxList.begin ();
4753 for (; it != auxList.end (); it++)
4755 os << (int) *it <<
", ";
4760 os <<
" haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl;
4761 if (m_measConfig.haveQuantityConfig)
4763 os <<
" filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl;
4764 os <<
" filterCoefficientRSRQ:" << (
int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl;
4767 os <<
" haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl;
4768 if (m_measConfig.haveMeasGapConfig)
4770 os <<
" measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl;
4771 os <<
" measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice
4772 <<
"," << (int) m_measConfig.measGapConfig.gapOffsetValue <<
")" << std::endl;
4775 os <<
" haveSmeasure: " << m_measConfig.haveSmeasure << std::endl;
4776 if (m_measConfig.haveSmeasure)
4778 os <<
" sMeasure: " << (int) m_measConfig.sMeasure << std::endl;
4781 os <<
" haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl;
4782 if (m_measConfig.haveSpeedStatePars)
4784 os <<
" speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl;
4785 os <<
" speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl;
4786 os <<
" speedStatePars.mobilityStateParameters.tHystNormal: " << (
int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl;
4787 os <<
" speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl;
4788 os <<
" speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (
int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl;
4789 os <<
" speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl;
4790 os <<
" speedStatePars.timeToTriggerSf.sfHigh: " << (
int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl;
4794 os <<
"haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl;
4795 if (m_haveMobilityControlInfo)
4797 os <<
"targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellId << std::endl;
4798 os <<
"haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << std::endl;
4799 if (m_mobilityControlInfo.haveCarrierFreq)
4801 os <<
" carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo.carrierFreq.dlCarrierFreq << std::endl;
4802 os <<
" carrierFreq.dlCarrierFreq: " << (
int) m_mobilityControlInfo.carrierFreq.ulCarrierFreq << std::endl;
4804 os <<
"haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandwidth << std::endl;
4805 if (m_mobilityControlInfo.haveCarrierBandwidth)
4807 os <<
" carrierBandwidth.dlBandwidth: " << (int) m_mobilityControlInfo.carrierBandwidth.dlBandwidth << std::endl;
4808 os <<
" carrierBandwidth.ulBandwidth: " << (
int) m_mobilityControlInfo.carrierBandwidth.ulBandwidth << std::endl;
4810 os <<
"newUeIdentity: " << (int) m_mobilityControlInfo.newUeIdentity << std::endl;
4811 os <<
"haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfigDedicated << std::endl;
4812 if (m_mobilityControlInfo.haveRachConfigDedicated)
4814 os <<
"raPreambleIndex: " << (int) m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex << std::endl;
4815 os <<
"raPrachMaskIndex: " << (
int) m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex << std::endl;
4818 os <<
"haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedicated << std::endl;
4819 if (m_haveRadioResourceConfigDedicated)
4828 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
4829 m_haveMeasConfig = msg.haveMeasConfig;
4830 m_measConfig = msg.measConfig;
4831 m_haveMobilityControlInfo = msg.haveMobilityControlInfo;
4832 m_mobilityControlInfo = msg.mobilityControlInfo;
4833 m_haveRadioResourceConfigDedicated = msg.haveRadioResourceConfigDedicated;
4834 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
4836 m_isDataSerialized =
false;
4844 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
4845 msg.haveMeasConfig = m_haveMeasConfig;
4846 msg.measConfig = m_measConfig;
4847 msg.haveMobilityControlInfo = m_haveMobilityControlInfo;
4848 msg.mobilityControlInfo = m_mobilityControlInfo;
4849 msg.haveRadioResourceConfigDedicated = m_haveRadioResourceConfigDedicated;
4850 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
4858 return m_rrcTransactionIdentifier;
4864 return m_haveMeasConfig;
4870 return m_measConfig;
4876 return m_haveMobilityControlInfo;
4882 return m_mobilityControlInfo;
4888 return m_haveRadioResourceConfigDedicated;
4894 return m_radioResourceConfigDedicated;
4900 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated;
4903 std::list<LteRrcSap::SrbToAddMod>
4906 return m_radioResourceConfigDedicated.srbToAddModList;
4909 std::list<LteRrcSap::DrbToAddMod>
4912 return m_radioResourceConfigDedicated.drbToAddModList;
4918 return m_radioResourceConfigDedicated.drbToReleaseList;
4924 return m_radioResourceConfigDedicated.physicalConfigDedicated;
4930 HandoverPreparationInfoHeader::HandoverPreparationInfoHeader ()
4937 m_serializationResult =
Buffer ();
4941 SerializeSequence (std::bitset<0> (),
false);
4945 SerializeChoice (2,0,
false);
4949 SerializeChoice (8,0,
false);
4953 std::bitset<4> handoverPrepInfoOpts;
4954 handoverPrepInfoOpts.set (3,1);
4955 handoverPrepInfoOpts.set (2,0);
4956 handoverPrepInfoOpts.set (1,0);
4957 handoverPrepInfoOpts.set (0,0);
4958 SerializeSequence (handoverPrepInfoOpts,
false);
4961 SerializeSequenceOf (0,MAX_RAT_CAPABILITIES,0);
4964 SerializeSequence (std::bitset<0> (),
true);
4967 SerializeMeasConfig (m_asConfig.sourceMeasConfig);
4970 SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig);
4973 SerializeSequence (std::bitset<0> (),
false);
4975 SerializeEnum (8,0);
4977 SerializeEnum (8,0);
4980 SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity));
4983 SerializeSequence (std::bitset<0> (),
false);
4984 SerializeEnum (6,m_asConfig.sourceMasterInformationBlock.dlBandwidth);
4985 SerializeSequence (std::bitset<0> (),
false);
4986 SerializeEnum (2,0);
4987 SerializeEnum (4,0);
4988 SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.systemFrameNumber));
4989 SerializeBitstring (std::bitset<10> (321));
4992 SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBlockType1);
4995 SerializeSystemInformationBlockType2 (m_asConfig.sourceSystemInformationBlockType2);
4998 SerializeSequence (std::bitset<0> (0),
false);
4999 SerializeEnum (4,0);
5002 SerializeInteger (m_asConfig.sourceDlCarrierFreq,0,MAX_EARFCN);
5005 FinalizeSerialization ();
5011 std::bitset<0> bitset0;
5016 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5019 int criticalExtensionsChosen;
5020 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChosen,bIterator);
5022 if (criticalExtensionsChosen == 1)
5025 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5027 else if (criticalExtensionsChosen == 0)
5031 bIterator = DeserializeChoice (8,
false,&c1Chosen,bIterator);
5034 bIterator = DeserializeNull (bIterator);
5036 else if (c1Chosen == 0)
5039 std::bitset<4> handoverPrepInfoOpts;
5040 bIterator = DeserializeSequence (&handoverPrepInfoOpts,
false,bIterator);
5043 bIterator = DeserializeSequenceOf (&n,MAX_RAT_CAPABILITIES,0,bIterator);
5044 for (
int i = 0; i < n; i++)
5050 if (handoverPrepInfoOpts[3])
5053 bIterator = DeserializeSequence (&bitset0,
true,bIterator);
5056 bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, bIterator);
5059 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.sourceRadioResourceConfig,bIterator);
5062 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5063 bIterator = DeserializeEnum (8,&n,bIterator);
5064 bIterator = DeserializeEnum (8,&n,bIterator);
5067 std::bitset<16> cRnti;
5068 bIterator = DeserializeBitstring (&cRnti,bIterator);
5069 m_asConfig.sourceUeIdentity = cRnti.to_ulong ();
5072 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5073 bIterator = DeserializeEnum (6,&n,bIterator);
5074 m_asConfig.sourceMasterInformationBlock.dlBandwidth = n;
5077 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5078 bIterator = DeserializeEnum (2,&n,bIterator);
5079 bIterator = DeserializeEnum (4,&n,bIterator);
5082 std::bitset<8> systemFrameNumber;
5083 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator);
5084 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = systemFrameNumber.to_ulong ();
5086 std::bitset<10> spare;
5087 bIterator = DeserializeBitstring (&spare,bIterator);
5090 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.sourceSystemInformationBlockType1,bIterator);
5093 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.sourceSystemInformationBlockType2,bIterator);
5096 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5097 bIterator = DeserializeEnum (4,&n,bIterator);
5100 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator);
5101 m_asConfig.sourceDlCarrierFreq = n;
5103 if (handoverPrepInfoOpts[2])
5108 if (handoverPrepInfoOpts[1])
5113 if (handoverPrepInfoOpts[0])
5128 os <<
"sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl;
5129 os <<
"dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBandwidth << std::endl;
5130 os <<
"systemFrameNumber: " << (
int)m_asConfig.sourceMasterInformationBlock.systemFrameNumber << std::endl;
5131 os <<
"plmnIdentityInfo.plmnIdentity: " << (int) m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity << std::endl;
5132 os <<
"cellAccessRelatedInfo.cellIdentity " << (
int)m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity << std::endl;
5133 os <<
"cellAccessRelatedInfo.csgIndication: " << m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication << std::endl;
5134 os <<
"cellAccessRelatedInfo.csgIdentity: " << (int)m_asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity << std::endl;
5135 os <<
"sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl;
5141 m_asConfig = msg.asConfig;
5142 m_isDataSerialized =
false;
5149 msg.asConfig = m_asConfig;
5162 RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader ()
5166 RrcConnectionReestablishmentRequestHeader::~RrcConnectionReestablishmentRequestHeader ()
5173 m_serializationResult =
Buffer ();
5175 SerializeUlCcchMessage (0);
5179 SerializeSequence (std::bitset<0> (),
false);
5183 SerializeChoice (2,0,
false);
5187 SerializeSequence (std::bitset<0> (),
false);
5190 SerializeSequence (std::bitset<0> (),
false);
5192 SerializeBitstring (std::bitset<16> (m_ueIdentity.cRnti));
5194 SerializeInteger (m_ueIdentity.physCellId,0,503);
5196 SerializeBitstring (std::bitset<16> (0));
5199 switch (m_reestablishmentCause)
5201 case LteRrcSap::RECONFIGURATION_FAILURE:
5202 SerializeEnum (4,0);
5204 case LteRrcSap::HANDOVER_FAILURE:
5205 SerializeEnum (4,1);
5207 case LteRrcSap::OTHER_FAILURE:
5208 SerializeEnum (4,2);
5211 SerializeEnum (4,3);
5215 SerializeBitstring (std::bitset<2> (0));
5218 FinalizeSerialization ();
5224 std::bitset<0> bitset0;
5227 bIterator = DeserializeUlCcchMessage (bIterator);
5231 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5234 bIterator = DeserializeChoice (2,
false,&n,bIterator);
5238 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5243 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5246 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5249 std::bitset<16> cRnti;
5250 bIterator = DeserializeBitstring (&cRnti,bIterator);
5251 m_ueIdentity.cRnti = cRnti.to_ulong ();
5255 bIterator = DeserializeInteger (&physCellId,0,503,bIterator);
5256 m_ueIdentity.physCellId = physCellId;
5259 std::bitset<16> shortMacI;
5260 bIterator = DeserializeBitstring (&shortMacI,bIterator);
5264 bIterator = DeserializeEnum (4,&reestCs,bIterator);
5268 m_reestablishmentCause = LteRrcSap::RECONFIGURATION_FAILURE;
5271 m_reestablishmentCause = LteRrcSap::HANDOVER_FAILURE;
5274 m_reestablishmentCause = LteRrcSap::OTHER_FAILURE;
5281 std::bitset<2> spare;
5282 bIterator = DeserializeBitstring (&spare,bIterator);
5291 os <<
"ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl;
5292 os <<
"ueIdentity.physCellId: " << (
int)m_ueIdentity.physCellId << std::endl;
5293 os <<
"m_reestablishmentCause: " << m_reestablishmentCause << std::endl;
5299 m_ueIdentity = msg.ueIdentity;
5300 m_reestablishmentCause = msg.reestablishmentCause;
5301 m_isDataSerialized =
false;
5308 msg.ueIdentity = m_ueIdentity;
5309 msg.reestablishmentCause = m_reestablishmentCause;
5317 return m_ueIdentity;
5320 LteRrcSap::ReestablishmentCause
5323 return m_reestablishmentCause;
5328 RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader ()
5332 RrcConnectionReestablishmentHeader::~RrcConnectionReestablishmentHeader ()
5339 m_serializationResult =
Buffer ();
5341 SerializeDlCcchMessage (0);
5345 SerializeSequence (std::bitset<0> (),
false);
5348 SerializeInteger (m_rrcTransactionIdentifier,0,3);
5351 SerializeChoice (2,0,
false);
5354 SerializeChoice (8,0,
false);
5358 SerializeSequence (std::bitset<1> (0),
false);
5361 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated);
5364 SerializeInteger (0,0,7);
5367 FinalizeSerialization ();
5373 std::bitset<0> bitset0;
5376 bIterator = DeserializeDlCcchMessage (bIterator);
5380 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5383 bIterator = DeserializeInteger (&n,0,3,bIterator);
5384 m_rrcTransactionIdentifier = n;
5387 int criticalExtensionsChoice;
5388 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5389 if (criticalExtensionsChoice == 1)
5392 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5394 else if (criticalExtensionsChoice == 0)
5398 bIterator = DeserializeChoice (8,
false,&c1,bIterator);
5401 bIterator = DeserializeNull (bIterator);
5407 std::bitset<1> nonCriticalExtensionPresent;
5408 bIterator = DeserializeSequence (&nonCriticalExtensionPresent,
false,bIterator);
5411 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceConfigDedicated,bIterator);
5414 bIterator = DeserializeInteger (&n,0,7,bIterator);
5424 os <<
"rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5425 os <<
"RadioResourceConfigDedicated: " << std::endl;
5432 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
5433 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated;
5434 m_isDataSerialized =
false;
5441 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
5442 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;
5449 return m_rrcTransactionIdentifier;
5455 return m_radioResourceConfigDedicated;
5460 RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader ()
5467 m_serializationResult =
Buffer ();
5470 SerializeUlDcchMessage (3);
5474 SerializeSequence (std::bitset<0> (),
false);
5477 SerializeInteger (m_rrcTransactionIdentifier,0,3);
5480 SerializeChoice (2,0,
false);
5484 SerializeSequence (std::bitset<1> (0),
false);
5487 FinalizeSerialization ();
5493 std::bitset<0> bitset0;
5496 bIterator = DeserializeUlDcchMessage (bIterator);
5500 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5503 bIterator = DeserializeInteger (&n,0,3,bIterator);
5504 m_rrcTransactionIdentifier = n;
5507 int criticalExtensionsChoice;
5508 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5509 if (criticalExtensionsChoice == 1)
5512 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5514 else if (criticalExtensionsChoice == 0)
5517 std::bitset<1> opts;
5518 bIterator = DeserializeSequence (&opts,
false,bIterator);
5532 os <<
"rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::endl;
5538 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier;
5539 m_isDataSerialized =
false;
5546 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier;
5553 return m_rrcTransactionIdentifier;
5558 RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader ()
5562 RrcConnectionReestablishmentRejectHeader::~RrcConnectionReestablishmentRejectHeader ()
5569 m_serializationResult =
Buffer ();
5572 SerializeDlCcchMessage (1);
5576 SerializeSequence (std::bitset<0> (),
false);
5579 SerializeChoice (2,0,
false);
5583 SerializeSequence (std::bitset<1> (0),
false);
5586 FinalizeSerialization ();
5592 std::bitset<0> bitset0;
5594 bIterator = DeserializeDlCcchMessage (bIterator);
5598 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5601 int criticalExtensionsChoice;
5602 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5603 if (criticalExtensionsChoice == 1)
5606 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5608 else if (criticalExtensionsChoice == 0)
5611 std::bitset<1> opts;
5612 bIterator = DeserializeSequence (&opts,
false,bIterator);
5631 m_rrcConnectionReestablishmentReject = msg;
5632 m_isDataSerialized =
false;
5638 return m_rrcConnectionReestablishmentReject;
5643 RrcConnectionReleaseHeader::RrcConnectionReleaseHeader ()
5647 RrcConnectionReleaseHeader::~RrcConnectionReleaseHeader ()
5654 m_serializationResult =
Buffer ();
5657 SerializeDlDcchMessage (5);
5661 SerializeSequence (std::bitset<0> (),
false);
5664 SerializeInteger (m_rrcConnectionRelease.rrcTransactionIdentifier,0,3);
5667 SerializeChoice (2,0,
false);
5670 SerializeChoice (4,0,
false);
5674 SerializeSequence (std::bitset<3> (0),
false);
5677 SerializeEnum (4,1);
5680 FinalizeSerialization ();
5686 std::bitset<0> bitset0;
5689 bIterator = DeserializeDlDcchMessage (bIterator);
5693 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5696 bIterator = DeserializeInteger (&n,0,3,bIterator);
5697 m_rrcConnectionRelease.rrcTransactionIdentifier = n;
5700 int criticalExtensionsChoice;
5701 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5702 if (criticalExtensionsChoice == 1)
5705 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5707 else if (criticalExtensionsChoice == 0)
5711 bIterator = DeserializeChoice (4,
false,&c1Choice,bIterator);
5716 std::bitset<3> opts;
5717 bIterator = DeserializeSequence (&opts,
false,bIterator);
5720 bIterator = DeserializeEnum (4,&n,bIterator);
5741 bIterator = DeserializeNull (bIterator);
5756 m_rrcConnectionRelease = msg;
5757 m_isDataSerialized =
false;
5763 return m_rrcConnectionRelease;
5768 RrcConnectionRejectHeader::RrcConnectionRejectHeader ()
5772 RrcConnectionRejectHeader::~RrcConnectionRejectHeader ()
5779 m_serializationResult =
Buffer ();
5782 SerializeDlCcchMessage (2);
5786 SerializeSequence (std::bitset<0> (),
false);
5789 SerializeChoice (2,0,
false);
5792 SerializeChoice (4,0,
false);
5796 SerializeSequence (std::bitset<1> (0),
false);
5799 SerializeInteger (m_rrcConnectionReject.waitTime, 1, 16);
5802 FinalizeSerialization ();
5808 std::bitset<0> bitset0;
5811 bIterator = DeserializeDlCcchMessage (bIterator);
5815 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5818 int criticalExtensionsChoice;
5819 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5820 if (criticalExtensionsChoice == 1)
5823 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5825 else if (criticalExtensionsChoice == 0)
5829 bIterator = DeserializeChoice (4,
false,&c1Choice,bIterator);
5833 bIterator = DeserializeNull (bIterator);
5835 else if (c1Choice == 0)
5838 std::bitset<1> opts;
5839 bIterator = DeserializeSequence (&opts,
false,bIterator);
5841 bIterator = DeserializeInteger (&n,1,16,bIterator);
5842 m_rrcConnectionReject.waitTime = n;
5858 os <<
"wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl;
5864 m_rrcConnectionReject = msg;
5865 m_isDataSerialized =
false;
5871 return m_rrcConnectionReject;
5876 MeasurementReportHeader::MeasurementReportHeader ()
5880 MeasurementReportHeader::~MeasurementReportHeader ()
5887 m_serializationResult =
Buffer ();
5890 SerializeUlDcchMessage (1);
5894 SerializeSequence (std::bitset<0> (),
false);
5898 SerializeChoice (2,0,
false);
5902 SerializeChoice (8,0,
false);
5906 SerializeSequence (std::bitset<1> (0),
false);
5909 SerializeMeasResults (m_measurementReport.measResults);
5912 FinalizeSerialization ();
5918 std::bitset<0> bitset0;
5920 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5922 bIterator = DeserializeUlDcchMessage (bIterator);
5924 int criticalExtensionsChoice;
5925 bIterator = DeserializeChoice (2,
false,&criticalExtensionsChoice,bIterator);
5927 if (criticalExtensionsChoice == 1)
5930 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
5932 else if (criticalExtensionsChoice == 0)
5936 bIterator = DeserializeChoice (8,
false,&c1Choice,bIterator);
5940 bIterator = DeserializeNull (bIterator);
5945 std::bitset<1> isNonCriticalExtensionPresent;
5946 bIterator = DeserializeSequence (&isNonCriticalExtensionPresent,
false,bIterator);
5949 bIterator = DeserializeMeasResults (&m_measurementReport.measResults, bIterator);
5951 if (isNonCriticalExtensionPresent[0])
5966 os <<
"measId = " << (int)m_measurementReport.measResults.measId << std::endl;
5967 os <<
"rsrpResult = " << (
int)m_measurementReport.measResults.rsrpResult << std::endl;
5968 os <<
"rsrqResult = " << (int)m_measurementReport.measResults.rsrqResult << std::endl;
5969 os <<
"haveMeasResultNeighCells = " << (
int)m_measurementReport.measResults.haveMeasResultNeighCells << std::endl;
5971 if (m_measurementReport.measResults.haveMeasResultNeighCells)
5973 std::list<LteRrcSap::MeasResultEutra> measResultListEutra = m_measurementReport.measResults.measResultListEutra;
5974 std::list<LteRrcSap::MeasResultEutra>::iterator it = measResultListEutra.begin ();
5975 for (; it != measResultListEutra.end (); it++)
5977 os <<
" physCellId =" << (int) it->physCellId << std::endl;
5978 os <<
" haveCgiInfo =" << it->haveCgiInfo << std::endl;
5979 if (it->haveCgiInfo)
5981 os <<
" plmnIdentity = " << (int) it->cgiInfo.plmnIdentity << std::endl;
5982 os <<
" cellIdentity = " << (
int) it->cgiInfo.cellIdentity << std::endl;
5983 os <<
" trackingAreaCode = " << (int) it->cgiInfo.trackingAreaCode << std::endl;
5984 os <<
" havePlmnIdentityList = " << !it->cgiInfo.plmnIdentityList.empty () << std::endl;
5985 if (!it->cgiInfo.plmnIdentityList.empty ())
5987 for (std::list<uint32_t>::iterator it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it->cgiInfo.plmnIdentityList.begin (); it2++)
5989 os <<
" plmnId : " << *it2 << std::endl;
5994 os <<
" haveRsrpResult =" << it->haveRsrpResult << std::endl;
5995 if (it->haveRsrpResult)
5997 os <<
" rsrpResult =" << (int) it->rsrpResult << std::endl;
6000 os <<
" haveRsrqResult =" << it->haveRsrqResult << std::endl;
6001 if (it->haveRsrqResult)
6003 os <<
" rsrqResult =" << (int) it->rsrqResult << std::endl;
6013 m_measurementReport = msg;
6014 m_isDataSerialized =
false;
6021 msg = m_measurementReport;
6030 RrcUlDcchMessage::~RrcUlDcchMessage ()
6037 DeserializeUlDcchMessage (bIterator);
6044 std::cout <<
"UL DCCH MSG TYPE: " <<
m_messageType << std::endl;
6056 std::bitset<0> bitset0;
6059 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6060 bIterator = DeserializeChoice (2,
false,&n,bIterator);
6064 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6070 bIterator = DeserializeChoice (16,
false,&
m_messageType,bIterator);
6077 RrcUlDcchMessage::SerializeUlDcchMessage (
int messageType)
const
6079 SerializeSequence (std::bitset<0> (),
false);
6081 SerializeChoice (2,0,
false);
6083 SerializeChoice (16,messageType,
false);
6087 RrcDlDcchMessage::RrcDlDcchMessage () : RrcAsn1Header ()
6091 RrcDlDcchMessage::~RrcDlDcchMessage ()
6098 DeserializeDlDcchMessage (bIterator);
6105 std::cout <<
"DL DCCH MSG TYPE: " <<
m_messageType << std::endl;
6117 std::bitset<0> bitset0;
6120 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6121 bIterator = DeserializeChoice (2,
false,&n,bIterator);
6125 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6131 bIterator = DeserializeChoice (16,
false,&
m_messageType,bIterator);
6138 RrcDlDcchMessage::SerializeDlDcchMessage (
int messageType)
const
6140 SerializeSequence (std::bitset<0> (),
false);
6142 SerializeChoice (2,0,
false);
6144 SerializeChoice (16,messageType,
false);
6148 RrcUlCcchMessage::RrcUlCcchMessage () : RrcAsn1Header ()
6152 RrcUlCcchMessage::~RrcUlCcchMessage ()
6159 DeserializeUlCcchMessage (bIterator);
6166 std::cout <<
"UL CCCH MSG TYPE: " <<
m_messageType << std::endl;
6178 std::bitset<0> bitset0;
6181 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6182 bIterator = DeserializeChoice (2,
false,&n,bIterator);
6186 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6192 bIterator = DeserializeChoice (2,
false,&
m_messageType,bIterator);
6199 RrcUlCcchMessage::SerializeUlCcchMessage (
int messageType)
const
6201 SerializeSequence (std::bitset<0> (),
false);
6203 SerializeChoice (2,0,
false);
6205 SerializeChoice (2,messageType,
false);
6209 RrcDlCcchMessage::RrcDlCcchMessage () : RrcAsn1Header ()
6213 RrcDlCcchMessage::~RrcDlCcchMessage ()
6220 DeserializeDlCcchMessage (bIterator);
6227 std::cout <<
"DL CCCH MSG TYPE: " <<
m_messageType << std::endl;
6239 std::bitset<0> bitset0;
6242 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6243 bIterator = DeserializeChoice (2,
false,&n,bIterator);
6247 bIterator = DeserializeSequence (&bitset0,
false,bIterator);
6253 bIterator = DeserializeChoice (4,
false,&
m_messageType,bIterator);
6260 RrcDlCcchMessage::SerializeDlCcchMessage (
int messageType)
const
6262 SerializeSequence (std::bitset<0> (),
false);
6264 SerializeChoice (2,0,
false);
6266 SerializeChoice (4,messageType,
false);
uint32_t Deserialize(Buffer::Iterator bIterator)
automatically resized byte buffer
uint32_t Deserialize(Buffer::Iterator bIterator)
#define NS_LOG_COMPONENT_DEFINE(name)
uint32_t Deserialize(Buffer::Iterator bIterator)
LteRrcSap::HandoverPreparationInfo GetMessage() const
iterator in a Buffer instance
void Print(std::ostream &os) const
void Print(std::ostream &os) const
void PreSerialize() const
void PreSerialize() const
uint32_t Deserialize(Buffer::Iterator bIterator)
void Print(std::ostream &os) const
void PreSerialize() const
void PreSerialize() const
void SetMessage(LteRrcSap::HandoverPreparationInfo msg)
LteRrcSap::AsConfig GetAsConfig() const
uint32_t Deserialize(Buffer::Iterator bIterator)
void Print(std::ostream &os) const
void PreSerialize() const
void Print(std::ostream &os) const