all: refactor: methods made virtual

To allow overriding in subclasses.

DrbTable is left alone on purpose: it is a by-value member of NrSdap, so
it can never be substituted polymorphically and a vtable would buy nothing.

Also adds the virtual destructors that the newly polymorphic classes
need. ConflictGraph is a genuine fix rather than a precaution: it already had
pure virtual methods, and LteMacEnbD2D holds a DistanceBasedConflictGraph
through a ConflictGraph pointer, so destroying one was undefined behaviour.

RlcRetransmissionBuffer's destructor is made virtual along with it, as
the class becomes polymorphic here.

The four TR 38.901 path loss helpers in NrChannelModel_3GPP38_901 have
the same signatures as the ones in NrChannelModel and were hiding them; they are
marked override now that the base ones are virtual. This does not change
behaviour, because both classes override computePathLoss(), which is their only
caller. The same applies to getStdDev(), whose only caller computeShadowing() is
likewise overridden.

Note that computeLosProbability() is deliberately left non-virtual for
now: NrChannelModel_3GPP38_901 does not override getAttenuation(), so making
it virtual would genuinely change which LOS model runs, and needs its own
fix.

Author: avarga

src/simu5g/stack/compManager/LteCompManagerBase.h

@@ -76,11 +76,11 @@ class LteCompManagerBase : public cSimpleModule
 
   protected:
     static CompNodeType parseNodeType(const char *nodeType);
-    void runClientOperations();
-    void runCoordinatorOperations();
-    void handleX2Message(inet::Packet *pkt);
-    void sendClientRequest(X2CompRequestIE *requestIe);
-    void sendCoordinatorReply(X2NodeId clientId, X2CompReplyIE *replyIe);
+    virtual void runClientOperations();
+    virtual void runCoordinatorOperations();
+    virtual void handleX2Message(inet::Packet *pkt);
+    virtual void sendClientRequest(X2CompRequestIE *requestIe);
+    virtual void sendCoordinatorReply(X2NodeId clientId, X2CompReplyIE *replyIe);
 
     virtual void provisionalSchedule() = 0;  // run the provisional scheduling algorithm (client side)
     virtual void doCoordination() = 0;       // run the coordination algorithm (coordinator side)
@@ -91,7 +91,7 @@ class LteCompManagerBase : public cSimpleModule
     virtual X2CompReplyIE *buildCoordinatorReply(X2NodeId clientId) = 0;
     virtual void handleCoordinatorReply(inet::IntrusivePtr<X2CompMsg> compMsg) = 0;
 
-    void setUsableBands(UsableBands& usableBands);
+    virtual void setUsableBands(UsableBands& usableBands);
 
   public:
     void initialize(int stage) override;

src/simu5g/stack/compManager/compManagerProportional/LteCompManagerProportional.h

@@ -40,7 +40,7 @@ class LteCompManagerProportional : public LteCompManagerBase
     std::vector<unsigned int> offset_;
 
     // utility function: convert a vector of double to a vector of integer, preserving the sum of the elements
-    std::vector<unsigned int> roundVector(std::vector<double>& vec, int sum);
+    virtual std::vector<unsigned int> roundVector(std::vector<double>& vec, int sum);
 
     void provisionalSchedule() override;  // run the provisional scheduling algorithm (client side)
     void doCoordination() override;       // run the coordination algorithm (coordinator side)
@@ -51,7 +51,7 @@ class LteCompManagerProportional : public LteCompManagerBase
     X2CompProportionalReplyIE *buildCoordinatorReply(X2NodeId clientId) override;
     void handleCoordinatorReply(inet::Ptr<X2CompMsg> compMsg) override;
 
-    UsableBands parseAllowedBlocksMap(std::vector<CompRbStatus>& allowedBlocksMap);
+    virtual UsableBands parseAllowedBlocksMap(std::vector<CompRbStatus>& allowedBlocksMap);
 
   public:
 

src/simu5g/stack/dcX2Forwarder/DcX2Forwarder.h

@@ -38,7 +38,7 @@ class DcX2Forwarder : public cSimpleModule
     cGate *x2ManagerInGate_ = nullptr;
     cGate *x2ManagerOutGate_ = nullptr;
 
-    void handleX2Message(cMessage *msg);
+    virtual void handleX2Message(cMessage *msg);
 
   protected:
 
@@ -47,10 +47,10 @@ class DcX2Forwarder : public cSimpleModule
     void handleMessage(cMessage *msg) override;
 
     // send a PDCP PDU to the X2 Manager
-    void forwardDataToTargetNode(inet::Packet *pkt, MacNodeId targetNode);
+    virtual void forwardDataToTargetNode(inet::Packet *pkt, MacNodeId targetNode);
 
     // receive PDCP PDU from X2 Manager and send it to the PDCP layer
-    void receiveDataFromSourceNode(inet::Packet *pkt, MacNodeId sourceNode);
+    virtual void receiveDataFromSourceNode(inet::Packet *pkt, MacNodeId sourceNode);
 };
 
 } //namespace

src/simu5g/stack/handoverX2Forwarder/HandoverX2Forwarder.h

@@ -52,20 +52,20 @@ class HandoverX2Forwarder : public cSimpleModule
     int numInitStages() const override { return inet::NUM_INIT_STAGES; }
     void handleMessage(cMessage *msg) override;
 
-    void handleX2Message(cPacket *pkt);
+    virtual void handleX2Message(cPacket *pkt);
 
     // receive handover command on X2 from the source eNB
-    void receiveHandoverCommand(MacNodeId ueId, MacNodeId enb, bool startHo);
+    virtual void receiveHandoverCommand(MacNodeId ueId, MacNodeId enb, bool startHo);
 
     // send an IP datagram to the X2 Manager (called internally via gate)
-    void forwardDataToTargetEnb(inet::Packet *datagram, MacNodeId targetEnb);
+    virtual void forwardDataToTargetEnb(inet::Packet *datagram, MacNodeId targetEnb);
 
     // receive data from X2 message and send it to the HandoverPacketHolder
-    void receiveDataFromSourceEnb(inet::Packet *datagram, MacNodeId sourceEnb);
+    virtual void receiveDataFromSourceEnb(inet::Packet *datagram, MacNodeId sourceEnb);
 
   public:
     // send handover command on X2 to the eNB
-    void sendHandoverCommand(MacNodeId ueId, MacNodeId enb, bool startHo);
+    virtual void sendHandoverCommand(MacNodeId ueId, MacNodeId enb, bool startHo);
 
 };
 

src/simu5g/stack/ip2nic/HandoverPacketHolderEnb.h

@@ -57,12 +57,12 @@ class HandoverPacketHolderEnb : public cSimpleModule
 
   public:
     ~HandoverPacketHolderEnb() override;
-    void triggerHandoverSource(MacNodeId ueId, MacNodeId targetEnb);
-    void triggerHandoverTarget(MacNodeId ueId, MacNodeId sourceEnb);
-    void sendTunneledPacketOnHandover(inet::Packet *datagram, MacNodeId targetEnb);
-    void receiveTunneledPacketOnHandover(inet::Packet *datagram);
-    void signalHandoverCompleteSource(MacNodeId ueId, MacNodeId targetEnb);
-    void signalHandoverCompleteTarget(MacNodeId ueId, MacNodeId sourceEnb);
+    virtual void triggerHandoverSource(MacNodeId ueId, MacNodeId targetEnb);
+    virtual void triggerHandoverTarget(MacNodeId ueId, MacNodeId sourceEnb);
+    virtual void sendTunneledPacketOnHandover(inet::Packet *datagram, MacNodeId targetEnb);
+    virtual void receiveTunneledPacketOnHandover(inet::Packet *datagram);
+    virtual void signalHandoverCompleteSource(MacNodeId ueId, MacNodeId targetEnb);
+    virtual void signalHandoverCompleteTarget(MacNodeId ueId, MacNodeId sourceEnb);
 };
 
 } //namespace

src/simu5g/stack/ip2nic/HandoverPacketHolderUe.h

@@ -51,13 +51,13 @@ class HandoverPacketHolderUe : public cSimpleModule
     int numInitStages() const override { return inet::NUM_INIT_STAGES; }
     void handleMessage(cMessage *msg) override;
 
-    void fromIpUe(inet::Packet *datagram);
+    virtual void fromIpUe(inet::Packet *datagram);
     virtual void toStackUe(inet::Packet *datagram);
 
   public:
     ~HandoverPacketHolderUe() override;
-    void triggerHandoverUe(MacNodeId newMasterId, bool isNr = false);
-    void signalHandoverCompleteUe(bool isNr = false);
+    virtual void triggerHandoverUe(MacNodeId newMasterId, bool isNr = false);
+    virtual void signalHandoverCompleteUe(bool isNr = false);
 
     MacNodeId getServingNodeId() const { return servingNodeId_; }
     MacNodeId getNrServingNodeId() const { return nrServingNodeId_; }

src/simu5g/stack/ip2nic/Ip2Nic.h

@@ -116,20 +116,20 @@ class Ip2Nic : public cSimpleModule
     virtual void toStackUe(inet::Packet *datagram);
 
     // Packet analysis (moved from PDCP): classifies the packet and fills FlowControlInfo tag
-    void analyzePacket(inet::Packet *pkt, inet::Ipv4Address srcAddr, inet::Ipv4Address destAddr, uint16_t typeOfService);
-    MacNodeId getNextHopNodeId(const inet::Ipv4Address& destAddr, bool useNR, MacNodeId sourceId);
-    LteTrafficClass getTrafficCategory(cPacket *pkt);
-    LteRlcType getRlcType(LteTrafficClass trafficCategory);
-    DrbId lookupOrAssignDrbId(const ConnectionKey& key, const FlowControlInfo *lteInfo);
+    virtual void analyzePacket(inet::Packet *pkt, inet::Ipv4Address srcAddr, inet::Ipv4Address destAddr, uint16_t typeOfService);
+    virtual MacNodeId getNextHopNodeId(const inet::Ipv4Address& destAddr, bool useNR, MacNodeId sourceId);
+    virtual LteTrafficClass getTrafficCategory(cPacket *pkt);
+    virtual LteRlcType getRlcType(LteTrafficClass trafficCategory);
+    virtual DrbId lookupOrAssignDrbId(const ConnectionKey& key, const FlowControlInfo *lteInfo);
 
     // Establish the (duplex) bearer for the flow via the Binder, then register the
     // mirrored flow->DRB mapping at the peer's Ip2Nic so reverse application traffic
     // resolves to this bearer's reverse leg instead of allocating a new DRB.
-    void establishConnection(FlowControlInfo *lteInfo, const ConnectionKey& key);
+    virtual void establishConnection(FlowControlInfo *lteInfo, const ConnectionKey& key);
 
     // Called by a peer's Ip2Nic: bind an incoming flow key to the DRB of a bearer
     // established from the remote side (no-op if the key is already bound).
-    void registerDrbMapping(const ConnectionKey& key, DrbId drbId);
+    virtual void registerDrbMapping(const ConnectionKey& key, DrbId drbId);
 
   public:
     // Radio link failure handling is data-plane only here: BearerManagement (RRC) drives
@@ -138,10 +138,10 @@ class Ip2Nic : public cSimpleModule
 
     // Start dropping a peer's future DL/UL packets (UE Context Release). Its bearer
     // re-establishes on demand once resumeUe() is called.
-    void releaseUe(MacNodeId ueId);
+    virtual void releaseUe(MacNodeId ueId);
 
     // Stop dropping the peer's packets (RRC re-establishment complete); traffic resumes.
-    void resumeUe(MacNodeId ueId);
+    virtual void resumeUe(MacNodeId ueId);
 };
 
 } //namespace

src/simu5g/stack/mac/LteMacBase.h

@@ -188,7 +188,7 @@ class LteMacBase : public cSimpleModule
   protected:
 
     unsigned int getNumerologyPeriodCounter(NumerologyIndex index) { return numerologyPeriodCounter_[index].current; }
-    void decreaseNumerologyPeriodCounter();
+    virtual void decreaseNumerologyPeriodCounter();
 
   public:
 
@@ -249,7 +249,7 @@ class LteMacBase : public cSimpleModule
      * Extracts a MacCid from FlowControlInfo.
      * Converts DrbId (from PDCP/RLC) to LogicalCid (MAC layer).
      */
-    MacCid ctrlInfoToMacCid(const FlowControlInfo *info) {
+    virtual MacCid ctrlInfoToMacCid(const FlowControlInfo *info) {
         return MacCid(ctrlInfoToUeId(info), drbIdToLcid(info->getDrbId()));
     }
 
@@ -372,13 +372,13 @@ class LteMacBase : public cSimpleModule
         return false;
     }
 
-    void unregisterHarqBufferRx(MacNodeId nodeId);
+    virtual void unregisterHarqBufferRx(MacNodeId nodeId);
 
     // visualization
     void refreshDisplay() const override;
 
-    void recordHarqErrorRate(unsigned int sample, Direction dir);
-    double getHarqErrorRate(Direction dir);
+    virtual void recordHarqErrorRate(unsigned int sample, Direction dir);
+    virtual double getHarqErrorRate(Direction dir);
 
     /*
      * @author Alessandro Noferi
@@ -430,15 +430,15 @@ class LteMacBase : public cSimpleModule
      *
      * @param pkt Packet to send
      */
-    void sendLowerPackets(cPacket *pkt);
+    virtual void sendLowerPackets(cPacket *pkt);
 
     /**
      * sendUpperPackets() is used
      * to send packets to upper layer
      *
      * @param pkt Packet to send
      */
-    void sendUpperPackets(cPacket *pkt);
+    virtual void sendUpperPackets(cPacket *pkt);
 
     /*
      * Functions to be redefined by derived classes
@@ -519,7 +519,7 @@ class LteMacBase : public cSimpleModule
     virtual void updateUserTxParam(cPacket *pkt) = 0;
 
     /// Upper Layer Handler
-    void fromRlc(cPacket *pkt);
+    virtual void fromRlc(cPacket *pkt);
 
     /// Lower Layer Handler
     virtual void fromPhy(cPacket *pkt);