Pdcp,schedulers,etc: more use of structured bindings (c++17)

avarga · avarga · commit f39bcf353f63 · 2025-09-13T17:33:45.000+02:00
diff --git a/src/simu5g/apps/d2dMultihop/eventGenerator/EventGenerator.cc b/src/simu5g/apps/d2dMultihop/eventGenerator/EventGenerator.cc
@@ -117,10 +117,10 @@ void EventGenerator::computeTargetNodeSet(std::set<MacNodeId>& targetSet, MacNod
         inet::Coord srcCoord = uePos[sourceId];
 
         // compute the distance for each UE
-        for (auto& mit : uePos) {
-            if (mit.second.distance(srcCoord) < maxBroadcastRadius) {
-                EV << " - " << mit.first << endl;
-                targetSet.insert(mit.first);
+        for (auto& [nodeId, pos] : uePos) {
+            if (pos.distance(srcCoord) < maxBroadcastRadius) {
+                EV << " - " << nodeId << endl;
+                targetSet.insert(nodeId);
             }
         }
     }
diff --git a/src/simu5g/corenetwork/statsCollector/BaseStationStatsCollector.cc b/src/simu5g/corenetwork/statsCollector/BaseStationStatsCollector.cc
@@ -158,33 +158,33 @@ void BaseStationStatsCollector::handleMessage(cMessage *msg)
 void BaseStationStatsCollector::resetDiscardCounterPerUe()
 {
     EV << collectorType_ << "::resetDiscardCounterPerUe " << endl;
-    for (auto const& ue : ueCollectors_) {
-        packetFlowManager_->resetDiscardCounterPerUe(ue.first);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        packetFlowManager_->resetDiscardCounterPerUe(ueId);
     }
 }
 
 void BaseStationStatsCollector::resetDelayCounterPerUe()
 {
     EV << collectorType_ << "::resetDelayCounterPerUe " << endl;
-    for (auto const& ue : ueCollectors_) {
-        packetFlowManager_->resetDelayCounterPerUe(ue.first);
-        ue.second->resetDelayCounter();
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        packetFlowManager_->resetDelayCounterPerUe(ueId);
+        ueCollector->resetDelayCounter();
     }
 }
 
 void BaseStationStatsCollector::resetThroughputCountersPerUe()
 {
     EV << collectorType_ << "::resetThroughputCountersPerUe " << endl;
-    for (auto const& ue : ueCollectors_) {
-        packetFlowManager_->resetThroughputCounterPerUe(ue.first);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        packetFlowManager_->resetThroughputCounterPerUe(ueId);
     }
 }
 
 void BaseStationStatsCollector::resetBytesCountersPerUe()
 {
     EV << collectorType_ << "::resetBytesCountersPerUe " << endl;
-    for (auto const& ue : ueCollectors_) {
-        packetFlowManager_->resetDataVolume(ue.first);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        packetFlowManager_->resetDataVolume(ueId);
     }
 }
 
@@ -273,8 +273,8 @@ void BaseStationStatsCollector::add_ul_nongbr_pdr_cell()
     DiscardedPkts pair = { 0, 0 };
     DiscardedPkts temp = { 0, 0 };
 
-    for (auto const& ue : ueCollectors_) {
-        temp = ue.second->getULDiscardedPkt();
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        temp = ueCollector->getULDiscardedPkt();
         pair.discarded += temp.discarded;
         pair.total += temp.total;
     }
@@ -294,37 +294,37 @@ void BaseStationStatsCollector::add_dl_nongbr_pdr_cell_perUser()
 {
     EV << collectorType_ << "::add_dl_nongbr_pdr_cell_perUser()" << endl;
     double discard;
-    for (auto const& ue : ueCollectors_) {
-        discard = packetFlowManager_->getDiscardedPktPerUe(ue.first);
-        ue.second->add_dl_nongbr_pdr_ue((int)discard);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        discard = packetFlowManager_->getDiscardedPktPerUe(ueId);
+        ueCollector->add_dl_nongbr_pdr_ue((int)discard);
     }
 }
 
 void BaseStationStatsCollector::add_ul_nongbr_pdr_cell_perUser()
 {
     EV << collectorType_ << "::add_ul_nongbr_pdr_cell_perUser()" << endl;
-    for (auto const& ue : ueCollectors_) {
-        ue.second->add_ul_nongbr_pdr_ue();
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        ueCollector->add_ul_nongbr_pdr_ue();
     }
 }
 
 void BaseStationStatsCollector::add_ul_nongbr_delay_perUser()
 {
     EV << collectorType_ << "::add_ul_nongbr_delay_perUser()" << endl;
-    for (auto const& ue : ueCollectors_) {
-        ue.second->add_ul_nongbr_delay_ue();
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        ueCollector->add_ul_nongbr_delay_ue();
     }
 }
 
 void BaseStationStatsCollector::add_dl_nongbr_delay_perUser()
 {
     EV << collectorType_ << "::add_dl_nongbr_delay_perUser()" << endl;
     double delay;
-    for (auto const& ue : ueCollectors_) {
-        delay = packetFlowManager_->getDelayStatsPerUe(ue.first);
-        EV << collectorType_ << "::add_dl_nongbr_delay_perUser - delay: " << delay << " for node id: " << ue.first << endl;
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        delay = packetFlowManager_->getDelayStatsPerUe(ueId);
+        EV << collectorType_ << "::add_dl_nongbr_delay_perUser - delay: " << delay << " for node id: " << ueId << endl;
         if (delay != 0) {
-            ue.second->add_dl_nongbr_delay_ue((int)delay);
+            ueCollector->add_dl_nongbr_delay_ue((int)delay);
         }
     }
 }
@@ -333,47 +333,47 @@ void BaseStationStatsCollector::add_ul_nongbr_data_volume_ue_perUser()
 {
     EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser" << endl;
     unsigned int bytes;
-    for (auto const& ue : ueCollectors_) {
-        bytes = packetFlowManager_->getDataVolume(ue.first, UL);
-        EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser - received: " << bytes << "B in UL from node id: " << ue.first << endl;
-        ue.second->add_ul_nongbr_data_volume_ue(bytes);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        bytes = packetFlowManager_->getDataVolume(ueId, UL);
+        EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser - received: " << bytes << "B in UL from node id: " << ueId << endl;
+        ueCollector->add_ul_nongbr_data_volume_ue(bytes);
     }
 }
 
 void BaseStationStatsCollector::add_dl_nongbr_data_volume_ue_perUser()
 {
     EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser" << endl;
     unsigned int bytes;
-    for (auto const& ue : ueCollectors_) {
-        bytes = packetFlowManager_->getDataVolume(ue.first, DL);
-        EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser - sent: " << bytes << "B in DL to node id: " << ue.first << endl;
-        ue.second->add_dl_nongbr_data_volume_ue(bytes);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        bytes = packetFlowManager_->getDataVolume(ueId, DL);
+        EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser - sent: " << bytes << "B in DL to node id: " << ueId << endl;
+        ueCollector->add_dl_nongbr_data_volume_ue(bytes);
     }
 }
 
 void BaseStationStatsCollector::add_dl_nongbr_throughput_ue_perUser()
 {
     EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser" << endl;
     double throughput;
-    for (auto const& ue : ueCollectors_) {
-        throughput = packetFlowManager_->getThroughputStatsPerUe(ue.first);
-        EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ue.first << endl;
-        packetFlowManager_->resetThroughputCounterPerUe(ue.first);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        throughput = packetFlowManager_->getThroughputStatsPerUe(ueId);
+        EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ueId << endl;
+        packetFlowManager_->resetThroughputCounterPerUe(ueId);
         if (throughput > 0.0)
-            ue.second->add_dl_nongbr_throughput_ue((int)throughput);
+            ueCollector->add_dl_nongbr_throughput_ue((int)throughput);
     }
 }
 
 void BaseStationStatsCollector::add_ul_nongbr_throughput_ue_perUser()
 {
     EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser" << endl;
     double throughput;
-    for (auto const& ue : ueCollectors_) {
-        throughput = rlc_->getUeThroughput(ue.first);
-        EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ue.first << endl;
-        rlc_->resetThroughputStats(ue.first);
+    for (auto const& [ueId, ueCollector] : ueCollectors_) {
+        throughput = rlc_->getUeThroughput(ueId);
+        EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ueId << endl;
+        rlc_->resetThroughputStats(ueId);
         if (throughput > 0.0)
-            ue.second->add_ul_nongbr_throughput_ue((int)throughput);
+            ueCollector->add_ul_nongbr_throughput_ue((int)throughput);
     }
 }
 
diff --git a/src/simu5g/stack/mac/amc/LteAmc.cc b/src/simu5g/stack/mac/amc/LteAmc.cc
@@ -101,11 +101,11 @@ void LteAmc::printFbhb(Direction dir)
 
     for (auto& [carrier, hist] : *history) { // for each antenna
         EV << simTime() << " # Carrier: " << carrier << "\n";
-        for (auto& histItem : hist) {
-            EV << simTime() << " # Remote: " << dasToA(histItem.first) << "\n";
-            for (size_t i = 0; i < histItem.second.size(); i++) { // for each UE
+        for (auto& [remote, remoteHist] : hist) {
+            EV << simTime() << " # Remote: " << dasToA(remote) << "\n";
+            for (size_t i = 0; i < remoteHist.size(); i++) { // for each UE
                 EV << "Ue index: " << i << ", MacNodeId: " << (*revIndex)[i] << endl;
-                auto& txVec = histItem.second[i];
+                auto& txVec = remoteHist[i];
                 for (size_t t = 0; t < txVec.size(); t++) { // for each tx mode
                     TxMode txMode = TxMode(t);
 
@@ -1137,28 +1137,28 @@ void LteAmc::detachUser(MacNodeId nodeId, Direction dir)
 
         // clear feedback data from history
         if (dir == UL || dir == DL) {
-            for (auto& hit : *history) {
+            for (auto& [carrierFreq, hist] : *history) {
                 for (auto remote : remoteSet_) {
-                    hit.second.at(remote).at(nodeIndex).clear();
+                    hist.at(remote).at(nodeIndex).clear();
                 }
             }
         }
         else { // D2D
-            for (auto& hit : *d2dHistory) {
-                for (auto& ht : hit.second) {
-                    if (ht.first == NODEID_NONE)                                          // skip fake UE 0
+            for (auto& [carrierFreq, carrierHist] : *d2dHistory) {
+                for (auto& [peerId, peerHist] : carrierHist) {
+                    if (peerId == NODEID_NONE)                                          // skip fake UE 0
                         continue;
 
                     for (auto remote : remoteSet_) {
-                        ht.second.at(remote).at(nodeIndex).clear();
+                        peerHist.at(remote).at(nodeIndex).clear();
                     }
                 }
             }
         }
 
         // clear user transmission parameters for this UE
-        for (auto& item : *userInfoVec) {
-            item.second.at(nodeIndex).restoreDefaultValues();
+        for (auto& [carrierFreq, txParams] : *userInfoVec) {
+            txParams.at(nodeIndex).restoreDefaultValues();
         }
     }
     catch (std::exception& e) {
diff --git a/src/simu5g/stack/mac/scheduler/LteSchedulerEnbDl.cc b/src/simu5g/stack/mac/scheduler/LteSchedulerEnbDl.cc
@@ -396,15 +396,14 @@ bool LteSchedulerEnbDl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandL
         // examination of HARQ process in rtx status, adding them to scheduling list
         for (auto it = harqQueues->begin(); it != harqQueues->end(); ) {
             // For each UE
-            MacNodeId nodeId = it->first;
+            auto& [nodeId, currHarq] = *it;
 
             OmnetId id = binder_->getOmnetId(nodeId);
             if (id == 0) {
                 // UE has left the simulation, erase HARQ queue
                 it = harqQueues->erase(it);
                 continue;
             }
-            LteHarqBufferTx *currHarq = it->second;
             std::vector<LteHarqProcessTx *> *processes = currHarq->getHarqProcesses();
 
             // Get user transmission parameters
@@ -492,8 +491,8 @@ bool LteSchedulerEnbDl::rtxscheduleBackground(GHz carrierFrequency, BandLimitVec
     }
 
     // consume bytes
-    for (auto & it : bgScheduledRtx)
-        bgTrafficManager->consumeBackloggedUeBytes(it.first, it.second, direction_, true); // in bytes
+    for (auto& [bgUeId, scheduledBytes] : bgScheduledRtx)
+        bgTrafficManager->consumeBackloggedUeBytes(bgUeId, scheduledBytes, direction_, true); // in bytes
 
     unsigned int availableBlocks = allocator_->computeTotalRbs();
     EV << " LteSchedulerEnbDl::rtxscheduleBackground OFDM Space: " << availableBlocks << endl;
diff --git a/src/simu5g/stack/mac/scheduler/LteSchedulerEnbUl.cc b/src/simu5g/stack/mac/scheduler/LteSchedulerEnbUl.cc
@@ -267,8 +267,8 @@ bool LteSchedulerEnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandL
         if (freqIt != harqRxBuffers_->end()) {
             auto& rxBufferForCarrierFrequency = freqIt->second;
             for (auto it = rxBufferForCarrierFrequency.begin(); it != rxBufferForCarrierFrequency.end(); ) {
-                // get current nodeId
-                MacNodeId nodeId = it->first;
+                // get current nodeId and buffer
+                auto& [nodeId, harqBuffer] = *it;
 
                 if (nodeId == NODEID_NONE) {
                     // UE has left the simulation - erase queue and continue
@@ -286,8 +286,8 @@ bool LteSchedulerEnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandL
 
                 // check whether the UE has a H-ARQ process waiting for retransmission. If not, skip UE.
                 bool skip = true;
-                unsigned char acid = (currentAcid + 2) % (it->second->getProcesses());
-                LteHarqProcessRx *currentProcess = it->second->getProcess(acid);
+                unsigned char acid = (currentAcid + 2) % (harqBuffer->getProcesses());
+                LteHarqProcessRx *currentProcess = harqBuffer->getProcess(acid);
                 std::vector<RxUnitStatus> procStatus = currentProcess->getProcessStatus();
                 for (const auto& status : procStatus) {
                     if (status.second == RXHARQ_PDU_CORRUPTED) {
@@ -328,8 +328,9 @@ bool LteSchedulerEnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandL
             HarqBuffersMirrorD2D *harqBuffersMirrorD2D = check_and_cast<LteMacEnbD2D *>(mac_.get())->getHarqBuffersMirrorD2D(carrierFrequency);
             if (harqBuffersMirrorD2D != nullptr) {
                 for (auto it_d2d = harqBuffersMirrorD2D->begin(); it_d2d != harqBuffersMirrorD2D->end(); ) {
-                    MacNodeId senderId = (it_d2d->first).first; // Transmitter
-                    MacNodeId destId = (it_d2d->first).second;  // Receiver
+                    auto& [d2dPair, harqBufferMirror] = *it_d2d;
+                    MacNodeId senderId = d2dPair.first; // Transmitter
+                    MacNodeId destId = d2dPair.second;  // Receiver
 
                     if (senderId == NODEID_NONE || binder_->getOmnetId(senderId) == 0) {
                         // UE has left the simulation - erase queue and continue
@@ -347,8 +348,8 @@ bool LteSchedulerEnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandL
 
                     // check whether the UE has a H-ARQ process waiting for retransmission. If not, skip UE.
                     bool skip = true;
-                    unsigned char acid = (currentAcid + 2) % (it_d2d->second->getProcesses());
-                    LteHarqProcessMirrorD2D *currentProcess = it_d2d->second->getProcess(acid);
+                    unsigned char acid = (currentAcid + 2) % (harqBufferMirror->getProcesses());
+                    LteHarqProcessMirrorD2D *currentProcess = harqBufferMirror->getProcess(acid);
                     std::vector<TxHarqPduStatus> procStatus = currentProcess->getProcessStatus();
                     for (const auto& status : procStatus) {
                         if (status == TXHARQ_PDU_BUFFERED) {
@@ -419,8 +420,8 @@ bool LteSchedulerEnbUl::rtxscheduleBackground(GHz carrierFrequency, BandLimitVec
         }
 
         // consume bytes
-        for (auto & it : bgScheduledRtx)
-            bgTrafficManager->consumeBackloggedUeBytes(it.first, it.second, direction_, true); // in bytes
+        for (auto& [bgUeId, scheduledBytes] : bgScheduledRtx)
+            bgTrafficManager->consumeBackloggedUeBytes(bgUeId, scheduledBytes, direction_, true); // in bytes
 
         int availableBlocks = allocator_->computeTotalRbs();
 
diff --git a/src/simu5g/stack/mac/scheduler/NrSchedulerGnbUl.cc b/src/simu5g/stack/mac/scheduler/NrSchedulerGnbUl.cc
@@ -115,10 +115,10 @@ bool NrSchedulerGnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandLi
             HarqBuffersMirrorD2D *harqBuffersMirrorD2D = check_and_cast<LteMacEnbD2D *>(mac_.get())->getHarqBuffersMirrorD2D(carrierFrequency);
             if (harqBuffersMirrorD2D != nullptr) {
                 for (auto it_d2d = harqBuffersMirrorD2D->begin(); it_d2d != harqBuffersMirrorD2D->end(); ) {
-
+                    auto& [d2dPair, currHarq] = *it_d2d;
                     // get current nodeIDs
-                    MacNodeId senderId = (it_d2d->first).first; // Transmitter
-                    MacNodeId destId = (it_d2d->first).second;  // Receiver
+                    MacNodeId senderId = d2dPair.first; // Transmitter
+                    MacNodeId destId = d2dPair.second;  // Receiver
 
                     if (senderId == NODEID_NONE || binder_->getOmnetId(senderId) == 0) {
                         // UE has left the simulation - erase queue and continue
@@ -131,8 +131,6 @@ bool NrSchedulerGnbUl::rtxschedule(GHz carrierFrequency, BandLimitVector *bandLi
                         continue;
                     }
 
-                    LteHarqBufferMirrorD2D *currHarq = it_d2d->second;
-
                     // Get user transmission parameters
                     const UserTxParams& txParams = mac_->getAmc()->computeTxParams(senderId, dir, carrierFrequency);// get the user info
 
diff --git a/src/simu5g/stack/packetFlowManager/PacketFlowManagerUe.cc b/src/simu5g/stack/packetFlowManager/PacketFlowManagerUe.cc
@@ -302,10 +302,10 @@ void PacketFlowManagerUe::insertMacPdu(inet::Ptr<const LteMacPdu> macPdu)
         // set the pdcp pdus related to this RLC as sent over the air since this method is called after the MAC ID
         // has been inserted in the HARQBuffer
         SequenceNumberSet pdcpSet = tit->second;
-        for (auto pit : pdcpSet) {
-            auto sdit = desc->pdcpStatus_.find(pit);
+        for (auto pdcpSno : pdcpSet) {
+            auto sdit = desc->pdcpStatus_.find(pdcpSno);
             if (sdit == desc->pdcpStatus_.end())
-                throw cRuntimeError("%s::insertMacPdu - PdcpStatus for PDCP sno [%d] not present, this should not happen", pfmType.c_str(), pit);
+                throw cRuntimeError("%s::insertMacPdu - PdcpStatus for PDCP sno [%d] not present, this should not happen", pfmType.c_str(), pdcpSno);
             sdit->second.sentOverTheAir = true;
         }
     }
diff --git a/src/simu5g/stack/pdcp/LtePdcp.cc b/src/simu5g/stack/pdcp/LtePdcp.cc
@@ -358,8 +358,9 @@ void LtePdcpEnb::deleteEntities(MacNodeId nodeId)
 
     // delete connections related to the given UE
     for (auto tit = txEntities_.begin(); tit != txEntities_.end(); ) {
-        if (tit->first.getNodeId() == nodeId) {
-            tit->second->deleteModule();
+        auto& [cid, txEntity] = *tit;
+        if (cid.getNodeId() == nodeId) {
+            txEntity->deleteModule();
             tit = txEntities_.erase(tit);
         }
         else {
@@ -368,8 +369,9 @@ void LtePdcpEnb::deleteEntities(MacNodeId nodeId)
     }
 
     for (auto rit = rxEntities_.begin(); rit != rxEntities_.end(); ) {
-        if (rit->first.getNodeId() == nodeId) {
-            rit->second->deleteModule();
+        auto& [cid, rxEntity] = *rit;
+        if (cid.getNodeId() == nodeId) {
+            rxEntity->deleteModule();
             rit = rxEntities_.erase(rit);
         }
         else {
diff --git a/src/simu5g/stack/pdcp/NrPdcpEnb.cc b/src/simu5g/stack/pdcp/NrPdcpEnb.cc
@@ -167,12 +167,11 @@ void NrPdcpEnb::receiveDataFromSourceNode(Packet *pkt, MacNodeId sourceNode)
 
 void NrPdcpEnb::activeUeUL(std::set<MacNodeId> *ueSet)
 {
-    for (const auto& entity : rxEntities_) {
-        MacNodeId nodeId = entity.first.getNodeId();
-        if (!(entity.second->isEmpty()))
+    for (const auto& [cid, rxEntity] : rxEntities_) {
+        MacNodeId nodeId = cid.getNodeId();
+        if (!(rxEntity->isEmpty()))
             ueSet->insert(nodeId);
     }
 }
 
 } //namespace
-
diff --git a/src/simu5g/stack/pdcp/NrPdcpUe.cc b/src/simu5g/stack/pdcp/NrPdcpUe.cc
diff --git a/src/simu5g/stack/phy/LtePhyBase.cc b/src/simu5g/stack/phy/LtePhyBase.cc

Original file line number	Diff line number	Diff line change
`@@ -117,10 +117,10 @@ void EventGenerator::computeTargetNodeSet(std::set<MacNodeId>& targetSet, MacNod`
`117`	`117`	`inet::Coord srcCoord = uePos[sourceId];`
`118`	`118`
`119`	`119`	`// compute the distance for each UE`
`120`		`- for (auto& mit : uePos) {`
`121`		`- if (mit.second.distance(srcCoord) < maxBroadcastRadius) {`
`122`		`- EV << " - " << mit.first << endl;`
`123`		`- targetSet.insert(mit.first);`
	`120`	`+ for (auto& [nodeId, pos] : uePos) {`
	`121`	`+ if (pos.distance(srcCoord) < maxBroadcastRadius) {`
	`122`	`+ EV << " - " << nodeId << endl;`
	`123`	`+ targetSet.insert(nodeId);`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,33 +158,33 @@ void BaseStationStatsCollector::handleMessage(cMessage *msg)`
`158`	`158`	`void BaseStationStatsCollector::resetDiscardCounterPerUe()`
`159`	`159`	`{`
`160`	`160`	`EV << collectorType_ << "::resetDiscardCounterPerUe " << endl;`
`161`		`- for (auto const& ue : ueCollectors_) {`
`162`		`- packetFlowManager_->resetDiscardCounterPerUe(ue.first);`
	`161`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`162`	`+ packetFlowManager_->resetDiscardCounterPerUe(ueId);`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`void BaseStationStatsCollector::resetDelayCounterPerUe()`
`167`	`167`	`{`
`168`	`168`	`EV << collectorType_ << "::resetDelayCounterPerUe " << endl;`
`169`		`- for (auto const& ue : ueCollectors_) {`
`170`		`- packetFlowManager_->resetDelayCounterPerUe(ue.first);`
`171`		`- ue.second->resetDelayCounter();`
	`169`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`170`	`+ packetFlowManager_->resetDelayCounterPerUe(ueId);`
	`171`	`+ ueCollector->resetDelayCounter();`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`void BaseStationStatsCollector::resetThroughputCountersPerUe()`
`176`	`176`	`{`
`177`	`177`	`EV << collectorType_ << "::resetThroughputCountersPerUe " << endl;`
`178`		`- for (auto const& ue : ueCollectors_) {`
`179`		`- packetFlowManager_->resetThroughputCounterPerUe(ue.first);`
	`178`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`179`	`+ packetFlowManager_->resetThroughputCounterPerUe(ueId);`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`void BaseStationStatsCollector::resetBytesCountersPerUe()`
`184`	`184`	`{`
`185`	`185`	`EV << collectorType_ << "::resetBytesCountersPerUe " << endl;`
`186`		`- for (auto const& ue : ueCollectors_) {`
`187`		`- packetFlowManager_->resetDataVolume(ue.first);`
	`186`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`187`	`+ packetFlowManager_->resetDataVolume(ueId);`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`@@ -273,8 +273,8 @@ void BaseStationStatsCollector::add_ul_nongbr_pdr_cell()`
`273`	`273`	`DiscardedPkts pair = { 0, 0 };`
`274`	`274`	`DiscardedPkts temp = { 0, 0 };`
`275`	`275`
`276`		`- for (auto const& ue : ueCollectors_) {`
`277`		`- temp = ue.second->getULDiscardedPkt();`
	`276`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`277`	`+ temp = ueCollector->getULDiscardedPkt();`
`278`	`278`	`pair.discarded += temp.discarded;`
`279`	`279`	`pair.total += temp.total;`
`280`	`280`	`}`
`@@ -294,37 +294,37 @@ void BaseStationStatsCollector::add_dl_nongbr_pdr_cell_perUser()`
`294`	`294`	`{`
`295`	`295`	`EV << collectorType_ << "::add_dl_nongbr_pdr_cell_perUser()" << endl;`
`296`	`296`	`double discard;`
`297`		`- for (auto const& ue : ueCollectors_) {`
`298`		`- discard = packetFlowManager_->getDiscardedPktPerUe(ue.first);`
`299`		`- ue.second->add_dl_nongbr_pdr_ue((int)discard);`
	`297`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`298`	`+ discard = packetFlowManager_->getDiscardedPktPerUe(ueId);`
	`299`	`+ ueCollector->add_dl_nongbr_pdr_ue((int)discard);`
`300`	`300`	`}`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`void BaseStationStatsCollector::add_ul_nongbr_pdr_cell_perUser()`
`304`	`304`	`{`
`305`	`305`	`EV << collectorType_ << "::add_ul_nongbr_pdr_cell_perUser()" << endl;`
`306`		`- for (auto const& ue : ueCollectors_) {`
`307`		`- ue.second->add_ul_nongbr_pdr_ue();`
	`306`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`307`	`+ ueCollector->add_ul_nongbr_pdr_ue();`
`308`	`308`	`}`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`void BaseStationStatsCollector::add_ul_nongbr_delay_perUser()`
`312`	`312`	`{`
`313`	`313`	`EV << collectorType_ << "::add_ul_nongbr_delay_perUser()" << endl;`
`314`		`- for (auto const& ue : ueCollectors_) {`
`315`		`- ue.second->add_ul_nongbr_delay_ue();`
	`314`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`315`	`+ ueCollector->add_ul_nongbr_delay_ue();`
`316`	`316`	`}`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`void BaseStationStatsCollector::add_dl_nongbr_delay_perUser()`
`320`	`320`	`{`
`321`	`321`	`EV << collectorType_ << "::add_dl_nongbr_delay_perUser()" << endl;`
`322`	`322`	`double delay;`
`323`		`- for (auto const& ue : ueCollectors_) {`
`324`		`- delay = packetFlowManager_->getDelayStatsPerUe(ue.first);`
`325`		`- EV << collectorType_ << "::add_dl_nongbr_delay_perUser - delay: " << delay << " for node id: " << ue.first << endl;`
	`323`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`324`	`+ delay = packetFlowManager_->getDelayStatsPerUe(ueId);`
	`325`	`+ EV << collectorType_ << "::add_dl_nongbr_delay_perUser - delay: " << delay << " for node id: " << ueId << endl;`
`326`	`326`	`if (delay != 0) {`
`327`		`- ue.second->add_dl_nongbr_delay_ue((int)delay);`
	`327`	`+ ueCollector->add_dl_nongbr_delay_ue((int)delay);`
`328`	`328`	`}`
`329`	`329`	`}`
`330`	`330`	`}`
`@@ -333,47 +333,47 @@ void BaseStationStatsCollector::add_ul_nongbr_data_volume_ue_perUser()`
`333`	`333`	`{`
`334`	`334`	`EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser" << endl;`
`335`	`335`	`unsigned int bytes;`
`336`		`- for (auto const& ue : ueCollectors_) {`
`337`		`- bytes = packetFlowManager_->getDataVolume(ue.first, UL);`
`338`		`- EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser - received: " << bytes << "B in UL from node id: " << ue.first << endl;`
`339`		`- ue.second->add_ul_nongbr_data_volume_ue(bytes);`
	`336`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`337`	`+ bytes = packetFlowManager_->getDataVolume(ueId, UL);`
	`338`	`+ EV << collectorType_ << "::add_ul_nongbr_data_volume_ue_perUser - received: " << bytes << "B in UL from node id: " << ueId << endl;`
	`339`	`+ ueCollector->add_ul_nongbr_data_volume_ue(bytes);`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`void BaseStationStatsCollector::add_dl_nongbr_data_volume_ue_perUser()`
`344`	`344`	`{`
`345`	`345`	`EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser" << endl;`
`346`	`346`	`unsigned int bytes;`
`347`		`- for (auto const& ue : ueCollectors_) {`
`348`		`- bytes = packetFlowManager_->getDataVolume(ue.first, DL);`
`349`		`- EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser - sent: " << bytes << "B in DL to node id: " << ue.first << endl;`
`350`		`- ue.second->add_dl_nongbr_data_volume_ue(bytes);`
	`347`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`348`	`+ bytes = packetFlowManager_->getDataVolume(ueId, DL);`
	`349`	`+ EV << collectorType_ << "::add_dl_nongbr_data_volume_ue_perUser - sent: " << bytes << "B in DL to node id: " << ueId << endl;`
	`350`	`+ ueCollector->add_dl_nongbr_data_volume_ue(bytes);`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`void BaseStationStatsCollector::add_dl_nongbr_throughput_ue_perUser()`
`355`	`355`	`{`
`356`	`356`	`EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser" << endl;`
`357`	`357`	`double throughput;`
`358`		`- for (auto const& ue : ueCollectors_) {`
`359`		`- throughput = packetFlowManager_->getThroughputStatsPerUe(ue.first);`
`360`		`- EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ue.first << endl;`
`361`		`- packetFlowManager_->resetThroughputCounterPerUe(ue.first);`
	`358`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`359`	`+ throughput = packetFlowManager_->getThroughputStatsPerUe(ueId);`
	`360`	`+ EV << collectorType_ << "::add_dl_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ueId << endl;`
	`361`	`+ packetFlowManager_->resetThroughputCounterPerUe(ueId);`
`362`	`362`	`if (throughput > 0.0)`
`363`		`- ue.second->add_dl_nongbr_throughput_ue((int)throughput);`
	`363`	`+ ueCollector->add_dl_nongbr_throughput_ue((int)throughput);`
`364`	`364`	`}`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`void BaseStationStatsCollector::add_ul_nongbr_throughput_ue_perUser()`
`368`	`368`	`{`
`369`	`369`	`EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser" << endl;`
`370`	`370`	`double throughput;`
`371`		`- for (auto const& ue : ueCollectors_) {`
`372`		`- throughput = rlc_->getUeThroughput(ue.first);`
`373`		`- EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ue.first << endl;`
`374`		`- rlc_->resetThroughputStats(ue.first);`
	`371`	`+ for (auto const& [ueId, ueCollector] : ueCollectors_) {`
	`372`	`+ throughput = rlc_->getUeThroughput(ueId);`
	`373`	`+ EV << collectorType_ << "::add_ul_nongbr_throughput_ue_perUser - throughput: " << throughput << " for node " << ueId << endl;`
	`374`	`+ rlc_->resetThroughputStats(ueId);`
`375`	`375`	`if (throughput > 0.0)`
`376`		`- ue.second->add_ul_nongbr_throughput_ue((int)throughput);`
	`376`	`+ ueCollector->add_ul_nongbr_throughput_ue((int)throughput);`
`377`	`377`	`}`
`378`	`378`	`}`
`379`	`379`
Original file line number	Diff line number	Diff line change
`@@ -101,11 +101,11 @@ void LteAmc::printFbhb(Direction dir)`
`101`	`101`
`102`	`102`	`for (auto& [carrier, hist] : *history) { // for each antenna`
`103`	`103`	`EV << simTime() << " # Carrier: " << carrier << "\n";`
`104`		`- for (auto& histItem : hist) {`
`105`		`- EV << simTime() << " # Remote: " << dasToA(histItem.first) << "\n";`
`106`		`- for (size_t i = 0; i < histItem.second.size(); i++) { // for each UE`
	`104`	`+ for (auto& [remote, remoteHist] : hist) {`
	`105`	`+ EV << simTime() << " # Remote: " << dasToA(remote) << "\n";`
	`106`	`+ for (size_t i = 0; i < remoteHist.size(); i++) { // for each UE`
`107`	`107`	`EV << "Ue index: " << i << ", MacNodeId: " << (*revIndex)[i] << endl;`
`108`		`- auto& txVec = histItem.second[i];`
	`108`	`+ auto& txVec = remoteHist[i];`
`109`	`109`	`for (size_t t = 0; t < txVec.size(); t++) { // for each tx mode`
`110`	`110`	`TxMode txMode = TxMode(t);`
`111`	`111`
`@@ -1137,28 +1137,28 @@ void LteAmc::detachUser(MacNodeId nodeId, Direction dir)`
`1137`	`1137`
`1138`	`1138`	`// clear feedback data from history`
`1139`	`1139`	`if (dir == UL \|\| dir == DL) {`
`1140`		`- for (auto& hit : *history) {`
	`1140`	`+ for (auto& [carrierFreq, hist] : *history) {`
`1141`	`1141`	`for (auto remote : remoteSet_) {`
`1142`		`- hit.second.at(remote).at(nodeIndex).clear();`
	`1142`	`+ hist.at(remote).at(nodeIndex).clear();`
`1143`	`1143`	`}`
`1144`	`1144`	`}`
`1145`	`1145`	`}`
`1146`	`1146`	`else { // D2D`
`1147`		`- for (auto& hit : *d2dHistory) {`
`1148`		`- for (auto& ht : hit.second) {`
`1149`		`- if (ht.first == NODEID_NONE) // skip fake UE 0`
	`1147`	`+ for (auto& [carrierFreq, carrierHist] : *d2dHistory) {`
	`1148`	`+ for (auto& [peerId, peerHist] : carrierHist) {`
	`1149`	`+ if (peerId == NODEID_NONE) // skip fake UE 0`
`1150`	`1150`	`continue;`
`1151`	`1151`
`1152`	`1152`	`for (auto remote : remoteSet_) {`
`1153`		`- ht.second.at(remote).at(nodeIndex).clear();`
	`1153`	`+ peerHist.at(remote).at(nodeIndex).clear();`
`1154`	`1154`	`}`
`1155`	`1155`	`}`
`1156`	`1156`	`}`
`1157`	`1157`	`}`
`1158`	`1158`
`1159`	`1159`	`// clear user transmission parameters for this UE`
`1160`		`- for (auto& item : *userInfoVec) {`
`1161`		`- item.second.at(nodeIndex).restoreDefaultValues();`
	`1160`	`+ for (auto& [carrierFreq, txParams] : *userInfoVec) {`
	`1161`	`+ txParams.at(nodeIndex).restoreDefaultValues();`
`1162`	`1162`	`}`
`1163`	`1163`	`}`
`1164`	`1164`	`catch (std::exception& e) {`
Original file line number	Diff line number	Diff line change
`@@ -302,10 +302,10 @@ void PacketFlowManagerUe::insertMacPdu(inet::Ptr<const LteMacPdu> macPdu)`
`302`	`302`	`// set the pdcp pdus related to this RLC as sent over the air since this method is called after the MAC ID`
`303`	`303`	`// has been inserted in the HARQBuffer`
`304`	`304`	`SequenceNumberSet pdcpSet = tit->second;`
`305`		`- for (auto pit : pdcpSet) {`
`306`		`- auto sdit = desc->pdcpStatus_.find(pit);`
	`305`	`+ for (auto pdcpSno : pdcpSet) {`
	`306`	`+ auto sdit = desc->pdcpStatus_.find(pdcpSno);`
`307`	`307`	`if (sdit == desc->pdcpStatus_.end())`
`308`		`- throw cRuntimeError("%s::insertMacPdu - PdcpStatus for PDCP sno [%d] not present, this should not happen", pfmType.c_str(), pit);`
	`308`	`+ throw cRuntimeError("%s::insertMacPdu - PdcpStatus for PDCP sno [%d] not present, this should not happen", pfmType.c_str(), pdcpSno);`
`309`	`309`	`sdit->second.sentOverTheAir = true;`
`310`	`310`	`}`
`311`	`311`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,12 +167,11 @@ void NrPdcpEnb::receiveDataFromSourceNode(Packet *pkt, MacNodeId sourceNode)`
`167`	`167`
`168`	`168`	`void NrPdcpEnb::activeUeUL(std::set<MacNodeId> *ueSet)`
`169`	`169`	`{`
`170`		`- for (const auto& entity : rxEntities_) {`
`171`		`- MacNodeId nodeId = entity.first.getNodeId();`
`172`		`- if (!(entity.second->isEmpty()))`
	`170`	`+ for (const auto& [cid, rxEntity] : rxEntities_) {`
	`171`	`+ MacNodeId nodeId = cid.getNodeId();`
	`172`	`+ if (!(rxEntity->isEmpty()))`
`173`	`173`	`ueSet->insert(nodeId);`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`} //namespace`
`178`		`-`