--- a/src/lte/model/lte-rrc-header.cc Wed Feb 20 16:35:51 2013 +0100
+++ b/src/lte/model/lte-rrc-header.cc Wed Feb 20 16:51:26 2013 +0100
@@ -857,6 +857,932 @@
SerializeInteger (1,1,8); // maxHARQ-Msg3Tx
}
+void
+RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const
+{
+ switch (qOffsetRange)
+ {
+ case -24:
+ SerializeEnum (31,0);
+ break;
+ case -22:
+ SerializeEnum (31,1);
+ break;
+ case -20:
+ SerializeEnum (31,2);
+ break;
+ case -18:
+ SerializeEnum (31,3);
+ break;
+ case -16:
+ SerializeEnum (31,4);
+ break;
+ case -14:
+ SerializeEnum (31,5);
+ break;
+ case -12:
+ SerializeEnum (31,6);
+ break;
+ case -10:
+ SerializeEnum (31,7);
+ break;
+ case -8:
+ SerializeEnum (31,8);
+ break;
+ case -6:
+ SerializeEnum (31,9);
+ break;
+ case -5:
+ SerializeEnum (31,10);
+ break;
+ case -4:
+ SerializeEnum (31,11);
+ break;
+ case -3:
+ SerializeEnum (31,12);
+ break;
+ case -2:
+ SerializeEnum (31,13);
+ break;
+ case -1:
+ SerializeEnum (31,14);
+ break;
+ case 0:
+ SerializeEnum (31,15);
+ break;
+ case 1:
+ SerializeEnum (31,16);
+ break;
+ case 2:
+ SerializeEnum (31,17);
+ break;
+ case 3:
+ SerializeEnum (31,18);
+ break;
+ case 4:
+ SerializeEnum (31,19);
+ break;
+ case 5:
+ SerializeEnum (31,20);
+ break;
+ case 6:
+ SerializeEnum (31,21);
+ break;
+ case 8:
+ SerializeEnum (31,22);
+ break;
+ case 10:
+ SerializeEnum (31,23);
+ break;
+ case 12:
+ SerializeEnum (31,24);
+ break;
+ case 14:
+ SerializeEnum (31,25);
+ break;
+ case 16:
+ SerializeEnum (31,26);
+ break;
+ case 18:
+ SerializeEnum (31,27);
+ break;
+ case 20:
+ SerializeEnum (31,28);
+ break;
+ case 22:
+ SerializeEnum (31,29);
+ break;
+ case 24:
+ SerializeEnum (31,30);
+ break;
+ default:
+ SerializeEnum (31,15);
+ }
+}
+
+void
+RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra) const
+{
+ switch (thresholdEutra.choice)
+ {
+ case LteRrcSap::ThresholdEutra::thresholdRsrp:
+ SerializeChoice (2,0,false);
+ SerializeInteger (thresholdEutra.range, 0, 97);
+ break;
+ case LteRrcSap::ThresholdEutra::thresholdRsrq:
+ default:
+ SerializeChoice (2,1,false);
+ SerializeInteger (thresholdEutra.range, 0, 34);
+ }
+}
+
+void
+RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const
+{
+ // Serialize MeasConfig sequence
+ // 11 optional fields, extension marker present
+ std::bitset<11> measConfigOptional;
+ measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () );
+ measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () );
+ measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () );
+ measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () );
+ measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () );
+ measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () );
+ measConfigOptional.set (4, measConfig.haveQuantityConfig );
+ measConfigOptional.set (3, measConfig.haveMeasGapConfig );
+ measConfigOptional.set (2, measConfig.haveSmeasure );
+ measConfigOptional.set (1, false ); // preRegistrationInfoHRPD
+ measConfigOptional.set (0, measConfig.haveSpeedStatePars );
+ SerializeSequence (measConfigOptional,true);
+
+ if (!measConfig.measObjectToRemoveList.empty ())
+ {
+ SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_ID,1);
+ for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList.begin (); it != measConfig.measObjectToRemoveList.end (); it++)
+ {
+ SerializeInteger (*it, 1, MAX_OBJECT_ID);
+ }
+ }
+
+ if (!measConfig.measObjectToAddModList.empty ())
+ {
+ SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_ID,1);
+ for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = measConfig.measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); it++)
+ {
+ SerializeSequence (std::bitset<0> (), false);
+ SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
+ SerializeChoice (4, 0, true); // Select MeasObjectEUTRA
+
+ // Serialize measObjectEutra
+ std::bitset<5> measObjOpts;
+ measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () );
+ measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () );
+ measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty () );
+ measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty () );
+ measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI);
+ SerializeSequence (measObjOpts, true);
+
+ // Serialize carrierFreq
+ SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN);
+
+ // Serialize allowedMeasBandwidth
+ switch (it->measObjectEutra.allowedMeasBandwidth)
+ {
+ case 6:
+ SerializeEnum (6,0);
+ break;
+ case 15:
+ SerializeEnum (6,1);
+ break;
+ case 25:
+ SerializeEnum (6,2);
+ break;
+ case 50:
+ SerializeEnum (6,3);
+ break;
+ case 75:
+ SerializeEnum (6,4);
+ break;
+ case 100:
+ SerializeEnum (6,5);
+ break;
+ default:
+ SerializeEnum (6,0);
+ }
+
+ SerializeBoolean (it->measObjectEutra.presenceAntennaPort1);
+ SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfig));
+ SerializeQoffsetRange (it->measObjectEutra.offsetFreq);
+
+ if (!it->measObjectEutra.cellsToRemoveList.empty ())
+ {
+ SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size (),MAX_CELL_MEAS,1);
+ for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++)
+ {
+ SerializeInteger (*it2, 1, MAX_CELL_MEAS);
+ }
+ }
+
+ if (!it->measObjectEutra.cellsToAddModList.empty ())
+ {
+ SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size (), MAX_CELL_MEAS, 1);
+ for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 = it->measObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModList.end (); it2++)
+ {
+ SerializeSequence (std::bitset<0> (), false);
+
+ // Serialize cellIndex
+ SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
+
+ // Serialize PhysCellId
+ SerializeInteger (it2->physCellId,0,503);
+
+ // Serialize cellIndividualOffset
+ SerializeQoffsetRange (it2->cellIndividualOffset);
+ }
+ }
+
+ if (!it->measObjectEutra.blackCellsToRemoveList.empty () )
+ {
+ SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.size (),MAX_CELL_MEAS,1);
+ for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.blackCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end (); it2++)
+ {
+ SerializeInteger (*it2, 1, MAX_CELL_MEAS);
+ }
+ }
+
+ if (!it->measObjectEutra.blackCellsToAddModList.empty () )
+ {
+ SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.size (), MAX_CELL_MEAS, 1);
+ for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = it->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blackCellsToAddModList.end (); it2++)
+ {
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS);
+
+ // Serialize PhysCellIdRange
+ // range optional
+ std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdRange.haveRange);
+ SerializeSequence (rangePresent,false);
+ SerializeInteger (it2->physCellIdRange.start,0,503);
+ if (it2->physCellIdRange.haveRange)
+ {
+ switch (it2->physCellIdRange.range)
+ {
+ case 4:
+ SerializeEnum (16, 0);
+ break;
+ case 8:
+ SerializeEnum (16, 1);
+ break;
+ case 12:
+ SerializeEnum (16, 2);
+ break;
+ case 16:
+ SerializeEnum (16, 3);
+ break;
+ case 24:
+ SerializeEnum (16, 4);
+ break;
+ case 32:
+ SerializeEnum (16, 5);
+ break;
+ case 48:
+ SerializeEnum (16, 6);
+ break;
+ case 64:
+ SerializeEnum (16, 7);
+ break;
+ case 84:
+ SerializeEnum (16, 8);
+ break;
+ case 96:
+ SerializeEnum (16, 9);
+ break;
+ case 128:
+ SerializeEnum (16, 10);
+ break;
+ case 168:
+ SerializeEnum (16, 11);
+ break;
+ case 252:
+ SerializeEnum (16, 12);
+ break;
+ case 504:
+ SerializeEnum (16, 13);
+ break;
+ default:
+ SerializeEnum (16, 0);
+ }
+ }
+ }
+
+ }
+
+ if (it->measObjectEutra.haveCellForWhichToReportCGI)
+ {
+ SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,503);
+ }
+ }
+ }
+
+
+ if (!measConfig.reportConfigToRemoveList.empty () )
+ {
+ SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPORT_CONFIG_ID,1);
+ for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveList.begin (); it != measConfig.reportConfigToRemoveList.end (); it++)
+ {
+ SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID);
+ }
+ }
+
+ if (!measConfig.reportConfigToAddModList.empty () )
+ {
+ SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPORT_CONFIG_ID,1);
+ for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = measConfig.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end (); it++)
+ {
+ SerializeSequence (std::bitset<0> (), false);
+ SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID);
+ SerializeChoice (2,0,false); // reportConfigEUTRA
+
+ // Serialize ReportConfigEUTRA
+ SerializeSequence (std::bitset<0> (), true);
+ switch (it->reportConfigEutra.triggerType)
+ {
+ case LteRrcSap::ReportConfigEutra::periodical:
+ SerializeChoice (2, 1, false);
+ SerializeSequence (std::bitset<0> (),false);
+ switch (it->reportConfigEutra.purpose)
+ {
+ case LteRrcSap::ReportConfigEutra::reportCgi:
+ SerializeEnum (2,1);
+ break;
+ case LteRrcSap::ReportConfigEutra::reportStrongestCells:
+ default:
+ SerializeEnum (2,0);
+ }
+ break;
+ case LteRrcSap::ReportConfigEutra::event:
+ default:
+ SerializeChoice (2, 0, false);
+ SerializeSequence (std::bitset<0> (),false);
+ switch (it->reportConfigEutra.eventId)
+ {
+ case LteRrcSap::ReportConfigEutra::eventA1:
+ SerializeChoice (5, 0, true);
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeThresholdEutra (it->reportConfigEutra.threshold1);
+ break;
+ case LteRrcSap::ReportConfigEutra::eventA2:
+ SerializeChoice (5, 1, true);
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeThresholdEutra (it->reportConfigEutra.threshold1);
+ break;
+ case LteRrcSap::ReportConfigEutra::eventA3:
+ SerializeChoice (5, 2, true);
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeInteger (it->reportConfigEutra.a3Offset,-30,30);
+ SerializeBoolean (it->reportConfigEutra.reportOnLeave);
+ break;
+ case LteRrcSap::ReportConfigEutra::eventA4:
+ SerializeChoice (5, 3, true);
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeThresholdEutra (it->reportConfigEutra.threshold1);
+ break;
+ case LteRrcSap::ReportConfigEutra::eventA5:
+ default:
+ SerializeChoice (5, 4, true);
+ SerializeSequence (std::bitset<0> (),false);
+ SerializeThresholdEutra (it->reportConfigEutra.threshold1);
+ SerializeThresholdEutra (it->reportConfigEutra.threshold2);
+ }
+
+ SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30);
+
+ switch (it->reportConfigEutra.timeToTrigger)
+ {
+ case 0:
+ SerializeEnum (16, 0);
+ break;
+ case 40:
+ SerializeEnum (16, 1);
+ break;
+ case 64:
+ SerializeEnum (16, 2);
+ break;
+ case 80:
+ SerializeEnum (16, 3);
+ break;
+ case 100:
+ SerializeEnum (16, 4);
+ break;
+ case 128:
+ SerializeEnum (16, 5);
+ break;
+ case 160:
+ SerializeEnum (16, 6);
+ break;
+ case 256:
+ SerializeEnum (16, 7);
+ break;
+ case 320:
+ SerializeEnum (16, 8);
+ break;
+ case 480:
+ SerializeEnum (16, 9);
+ break;
+ case 512:
+ SerializeEnum (16, 10);
+ break;
+ case 640:
+ SerializeEnum (16, 11);
+ break;
+ case 1024:
+ SerializeEnum (16, 12);
+ break;
+ case 1280:
+ SerializeEnum (16, 13);
+ break;
+ case 2560:
+ SerializeEnum (16, 14);
+ break;
+ case 5120:
+ default:
+ SerializeEnum (16, 15);
+ }
+ } // end trigger type
+
+ // Serialize triggerQuantity
+ if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEutra::rsrp)
+ {
+ SerializeEnum (2, 0);
+ }
+ else
+ {
+ SerializeEnum (2, 1);
+ }
+
+ // Serialize reportQuantity
+ if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity)
+ {
+ SerializeEnum (2, 0);
+ }
+ else
+ {
+ SerializeEnum (2, 1);
+ }
+
+ // Serialize maxReportCells
+ SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_REPORT);
+
+ // Serialize reportInterval
+ switch (it->reportConfigEutra.reportInterval)
+ {
+ case LteRrcSap::ReportConfigEutra::ms120:
+ SerializeEnum (16, 0);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms240:
+ SerializeEnum (16, 1);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms480:
+ SerializeEnum (16, 2);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms640:
+ SerializeEnum (16, 3);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms1024:
+ SerializeEnum (16, 4);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms2048:
+ SerializeEnum (16, 5);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms5120:
+ SerializeEnum (16, 6);
+ break;
+ case LteRrcSap::ReportConfigEutra::ms10240:
+ SerializeEnum (16, 7);
+ break;
+ case LteRrcSap::ReportConfigEutra::min1:
+ SerializeEnum (16, 8);
+ break;
+ case LteRrcSap::ReportConfigEutra::min6:
+ SerializeEnum (16, 9);
+ break;
+ case LteRrcSap::ReportConfigEutra::min12:
+ SerializeEnum (16, 10);
+ break;
+ case LteRrcSap::ReportConfigEutra::min30:
+ SerializeEnum (16, 11);
+ break;
+ case LteRrcSap::ReportConfigEutra::min60:
+ SerializeEnum (16, 12);
+ break;
+ case LteRrcSap::ReportConfigEutra::spare3:
+ SerializeEnum (16, 13);
+ break;
+ case LteRrcSap::ReportConfigEutra::spare2:
+ SerializeEnum (16, 14);
+ break;
+ case LteRrcSap::ReportConfigEutra::spare1:
+ default:
+ SerializeEnum (16, 15);
+ }
+
+ // Serialize reportAmount
+ switch (it->reportConfigEutra.reportAmount)
+ {
+ case 1:
+ SerializeEnum (8, 0);
+ break;
+ case 2:
+ SerializeEnum (8, 1);
+ break;
+ case 4:
+ SerializeEnum (8, 2);
+ break;
+ case 8:
+ SerializeEnum (8, 3);
+ break;
+ case 16:
+ SerializeEnum (8, 4);
+ break;
+ case 32:
+ SerializeEnum (8, 5);
+ break;
+ case 64:
+ SerializeEnum (8, 6);
+ break;
+ default:
+ SerializeEnum (8, 7);
+ }
+ }
+ }
+
+ if (!measConfig.measIdToRemoveList.empty () )
+ {
+ SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1);
+ for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.begin (); it != measConfig.measIdToRemoveList.end (); it++)
+ {
+ SerializeInteger (*it, 1, MAX_MEAS_ID);
+ }
+ }
+
+ if (!measConfig.measIdToAddModList.empty () )
+ {
+ SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID, 1);
+ for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it = measConfig.measIdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++)
+ {
+ SerializeInteger (it->measId, 1, MAX_MEAS_ID);
+ SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID);
+ SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID);
+ }
+ }
+
+ if (measConfig.haveQuantityConfig )
+ {
+ // QuantityConfig sequence
+ // 4 optional fields, only first (EUTRA) present. Extension marker yes.
+ std::bitset<4> quantityConfigOpts (0);
+ quantityConfigOpts.set (3,1);
+ SerializeSequence (quantityConfigOpts, true);
+ SerializeSequence (std::bitset<0> (), false);
+
+ switch (measConfig.quantityConfig.filterCoefficientRSRP)
+ {
+ case 0:
+ SerializeEnum (16, 0);
+ break;
+ case 1:
+ SerializeEnum (16, 1);
+ break;
+ case 2:
+ SerializeEnum (16, 2);
+ break;
+ case 3:
+ SerializeEnum (16, 3);
+ break;
+ case 4:
+ SerializeEnum (16, 4);
+ break;
+ case 5:
+ SerializeEnum (16, 5);
+ break;
+ case 6:
+ SerializeEnum (16, 6);
+ break;
+ case 7:
+ SerializeEnum (16, 7);
+ break;
+ case 8:
+ SerializeEnum (16, 8);
+ break;
+ case 9:
+ SerializeEnum (16, 9);
+ break;
+ case 11:
+ SerializeEnum (16, 10);
+ break;
+ case 13:
+ SerializeEnum (16, 11);
+ break;
+ case 15:
+ SerializeEnum (16, 12);
+ break;
+ case 17:
+ SerializeEnum (16, 13);
+ break;
+ case 19:
+ SerializeEnum (16, 14);
+ break;
+ default:
+ SerializeEnum (16, 4);
+ }
+
+ switch (measConfig.quantityConfig.filterCoefficientRSRQ)
+ {
+ case 0:
+ SerializeEnum (16, 0);
+ break;
+ case 1:
+ SerializeEnum (16, 1);
+ break;
+ case 2:
+ SerializeEnum (16, 2);
+ break;
+ case 3:
+ SerializeEnum (16, 3);
+ break;
+ case 4:
+ SerializeEnum (16, 4);
+ break;
+ case 5:
+ SerializeEnum (16, 5);
+ break;
+ case 6:
+ SerializeEnum (16, 6);
+ break;
+ case 7:
+ SerializeEnum (16, 7);
+ break;
+ case 8:
+ SerializeEnum (16, 8);
+ break;
+ case 9:
+ SerializeEnum (16, 9);
+ break;
+ case 11:
+ SerializeEnum (16, 10);
+ break;
+ case 13:
+ SerializeEnum (16, 11);
+ break;
+ case 15:
+ SerializeEnum (16, 12);
+ break;
+ case 17:
+ SerializeEnum (16, 13);
+ break;
+ case 19:
+ SerializeEnum (16, 14);
+ break;
+ default:
+ SerializeEnum (16, 4);
+ }
+ }
+
+ if (measConfig.haveMeasGapConfig )
+ {
+ switch (measConfig.measGapConfig.type)
+ {
+ case LteRrcSap::MeasGapConfig::RESET:
+ SerializeChoice (2, 0, false);
+ SerializeNull ();
+ break;
+ case LteRrcSap::MeasGapConfig::SETUP:
+ default:
+ SerializeChoice (2, 1, false);
+ SerializeSequence (std::bitset<0> (),false);
+ switch (measConfig.measGapConfig.gapOffsetChoice)
+ {
+ case LteRrcSap::MeasGapConfig::gp0:
+ SerializeChoice (2, 0, true);
+ SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39);
+ break;
+ case LteRrcSap::MeasGapConfig::gp1:
+ default:
+ SerializeChoice (2, 1, true);
+ SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79);
+ }
+ }
+ }
+
+ if (measConfig.haveSmeasure )
+ {
+ SerializeInteger (measConfig.sMeasure, 0, 97);
+ }
+
+ // ...Here preRegistrationInfoHRPD would be serialized
+
+ if (measConfig.haveSpeedStatePars )
+ {
+ switch (measConfig.speedStatePars.type)
+ {
+ case LteRrcSap::SpeedStatePars::RESET:
+ SerializeChoice (2, 0, false);
+ SerializeNull ();
+ break;
+ case LteRrcSap::SpeedStatePars::SETUP:
+ default:
+ SerializeChoice (2, 1, false);
+ SerializeSequence (std::bitset<0> (), false);
+ switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation)
+ {
+ case 30:
+ SerializeEnum (8, 0);
+ break;
+ case 60:
+ SerializeEnum (8, 1);
+ break;
+ case 120:
+ SerializeEnum (8, 2);
+ break;
+ case 180:
+ SerializeEnum (8, 3);
+ break;
+ case 240:
+ SerializeEnum (8, 4);
+ break;
+ default:
+ SerializeEnum (8, 5);
+ break;
+ }
+
+ switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal)
+ {
+ case 30:
+ SerializeEnum (8, 0);
+ break;
+ case 60:
+ SerializeEnum (8, 1);
+ break;
+ case 120:
+ SerializeEnum (8, 2);
+ break;
+ case 180:
+ SerializeEnum (8, 3);
+ break;
+ case 240:
+ SerializeEnum (8, 4);
+ break;
+ default:
+ SerializeEnum (8, 5);
+ break;
+ }
+
+ SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium, 1, 16);
+ SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh, 1, 16);
+
+ SerializeSequence (std::bitset<0> (), false);
+ switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium)
+ {
+ case 25:
+ SerializeEnum (4, 0);
+ break;
+ case 50:
+ SerializeEnum (4, 1);
+ break;
+ case 75:
+ SerializeEnum (4, 2);
+ break;
+ case 100:
+ default:
+ SerializeEnum (4, 3);
+ }
+
+ switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh)
+ {
+ case 25:
+ SerializeEnum (4, 0);
+ break;
+ case 50:
+ SerializeEnum (4, 1);
+ break;
+ case 75:
+ SerializeEnum (4, 2);
+ break;
+ case 100:
+ default:
+ SerializeEnum (4, 3);
+ }
+ }
+ }
+}
+
+Buffer::Iterator
+RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdEutra, Buffer::Iterator bIterator)
+{
+ int thresholdEutraChoice, range;
+ bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator);
+
+ switch (thresholdEutraChoice)
+ {
+ case 0:
+ thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrp;
+ bIterator = DeserializeInteger (&range, 0, 97, bIterator);
+ thresholdEutra->range = range;
+ break;
+ case 1:
+ default:
+ thresholdEutra->choice = LteRrcSap::ThresholdEutra::thresholdRsrq;
+ bIterator = DeserializeInteger (&range, 0, 34, bIterator);
+ thresholdEutra->range = range;
+ }
+
+ return bIterator;
+}
+
+Buffer::Iterator
+RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator bIterator)
+{
+ int n;
+ bIterator = DeserializeEnum (31, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ *qOffsetRange = -24;
+ break;
+ case 1:
+ *qOffsetRange = -22;
+ break;
+ case 2:
+ *qOffsetRange = -20;
+ break;
+ case 3:
+ *qOffsetRange = -18;
+ break;
+ case 4:
+ *qOffsetRange = -16;
+ break;
+ case 5:
+ *qOffsetRange = -14;
+ break;
+ case 6:
+ *qOffsetRange = -12;
+ break;
+ case 7:
+ *qOffsetRange = -10;
+ break;
+ case 8:
+ *qOffsetRange = -8;
+ break;
+ case 9:
+ *qOffsetRange = -6;
+ break;
+ case 10:
+ *qOffsetRange = -5;
+ break;
+ case 11:
+ *qOffsetRange = -4;
+ break;
+ case 12:
+ *qOffsetRange = -3;
+ break;
+ case 13:
+ *qOffsetRange = -2;
+ break;
+ case 14:
+ *qOffsetRange = -1;
+ break;
+ case 15:
+ *qOffsetRange = 0;
+ break;
+ case 16:
+ *qOffsetRange = 1;
+ break;
+ case 17:
+ *qOffsetRange = 2;
+ break;
+ case 18:
+ *qOffsetRange = 3;
+ break;
+ case 19:
+ *qOffsetRange = 4;
+ break;
+ case 20:
+ *qOffsetRange = 5;
+ break;
+ case 21:
+ *qOffsetRange = 6;
+ break;
+ case 22:
+ *qOffsetRange = 8;
+ break;
+ case 23:
+ *qOffsetRange = 10;
+ break;
+ case 24:
+ *qOffsetRange = 12;
+ break;
+ case 25:
+ *qOffsetRange = 14;
+ break;
+ case 26:
+ *qOffsetRange = 16;
+ break;
+ case 27:
+ *qOffsetRange = 18;
+ break;
+ case 28:
+ *qOffsetRange = 20;
+ break;
+ case 29:
+ *qOffsetRange = 22;
+ break;
+ case 30:
+ default:
+ *qOffsetRange = 24;
+ }
+ return bIterator;
+}
+
Buffer::Iterator
RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator)
{
@@ -1153,11 +2079,11 @@
logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs;
if (bitset1[0])
- {
- // Deserialize logicalChannelGroup
- bIterator = DeserializeInteger (&n,0,3,bIterator);
- logicalChannelConfig->logicalChannelGroup = n;
- }
+ {
+ // Deserialize logicalChannelGroup
+ bIterator = DeserializeInteger (&n,0,3,bIterator);
+ logicalChannelConfig->logicalChannelGroup = n;
+ }
}
return bIterator;
}
@@ -2092,6 +3018,839 @@
return bIterator;
}
+Buffer::Iterator
+RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer::Iterator bIterator)
+{
+ std::bitset<0> bitset0;
+ std::bitset<2> bitset2;
+ std::bitset<11> bitset11;
+ int n;
+
+ // measConfig
+ bIterator = DeserializeSequence (&bitset11,true,bIterator);
+
+ if (bitset11[10])
+ {
+ // measObjectToRemoveList
+ int measObjectToRemoveListElems;
+ bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJECT_ID, 1, bIterator);
+
+ for (int i = 0; i < measObjectToRemoveListElems; i++)
+ {
+ bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
+ measConfig->measObjectToRemoveList.push_back (n);
+ }
+ }
+
+ if (bitset11[9])
+ {
+ // measObjectToAddModList
+ int measObjectToAddModListElems;
+ bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJECT_ID, 1, bIterator);
+
+ for (int i = 0; i < measObjectToAddModListElems; i++)
+ {
+ LteRrcSap::MeasObjectToAddMod elem;
+
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
+ elem.measObjectId = n;
+
+ int measObjectChoice;
+ bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator);
+
+ switch (measObjectChoice)
+ {
+ case 1:
+ // Deserialize measObjectUTRA
+ // ...
+ break;
+
+ case 2:
+ // Deserialize measObjectGERAN
+ // ...
+ break;
+
+ case 3:
+ // Deserialize measObjectCDMA2000
+ // ...
+ break;
+
+ case 0:
+ default:
+ // Deserialize measObjectEUTRA
+ std::bitset<5> measObjectEutraOpts;
+ bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIterator);
+
+ // carrierFreq
+ bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator);
+ elem.measObjectEutra.carrierFreq = n;
+
+ // allowedMeasBandwidth
+ bIterator = DeserializeEnum (6, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ elem.measObjectEutra.allowedMeasBandwidth = 6;
+ break;
+ case 1:
+ elem.measObjectEutra.allowedMeasBandwidth = 15;
+ break;
+ case 2:
+ elem.measObjectEutra.allowedMeasBandwidth = 25;
+ break;
+ case 3:
+ elem.measObjectEutra.allowedMeasBandwidth = 50;
+ break;
+ case 4:
+ elem.measObjectEutra.allowedMeasBandwidth = 75;
+ break;
+ case 5:
+ default:
+ elem.measObjectEutra.allowedMeasBandwidth = 100;
+ break;
+ }
+
+ // presenceAntennaPort1
+ bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAntennaPort1, bIterator);
+
+ // neighCellConfig
+ bIterator = DeserializeBitstring (&bitset2, bIterator);
+ elem.measObjectEutra.neighCellConfig = bitset2.to_ulong ();
+
+ // offsetFreq
+ bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetFreq, bIterator);
+
+ if (measObjectEutraOpts[4])
+ {
+ // cellsToRemoveList
+ int numElems;
+ bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
+
+ for (int i = 0; i < numElems; i++)
+ {
+ bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
+ elem.measObjectEutra.cellsToRemoveList.push_back (n);
+ }
+ }
+
+ if (measObjectEutraOpts[3])
+ {
+ // cellsToAddModList
+ int numElems;
+ bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
+
+ for (int i = 0; i < numElems; i++)
+ {
+ LteRrcSap::CellsToAddMod cellsToAddMod;
+
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ // cellIndex
+ bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
+ cellsToAddMod.cellIndex = n;
+
+ // PhysCellId
+ bIterator = DeserializeInteger (&n, 0, 503, bIterator);
+ cellsToAddMod.physCellId = n;
+
+ // cellIndividualOffset
+ bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellIndividualOffset, bIterator);
+
+ elem.measObjectEutra.cellsToAddModList.push_back (cellsToAddMod);
+ }
+ }
+
+ if (measObjectEutraOpts[2])
+ {
+ // blackCellsToRemoveList
+ int numElems;
+ bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
+
+ for (int i = 0; i < numElems; i++)
+ {
+ bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
+ elem.measObjectEutra.blackCellsToRemoveList.push_back (n);
+ }
+ }
+
+
+ if (measObjectEutraOpts[1])
+ {
+ // blackCellsToAddModList
+ int numElems;
+ bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1, bIterator);
+
+ for (int i = 0; i < numElems; i++)
+ {
+ LteRrcSap::BlackCellsToAddMod blackCellsToAddMod;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIterator);
+ blackCellsToAddMod.cellIndex = n;
+
+ // PhysCellIdRange
+ std::bitset<1> isRangePresent;
+ bIterator = DeserializeSequence (&isRangePresent, false, bIterator);
+
+ // start
+ bIterator = DeserializeInteger (&n, 0, 503, bIterator);
+ blackCellsToAddMod.physCellIdRange.start = n;
+
+ blackCellsToAddMod.physCellIdRange.haveRange = isRangePresent[0];
+ if (blackCellsToAddMod.physCellIdRange.haveRange)
+ {
+ // range
+ bIterator = DeserializeEnum (16, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ blackCellsToAddMod.physCellIdRange.range = 4;
+ break;
+ case 1:
+ blackCellsToAddMod.physCellIdRange.range = 8;
+ break;
+ case 2:
+ blackCellsToAddMod.physCellIdRange.range = 12;
+ break;
+ case 3:
+ blackCellsToAddMod.physCellIdRange.range = 16;
+ break;
+ case 4:
+ blackCellsToAddMod.physCellIdRange.range = 24;
+ break;
+ case 5:
+ blackCellsToAddMod.physCellIdRange.range = 32;
+ break;
+ case 6:
+ blackCellsToAddMod.physCellIdRange.range = 48;
+ break;
+ case 7:
+ blackCellsToAddMod.physCellIdRange.range = 64;
+ break;
+ case 8:
+ blackCellsToAddMod.physCellIdRange.range = 84;
+ break;
+ case 9:
+ blackCellsToAddMod.physCellIdRange.range = 96;
+ break;
+ case 10:
+ blackCellsToAddMod.physCellIdRange.range = 128;
+ break;
+ case 11:
+ blackCellsToAddMod.physCellIdRange.range = 168;
+ break;
+ case 12:
+ blackCellsToAddMod.physCellIdRange.range = 252;
+ break;
+ case 13:
+ blackCellsToAddMod.physCellIdRange.range = 504;
+ break;
+ default:
+ blackCellsToAddMod.physCellIdRange.range = 0;
+ }
+ }
+
+ elem.measObjectEutra.blackCellsToAddModList.push_back (blackCellsToAddMod);
+ }
+ }
+
+ elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutraOpts[0];
+ if (measObjectEutraOpts[0])
+ {
+ // cellForWhichToReportCGI
+ bIterator = DeserializeInteger (&n, 0, 503, bIterator);
+ elem.measObjectEutra.cellForWhichToReportCGI = n;
+ }
+ }
+ measConfig->measObjectToAddModList.push_back (elem);
+ }
+ }
+
+ if (bitset11[8])
+ {
+ // reportConfigToRemoveList
+ int reportConfigToRemoveListElems;
+ bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
+
+ for (int i = 0; i < reportConfigToRemoveListElems; i++)
+ {
+ bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
+ measConfig->reportConfigToRemoveList.push_back (n);
+ }
+ }
+
+ if (bitset11[7])
+ {
+ // reportConfigToAddModList
+ int reportConfigToAddModListElems;
+ bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REPORT_CONFIG_ID, 1, bIterator);
+
+ for (int i = 0; i < reportConfigToAddModListElems; i++)
+ {
+ LteRrcSap::ReportConfigToAddMod elem;
+
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
+ elem.reportConfigId = n;
+
+ // Deserialize reportConfig
+ int reportConfigChoice;
+ bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterator);
+
+ if (reportConfigChoice == 0)
+ {
+ // reportConfigEUTRA
+ bIterator = DeserializeSequence (&bitset0, true, bIterator);
+
+ // triggerType
+ int triggerTypeChoice;
+ bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIterator);
+
+ if (triggerTypeChoice == 0)
+ {
+ // event
+ elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::event;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ // eventId
+ int eventIdChoice;
+ bIterator = DeserializeChoice (5, true, &eventIdChoice, bIterator);
+
+ switch (eventIdChoice)
+ {
+ case 0:
+ elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA1;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
+ break;
+
+ case 1:
+ elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA2;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
+ break;
+
+ case 2:
+ elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA3;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeInteger (&n, -30, 30, bIterator);
+ elem.reportConfigEutra.a3Offset = n;
+ bIterator = DeserializeBoolean (&elem.reportConfigEutra.reportOnLeave, bIterator);
+ break;
+
+ case 3:
+ elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA4;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
+ break;
+
+ case 4:
+ default:
+ elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEutra::eventA5;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold1, bIterator);
+ bIterator = DeserializeThresholdEutra (&elem.reportConfigEutra.threshold2, bIterator);
+ }
+
+ bIterator = DeserializeInteger (&n, 0, 30, bIterator);
+ elem.reportConfigEutra.hysteresis = n;
+
+ bIterator = DeserializeEnum (16, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ elem.reportConfigEutra.timeToTrigger = 0;
+ break;
+ case 1:
+ elem.reportConfigEutra.timeToTrigger = 40;
+ break;
+ case 2:
+ elem.reportConfigEutra.timeToTrigger = 64;
+ break;
+ case 3:
+ elem.reportConfigEutra.timeToTrigger = 80;
+ break;
+ case 4:
+ elem.reportConfigEutra.timeToTrigger = 100;
+ break;
+ case 5:
+ elem.reportConfigEutra.timeToTrigger = 128;
+ break;
+ case 6:
+ elem.reportConfigEutra.timeToTrigger = 160;
+ break;
+ case 7:
+ elem.reportConfigEutra.timeToTrigger = 256;
+ break;
+ case 8:
+ elem.reportConfigEutra.timeToTrigger = 320;
+ break;
+ case 9:
+ elem.reportConfigEutra.timeToTrigger = 480;
+ break;
+ case 10:
+ elem.reportConfigEutra.timeToTrigger = 512;
+ break;
+ case 11:
+ elem.reportConfigEutra.timeToTrigger = 640;
+ break;
+ case 12:
+ elem.reportConfigEutra.timeToTrigger = 1024;
+ break;
+ case 13:
+ elem.reportConfigEutra.timeToTrigger = 1280;
+ break;
+ case 14:
+ elem.reportConfigEutra.timeToTrigger = 2560;
+ break;
+ case 15:
+ default:
+ elem.reportConfigEutra.timeToTrigger = 5120;
+ break;
+ }
+ }
+
+ if (triggerTypeChoice == 1)
+ {
+ // periodical
+ elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEutra::periodical;
+
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+ bIterator = DeserializeEnum (2, &n, bIterator);
+ if (n == 0)
+ {
+ elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportStrongestCells;
+ }
+ else
+ {
+ elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEutra::reportCgi;
+ }
+ }
+
+ // triggerQuantity
+ bIterator = DeserializeEnum (2, &n, bIterator);
+ if (n == 0)
+ {
+ elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrp;
+ }
+ else
+ {
+ elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConfigEutra::rsrq;
+ }
+
+ // reportQuantity
+ bIterator = DeserializeEnum (2, &n, bIterator);
+ if (n == 0)
+ {
+ elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::sameAsTriggerQuantity;
+ }
+ else
+ {
+ elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfigEutra::both;
+ }
+
+ // maxReportCells
+ bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator);
+ elem.reportConfigEutra.maxReportCells = n;
+
+ // reportInterval
+ bIterator = DeserializeEnum (16, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms120;
+ break;
+ case 1:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms240;
+ break;
+ case 2:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms480;
+ break;
+ case 3:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms640;
+ break;
+ case 4:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms1024;
+ break;
+ case 5:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms2048;
+ break;
+ case 6:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms5120;
+ break;
+ case 7:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::ms10240;
+ break;
+ case 8:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min1;
+ break;
+ case 9:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min6;
+ break;
+ case 10:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min12;
+ break;
+ case 11:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min30;
+ break;
+ case 12:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::min60;
+ break;
+ case 13:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare3;
+ break;
+ case 14:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare2;
+ break;
+ case 15:
+ default:
+ elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfigEutra::spare1;
+ }
+
+ // reportAmount
+ bIterator = DeserializeEnum (8, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ elem.reportConfigEutra.reportAmount = 1;
+ break;
+ case 1:
+ elem.reportConfigEutra.reportAmount = 2;
+ break;
+ case 2:
+ elem.reportConfigEutra.reportAmount = 4;
+ break;
+ case 3:
+ elem.reportConfigEutra.reportAmount = 8;
+ break;
+ case 4:
+ elem.reportConfigEutra.reportAmount = 16;
+ break;
+ case 5:
+ elem.reportConfigEutra.reportAmount = 32;
+ break;
+ case 6:
+ elem.reportConfigEutra.reportAmount = 64;
+ break;
+ default:
+ elem.reportConfigEutra.reportAmount = 0;
+ }
+ }
+
+ if (reportConfigChoice == 1)
+ {
+ // ReportConfigInterRAT
+ // ...
+ }
+
+ measConfig->reportConfigToAddModList.push_back (elem);
+ }
+ }
+
+ if (bitset11[6])
+ {
+ // measIdToRemoveList
+ int measIdToRemoveListElems;
+ bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID, 1, bIterator);
+
+ for (int i = 0; i < measIdToRemoveListElems; i++)
+ {
+ bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
+ measConfig->measIdToRemoveList.push_back (n);
+ }
+ }
+
+ if (bitset11[5])
+ {
+ // measIdToAddModList
+ int measIdToAddModListElems;
+ bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID, 1, bIterator);
+
+ for (int i = 0; i < measIdToAddModListElems; i++)
+ {
+ LteRrcSap::MeasIdToAddMod elem;
+
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator);
+ elem.measId = n;
+
+ bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator);
+ elem.measObjectId = n;
+
+ bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator);
+ elem.reportConfigId = n;
+
+ measConfig->measIdToAddModList.push_back (elem);
+ }
+ }
+
+ measConfig->haveQuantityConfig = bitset11[4];
+ if (measConfig->haveQuantityConfig)
+ {
+ // quantityConfig
+ std::bitset<4> quantityConfigOpts;
+ bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator);
+
+ if (quantityConfigOpts[3])
+ {
+ // quantityConfigEUTRA
+ bIterator = DeserializeSequence (&bitset0,false,bIterator);
+ bIterator = DeserializeEnum (16, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ measConfig->quantityConfig.filterCoefficientRSRP = 0;
+ break;
+ case 1:
+ measConfig->quantityConfig.filterCoefficientRSRP = 1;
+ break;
+ case 2:
+ measConfig->quantityConfig.filterCoefficientRSRP = 2;
+ break;
+ case 3:
+ measConfig->quantityConfig.filterCoefficientRSRP = 3;
+ break;
+ case 4:
+ measConfig->quantityConfig.filterCoefficientRSRP = 4;
+ break;
+ case 5:
+ measConfig->quantityConfig.filterCoefficientRSRP = 5;
+ break;
+ case 6:
+ measConfig->quantityConfig.filterCoefficientRSRP = 6;
+ break;
+ case 7:
+ measConfig->quantityConfig.filterCoefficientRSRP = 7;
+ break;
+ case 8:
+ measConfig->quantityConfig.filterCoefficientRSRP = 8;
+ break;
+ case 9:
+ measConfig->quantityConfig.filterCoefficientRSRP = 9;
+ break;
+ case 10:
+ measConfig->quantityConfig.filterCoefficientRSRP = 11;
+ break;
+ case 11:
+ measConfig->quantityConfig.filterCoefficientRSRP = 13;
+ break;
+ case 12:
+ measConfig->quantityConfig.filterCoefficientRSRP = 15;
+ break;
+ case 13:
+ measConfig->quantityConfig.filterCoefficientRSRP = 17;
+ break;
+ case 14:
+ measConfig->quantityConfig.filterCoefficientRSRP = 19;
+ break;
+ case 15:
+ measConfig->quantityConfig.filterCoefficientRSRP = 0;
+ break;
+ default:
+ measConfig->quantityConfig.filterCoefficientRSRP = 4;
+ }
+ bIterator = DeserializeEnum (16, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 0;
+ break;
+ case 1:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 1;
+ break;
+ case 2:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 2;
+ break;
+ case 3:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 3;
+ break;
+ case 4:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 4;
+ break;
+ case 5:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 5;
+ break;
+ case 6:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 6;
+ break;
+ case 7:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 7;
+ break;
+ case 8:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 8;
+ break;
+ case 9:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 9;
+ break;
+ case 10:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 11;
+ break;
+ case 11:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 13;
+ break;
+ case 12:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 15;
+ break;
+ case 13:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 17;
+ break;
+ case 14:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 19;
+ break;
+ case 15:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 0;
+ break;
+ default:
+ measConfig->quantityConfig.filterCoefficientRSRQ = 4;
+ }
+ }
+ if (quantityConfigOpts[2])
+ {
+ // quantityConfigUTRA
+ // ...
+ }
+ if (quantityConfigOpts[1])
+ {
+ // quantityConfigGERAN
+ // ...
+ }
+ if (quantityConfigOpts[0])
+ {
+ // quantityConfigCDMA2000
+ // ...
+ }
+ }
+
+ measConfig->haveMeasGapConfig = bitset11[3];
+ if (measConfig->haveMeasGapConfig)
+ {
+ // measGapConfig
+ int measGapConfigChoice;
+ bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator);
+ switch (measGapConfigChoice)
+ {
+ case 0:
+ measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET;
+ bIterator = DeserializeNull (bIterator);
+ break;
+ case 1:
+ default:
+ measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ int gapOffsetChoice;
+ bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator);
+ switch (gapOffsetChoice)
+ {
+ case 0:
+ measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp0;
+ bIterator = DeserializeInteger (&n, 0, 39, bIterator);
+ measConfig->measGapConfig.gapOffsetValue = n;
+ break;
+ case 1:
+ default:
+ measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConfig::gp1;
+ bIterator = DeserializeInteger (&n, 0, 79, bIterator);
+ measConfig->measGapConfig.gapOffsetValue = n;
+ }
+ }
+ }
+
+ measConfig->haveSmeasure = bitset11[2];
+ if (measConfig->haveSmeasure)
+ {
+ // s-Measure
+ bIterator = DeserializeInteger (&n, 0, 97, bIterator);
+ measConfig->sMeasure = n;
+ }
+
+ if (bitset11[1])
+ {
+ // preRegistrationInfoHRPD
+ // ...
+ }
+
+ measConfig->haveSpeedStatePars = bitset11[0];
+ if (measConfig->haveSpeedStatePars)
+ {
+ // speedStatePars
+ int speedStateParsChoice;
+ bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterator);
+ switch (speedStateParsChoice)
+ {
+ case 0:
+ measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET;
+ bIterator = DeserializeNull (bIterator);
+ break;
+ case 1:
+ default:
+ measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP;
+ bIterator = DeserializeSequence (&bitset0, false, bIterator);
+
+ // Deserialize mobilityStateParameters
+ // Deserialize t-Evaluation
+ bIterator = DeserializeEnum (8, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 30;
+ break;
+ case 1:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 60;
+ break;
+ case 2:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 120;
+ break;
+ case 3:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 180;
+ break;
+ case 4:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 240;
+ break;
+ default:
+ measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0;
+ }
+ // Deserialize t-HystNormal
+ bIterator = DeserializeEnum (8, &n, bIterator);
+ switch (n)
+ {
+ case 0:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 30;
+ break;
+ case 1:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 60;
+ break;
+ case 2:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 120;
+ break;
+ case 3:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 180;
+ break;
+ case 4:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 240;
+ break;
+ default:
+ measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0;
+ }
+
+ bIterator = DeserializeInteger (&n, 1, 16, bIterator);
+ measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium = n;
+
+ bIterator = DeserializeInteger (&n, 1, 16, bIterator);
+ measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n;
+
+ // Deserialize timeToTriggerSf
+ bIterator = DeserializeEnum (4, &n, bIterator);
+ measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25;
+ bIterator = DeserializeEnum (4, &n, bIterator);
+ measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25;
+ }
+ }
+ return bIterator;
+}
//////////////////// RrcConnectionRequest class ////////////////////////
// Constructor
@@ -2656,13 +4415,9 @@
options.set (0,0); // No nonCriticalExtension
SerializeSequence (options,false);
-
if (m_haveMeasConfig)
{
- // Serialize MeasConfig sequence
- // 11 optional fields, extension marker present
- std::bitset<11> measConfigOptional (0);
- SerializeSequence (measConfigOptional,true);
+ SerializeMeasConfig (m_measConfig);
}
if (m_haveMobilityControlInfo)
@@ -2810,55 +4565,7 @@
m_haveMeasConfig = rrcConnRecOpts[5];
if (m_haveMeasConfig)
{
- std::bitset<11> bitset11;
-
- // measConfig
- bIterator = DeserializeSequence (&bitset11,true,bIterator);
-
- if (bitset11[10])
- {
- // measObjectToRemoveList
- }
- if (bitset11[9])
- {
- // measObjectToAddModList
- }
- if (bitset11[8])
- {
- // reportConfigToRemoveList
- }
- if (bitset11[7])
- {
- // reportConfigToAddModList
- }
- if (bitset11[6])
- {
- // measIdToRemoveList
- }
- if (bitset11[5])
- {
- // measIdToAddModList
- }
- if (bitset11[4])
- {
- // quantityConfig
- }
- if (bitset11[3])
- {
- // measGapConfig
- }
- if (bitset11[2])
- {
- // s-Measure
- }
- if (bitset11[1])
- {
- // preRegistrationInfoHRPD
- }
- if (bitset11[0])
- {
- // speedStatePars
- }
+ bIterator = DeserializeMeasConfig (&m_measConfig, bIterator);
}
m_haveMobilityControlInfo = rrcConnRecOpts[4];
@@ -3015,6 +4722,207 @@
{
os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std::endl;
os << "haveMeasConfig: " << m_haveMeasConfig << std::endl;
+ if (m_haveMobilityControlInfo)
+ {
+ if (!m_measConfig.measObjectToRemoveList.empty ())
+ {
+ os << " measObjectToRemoveList: ";
+ std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+ if (!m_measConfig.reportConfigToRemoveList.empty ())
+ {
+ os << " reportConfigToRemoveList: ";
+ std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+ if (!m_measConfig.measIdToRemoveList.empty ())
+ {
+ os << " measIdToRemoveList: ";
+ std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+
+ if (!m_measConfig.measObjectToAddModList.empty ())
+ {
+ os << " measObjectToAddMod: " << std::endl;
+ std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.measObjectToAddModList;
+ std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << " measObjectId: " << (int)it->measObjectId << std::endl;
+ os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq << std::endl;
+ os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.allowedMeasBandwidth << std::endl;
+ os << " presenceAntennaPort1: " << it->measObjectEutra.presenceAntennaPort1 << std::endl;
+ os << " neighCellConfig: " << (int) it->measObjectEutra.neighCellConfig << std::endl;
+ os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq << std::endl;
+
+
+ if (!it->measObjectEutra.cellsToRemoveList.empty ())
+ {
+ os << " cellsToRemoveList: ";
+ std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+
+ if (!it->measObjectEutra.blackCellsToRemoveList.empty ())
+ {
+ os << " blackCellsToRemoveList: ";
+ std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToRemoveList;
+ std::list<uint8_t>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << (int) *it << ", ";
+ }
+ os << std::endl;
+ }
+
+ if (!it->measObjectEutra.cellsToAddModList.empty ())
+ {
+ os << " cellsToAddModList: " << std::endl;
+ std::list<LteRrcSap::CellsToAddMod> auxList = it->measObjectEutra.cellsToAddModList;
+ std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << " cellIndex: " << (int)it->cellIndex << std::endl;
+ os << " physCellId: " << (int)it->physCellId << std::endl;
+ os << " cellIndividualOffset: " << (int)it->cellIndividualOffset << std::endl;
+ os << " ------ " << std::endl;
+ }
+ }
+
+ if (!it->measObjectEutra.blackCellsToAddModList.empty ())
+ {
+ os << " blackCellsToAddModList: " << std::endl;
+ std::list<LteRrcSap::BlackCellsToAddMod> auxList = it->measObjectEutra.blackCellsToAddModList;
+ std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << " cellIndex: " << (int)it->cellIndex << std::endl;
+ os << " physCellIdRange.start: " << (int)it->physCellIdRange.start << std::endl;
+ os << " physCellIdRange.haveRange: " << it->physCellIdRange.haveRange << std::endl;
+ os << " physCellIdRange.range: " << (int)it->physCellIdRange.range << std::endl;
+ os << " ------ " << std::endl;
+ }
+ }
+
+ os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.haveCellForWhichToReportCGI << std::endl;
+ os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra.cellForWhichToReportCGI << std::endl;
+ os << " ------------- " << std::endl;
+ }
+
+ }
+
+ if (!m_measConfig.reportConfigToAddModList.empty ())
+ {
+ os << " reportConfigToAddModList: " << std::endl;
+ std::list<LteRrcSap::ReportConfigToAddMod> auxList = m_measConfig.reportConfigToAddModList;
+ std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
+ os << " reportConfigEutra.triggerType " << (int)it->reportConfigEutra.triggerType << std::endl;
+ if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEutra::event)
+ {
+ os << " reportConfigEutra.eventId " << (int)it->reportConfigEutra.eventId << std::endl;
+ if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::eventA3)
+ {
+ os << " reportConfigEutra.reportOnLeave " << (int)it->reportConfigEutra.reportOnLeave << std::endl;
+ os << " reportConfigEutra.a3Offset " << (int)it->reportConfigEutra.a3Offset << std::endl;
+ }
+ else
+ {
+ os << " reportConfigEutra.threshold1.choice " << (int)it->reportConfigEutra.threshold1.choice << std::endl;
+ os << " reportConfigEutra.threshold1.range " << (int)it->reportConfigEutra.threshold1.range << std::endl;
+ if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEutra::eventA5)
+ {
+ os << " reportConfigEutra.threshold2.choice " << (int)it->reportConfigEutra.threshold2.choice << std::endl;
+ os << " reportConfigEutra.threshold2.range " << (int)it->reportConfigEutra.threshold2.range << std::endl;
+ }
+ }
+ os << " reportConfigEutra.hysteresis " << (int)it->reportConfigEutra.hysteresis << std::endl;
+ os << " reportConfigEutra.timeToTrigger " << (int)it->reportConfigEutra.timeToTrigger << std::endl;
+ }
+ else
+ {
+ os << " reportConfigEutra.purpose " << (int)it->reportConfigEutra.purpose << std::endl;
+ }
+ os << " reportConfigEutra.triggerQuantity " << (int)it->reportConfigEutra.triggerQuantity << std::endl;
+ os << " reportConfigEutra.reportQuantity " << (int)it->reportConfigEutra.reportQuantity << std::endl;
+ os << " reportConfigEutra.maxReportCells " << (int)it->reportConfigEutra.maxReportCells << std::endl;
+ os << " reportConfigEutra.reportInterval " << (int)it->reportConfigEutra.reportInterval << std::endl;
+ os << " reportConfigEutra.reportAmount " << (int)it->reportConfigEutra.reportAmount << std::endl;
+ }
+ }
+
+ if (!m_measConfig.measIdToAddModList.empty ())
+ {
+ os << " measIdToAddModList: " << std::endl;
+ std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdToAddModList;
+ std::list<LteRrcSap::MeasIdToAddMod>::iterator it = auxList.begin ();
+ for (; it != auxList.end (); it++)
+ {
+ os << " measId: " << (int)it->measId << std::endl;
+ os << " measObjectId: " << (int)it->measObjectId << std::endl;
+ os << " reportConfigId: " << (int)it->reportConfigId << std::endl;
+ os << " ------ " << std::endl;
+ }
+ }
+
+ os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::endl;
+ if (m_measConfig.haveQuantityConfig)
+ {
+ os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfig.filterCoefficientRSRP << std::endl;
+ os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig.filterCoefficientRSRQ << std::endl;
+ }
+
+ os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::endl;
+ if (m_measConfig.haveMeasGapConfig)
+ {
+ os << " measGapConfig.type: " << m_measConfig.measGapConfig.type << std::endl;
+ os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGapConfig.gapOffsetChoice
+ << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" << std::endl;
+ }
+
+ os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl;
+ if (m_measConfig.haveSmeasure)
+ {
+ os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl;
+ }
+
+ os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::endl;
+ if (m_measConfig.haveSpeedStatePars)
+ {
+ os << " speedStatePars.type: " << m_measConfig.speedStatePars.type << std::endl;
+ os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl;
+ os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl;
+ os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium << std::endl;
+ os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << std::endl;
+ os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl;
+ os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl;
+ }
+ }
+
os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl;
if (m_haveMobilityControlInfo)
{
@@ -3188,9 +5096,7 @@
SerializeSequence (std::bitset<0> (),true);
// Serialize sourceMeasConfig
- // 11 optional fields, extension marker present
- std::bitset<11> measConfigOptional (0);
- SerializeSequence (measConfigOptional,true);
+ SerializeMeasConfig (m_asConfig.sourceMeasConfig);
// Serialize sourceRadioResourceConfig
SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig);
@@ -3279,53 +5185,7 @@
bIterator = DeserializeSequence (&bitset0,true,bIterator);
// Deserialize sourceMeasConfig
- std::bitset<11> bitset11;
- bIterator = DeserializeSequence (&bitset11,true,bIterator);
-
- if (bitset11[10]) //measObjectToRemoveList
- {
- // ...
- }
- if (bitset11[9]) //measObjectToAddModList
- {
- // ...
- }
- if (bitset11[8]) //reportConfigToRemoveList
- {
- // ...
- }
- if (bitset11[7]) //reportConfigToAddModList
- {
- // ...
- }
- if (bitset11[6]) //measIdToRemoveList
- {
- // ...
- }
- if (bitset11[5]) //measIdToAddModList
- {
- // ...
- }
- if (bitset11[4]) //quantityConfig
- {
- // ...
- }
- if (bitset11[3]) //measGapConfig
- {
- // ...
- }
- if (bitset11[2]) //s-Measure
- {
- // ...
- }
- if (bitset11[1]) //preRegistrationInfoHRPD
- {
- // ...
- }
- if (bitset11[0]) //speedStatePars
- {
- // ...
- }
+ bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, bIterator);
// Deserialize sourceRadioResourceConfig
bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.sourceRadioResourceConfig,bIterator);