From e0c977cf7ecb4d03708c91a0fe7fc73fe8dcfc08 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 15 Apr 2017 18:45:11 -0700 Subject: [PATCH 001/551] wimax: Doxygen updates (mainly due to Robert Ammon) --- src/wimax/helper/wimax-helper.cc | 5 + src/wimax/helper/wimax-helper.h | 21 +- src/wimax/model/bandwidth-manager.h | 40 +- src/wimax/model/bs-link-manager.h | 83 ++- src/wimax/model/bs-net-device.h | 242 +++++++-- src/wimax/model/bs-scheduler-rtps.h | 35 +- src/wimax/model/bs-scheduler-simple.h | 21 +- src/wimax/model/bs-scheduler.h | 33 +- src/wimax/model/bs-service-flow-manager.h | 43 +- src/wimax/model/bs-uplink-scheduler-mbqos.h | 106 +++- src/wimax/model/bs-uplink-scheduler-rtps.h | 82 ++- src/wimax/model/bs-uplink-scheduler-simple.h | 59 +- src/wimax/model/bs-uplink-scheduler.h | 139 ++++- src/wimax/model/burst-profile-manager.h | 44 +- src/wimax/model/bvec.h | 1 + src/wimax/model/cid-factory.h | 32 +- src/wimax/model/cid.cc | 18 + src/wimax/model/cid.h | 13 +- src/wimax/model/connection-manager.h | 31 +- src/wimax/model/crc8.cc | 1 + src/wimax/model/cs-parameters.h | 7 +- src/wimax/model/dl-mac-messages.h | 369 ++++++++++--- src/wimax/model/ipcs-classifier-record.h | 59 +- src/wimax/model/ipcs-classifier.h | 4 + src/wimax/model/mac-messages.h | 377 +++++++++---- src/wimax/model/ofdm-downlink-frame-prefix.h | 125 ++++- src/wimax/model/send-params.h | 29 +- src/wimax/model/service-flow-manager.h | 37 +- src/wimax/model/service-flow-record.h | 107 +++- src/wimax/model/service-flow.h | 509 +++++++++++++++--- src/wimax/model/simple-ofdm-send-param.h | 39 +- src/wimax/model/simple-ofdm-wimax-channel.h | 24 +- src/wimax/model/simple-ofdm-wimax-phy.h | 259 +++++++-- .../model/snr-to-block-error-rate-manager.h | 8 +- .../model/snr-to-block-error-rate-record.h | 12 +- src/wimax/model/ss-link-manager.h | 143 ++++- src/wimax/model/ss-manager.h | 51 +- src/wimax/model/ss-net-device.cc | 4 +- src/wimax/model/ss-net-device.h | 210 +++++--- src/wimax/model/ss-record.h | 186 ++++++- src/wimax/model/ss-scheduler.h | 28 +- src/wimax/model/ss-service-flow-manager.h | 56 +- src/wimax/model/ul-job.cc | 6 + src/wimax/model/ul-job.h | 146 ++++- src/wimax/model/ul-mac-messages.h | 406 +++++++++++--- src/wimax/model/wimax-channel.h | 19 + src/wimax/model/wimax-connection.h | 47 +- src/wimax/model/wimax-mac-header.h | 305 +++++++++-- src/wimax/model/wimax-mac-queue.h | 166 ++++-- src/wimax/model/wimax-mac-to-mac-header.h | 15 +- src/wimax/model/wimax-net-device.h | 312 +++++++++-- src/wimax/model/wimax-phy.h | 204 +++++-- src/wimax/model/wimax-tlv.h | 250 ++++++++- src/wimax/test/mac-messages-test.cc | 23 +- src/wimax/test/phy-test.cc | 37 +- src/wimax/test/qos-test.cc | 33 +- src/wimax/test/ss-mac-test.cc | 24 +- src/wimax/test/wimax-fragmentation-test.cc | 16 +- src/wimax/test/wimax-service-flow-test.cc | 16 +- src/wimax/test/wimax-tlv-test.cc | 24 +- 60 files changed, 4847 insertions(+), 894 deletions(-) diff --git a/src/wimax/helper/wimax-helper.cc b/src/wimax/helper/wimax-helper.cc index 341844bfbd2..0819f77a6d6 100644 --- a/src/wimax/helper/wimax-helper.cc +++ b/src/wimax/helper/wimax-helper.cc @@ -545,6 +545,11 @@ WimaxHelper::EnableAsciiInternal (Ptr stream, } +/** + * \brief print pcap record + * \param file pcap file + * \param burst packet burst to print + */ static void PcapSniffTxRxEvent (Ptr file, Ptr burst) { diff --git a/src/wimax/helper/wimax-helper.h b/src/wimax/helper/wimax-helper.h index 9a918fcfb43..ee7bcc17510 100644 --- a/src/wimax/helper/wimax-helper.h +++ b/src/wimax/helper/wimax-helper.h @@ -142,6 +142,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice * \param type device type to create * \param phyType a phy to use * \param schedulerType the type of the scheduling algorithm to install + * \return NetDeviceContainer * * For each of the input nodes, a new WiMAX net device (either * ns3::SubscriberStationNetDevice or ns3::BaseStationNetDevice @@ -155,6 +156,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice * \param phyType PHY type to create. * \param channel A channel to use. * \param schedulerType The scheduling mechanism. + * \return NetDeviceContainer * * For each of the input nodes, a new WiMAX net device (either * ns3::SubscriberStationNetDevice or ns3::BaseStationNetDevice @@ -171,6 +173,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice * \param phyType PHY type to create. * \param schedulerType The scheduling mechanism. * \param frameDuration the farme duration in seconds + * \return NetDeviceContainer * * For each of the input nodes, a new WiMAX net device (either * ns3::SubscriberStationNetDevice or ns3::BaseStationNetDevice @@ -222,6 +225,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice * \param phyType PHY type to create. * \param channel A channel to use. * \param schedulerType The scheduling mechanism to install on the device. + * \return Ptr * * For each of the input nodes, a new WiMAX net device (either * ns3::SubscriberStationNetDevice or ns3::BaseStationNetDevice @@ -238,6 +242,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice * \param direction the direction of the service flow: UP or DOWN. * \param schedulinType The service scheduling type to be used: UGS, RTPS, NRTPS, BE * \param classifier The classifier to be used for this service flow + * \return ServiceFlow * */ ServiceFlow CreateServiceFlow (ServiceFlow::Direction direction, @@ -273,7 +278,21 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice int64_t AssignStreams (NetDeviceContainer c, int64_t stream); private: + /** + * ASCII trace receive event + * \param stream the output stream + * \param path the path name + * \param packet the packet + * \param source the source MAC address + */ static void AsciiRxEvent (Ptr stream, std::string path, Ptr packet, const Mac48Address &source); + /** + * ASCII trace transmit event + * \param stream the output stream + * \param path the path + * \param packet the packet + * \param dest the destination MAC address + */ static void AsciiTxEvent (Ptr stream, std::string path, Ptr packet, const Mac48Address &dest); /** * \brief Enable pcap output on the indicated net device. @@ -304,7 +323,7 @@ class WimaxHelper : public PcapHelperForDevice, public AsciiTraceHelperForDevice Ptr nd, bool explicitFilename); - Ptr m_channel; + Ptr m_channel; ///< wifi channel }; } // namespace ns3 diff --git a/src/wimax/model/bandwidth-manager.h b/src/wimax/model/bandwidth-manager.h index 8e1c726f981..2fbe9904de1 100644 --- a/src/wimax/model/bandwidth-manager.h +++ b/src/wimax/model/bandwidth-manager.h @@ -54,23 +54,59 @@ class UplinkScheduler; class BandwidthManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param device WIMAX device + */ BandwidthManager (Ptr device); ~BandwidthManager (void); void DoDispose (void); + /** + * Calculate allocation size function + * \param ssRecord the SS record + * \param serviceFlow the service flow + * \returns the allocation size + */ uint32_t CalculateAllocationSize (const SSRecord *ssRecord, const ServiceFlow *serviceFlow); + /** + * Select flow for request function + * \param bytesToRequest bytes to request + * \returns a service flow + */ ServiceFlow* SelectFlowForRequest (uint32_t &bytesToRequest); + /** + * Send bandwidth request + * \param uiuc the UIUC + * \param allocationSize the allocation size + */ void SendBandwidthRequest (uint8_t uiuc, uint16_t allocationSize); + /** + * Process bandwidth request + * \param bwRequestHdr the bandwidth request + */ void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr); + /// Set subframe ratio void SetSubframeRatio (void); + /** + * Get symbols per frame allocated + * \returns the symbols per the frame allocated + */ uint32_t GetSymbolsPerFrameAllocated (void); private: + /// Bandwidth manager type conversion operator BandwidthManager (const BandwidthManager &); + /// Bandwidth manager assignement operator BandwidthManager& operator= (const BandwidthManager &); - Ptr m_device; - uint16_t m_nrBwReqsSent; + Ptr m_device; ///< the device + uint16_t m_nrBwReqsSent; ///< bandwith requests sent }; } // namespace ns3 diff --git a/src/wimax/model/bs-link-manager.h b/src/wimax/model/bs-link-manager.h index 9c73a6f3df0..7747011e3f9 100644 --- a/src/wimax/model/bs-link-manager.h +++ b/src/wimax/model/bs-link-manager.h @@ -38,7 +38,16 @@ namespace ns3 { class BSLinkManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param bs base station device + */ BSLinkManager (Ptr bs); ~BSLinkManager (void); /** @@ -61,31 +70,97 @@ class BSLinkManager : public Object */ void VerifyInvitedRanging (Cid cid, uint8_t uiuc); private: + /// copy constructor (disabled) BSLinkManager (const BSLinkManager &); + /// assignment operator (disabled) BSLinkManager & operator= (const BSLinkManager &); + /** + * Perform ranging function + * \param cid the CID + * \param rngreq the ranging request + */ void PerformRanging (Cid cid, RngReq rngreq); + /** + * Perform initial ranging function + * \param cid the CID + * \param rngreq the ranging request + * \param rngrsp the ranging response + */ void PerformInitialRanging (Cid cid, RngReq *rngreq, RngRsp *rngrsp); + /** + * Perform inivted ranging function + * \param cid the CID + * \param rngrsp the ranging response + */ void PerformInvitedRanging (Cid cid, RngRsp *rngrsp); + /** + * Set parameters to adjust function + * \param rngrsp the ranging response + */ void SetParametersToAdjust (RngRsp *rngrsp); + /** + * Abort ranging function + * \param cid the CID + * \param rngrsp the ranging response + * \param ssRecord the SS record + * \param isNewSS true if a new SS + */ void AbortRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord, bool isNewSS); + /** + * Accept ranging function + * \param cid the CID + * \param rngrsp the ranging response + * \param ssRecord the SS record + */ void AcceptRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord); + /** + * Continue ranging function + * \param cid the CID + * \param rngrsp the ranging response + * \param ssRecord the SS record + */ void ContinueRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord); + /** + * Schedule range response message function + * \param cid the CID + * \param rngrsp the ranging response + */ void ScheduleRngRspMessage (Cid cid, RngRsp *rngrsp); + /** + * Deallocate CIDs function + * \param cid the CID + */ void DeallocateCids (Cid cid); + /** + * Change DL channel function + * \returns true if the DL channel changed + */ bool ChangeDlChannel (void); + /** + * Get new DL channel function + * \returns the new DL channel + */ uint32_t GetNewDlChannel (void); + /** + * Get signal quality function + * \returns the signal quality + */ uint8_t GetSignalQuality (void); + /** + * Is ranging acceptable function + * \returns true if ranging is acceptable + */ bool IsRangingAcceptable (void); - Ptr m_bs; + Ptr m_bs; ///< base station // ranging parameters - uint32_t m_signalQuality; - uint8_t m_signalQualityThreshold; - int tries; // variable to test multiple RNG-REQ by the SS for example undecodable at BS or lost RNG-RSP + uint32_t m_signalQuality; ///< signal quality + uint8_t m_signalQualityThreshold; ///< signal quality threshold + int tries; ///< variable to test multiple RNG-REQ by the SS for example undecodable at BS or lost RNG-RSP }; } // namespace ns3 diff --git a/src/wimax/model/bs-net-device.h b/src/wimax/model/bs-net-device.h index 5ef70964e6a..187217ae369 100644 --- a/src/wimax/model/bs-net-device.h +++ b/src/wimax/model/bs-net-device.h @@ -50,26 +50,50 @@ class BsServiceFlowManager; class BaseStationNetDevice : public WimaxNetDevice { public: + /// State enumeration enum State { - BS_STATE_DL_SUB_FRAME, BS_STATE_UL_SUB_FRAME, BS_STATE_TTG, BS_STATE_RTG + BS_STATE_DL_SUB_FRAME, + BS_STATE_UL_SUB_FRAME, + BS_STATE_TTG, + BS_STATE_RTG }; + /// MacPreamble enumeration enum MacPreamble { - SHORT_PREAMBLE = 1, LONG_PREAMBLE + SHORT_PREAMBLE = 1, + LONG_PREAMBLE }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); BaseStationNetDevice (void); + /** + * Constructor + * + * \param node the node + * \param phy the wimax phy + */ BaseStationNetDevice (Ptr node, Ptr phy); + /** + * Constructor + * + * \param node the node + * \param phy the wimax phy + * \param uplinkScheduler uplink scheduler + * \param bsScheduler bs scheduler + */ BaseStationNetDevice (Ptr node, Ptr phy, Ptr uplinkScheduler, Ptr bsScheduler); ~BaseStationNetDevice (void); /** - * \param initialRangInterval Time between Initial Ranging regions assigned by the BS + * \param initialRangInterval Time between initial ranging regions assigned by the BS */ void SetInitialRangingInterval (Time initialRangInterval); /** @@ -77,7 +101,7 @@ class BaseStationNetDevice : public WimaxNetDevice */ void InitBaseStationNetDevice (void); /** - * \returns Time between Initial Ranging regions assigned by the BS + * \returns Time between initial ranging regions assigned by the BS */ Time GetInitialRangingInterval (void) const; /** @@ -160,9 +184,17 @@ class BaseStationNetDevice : public WimaxNetDevice * \returns the number ucd messages already sent */ uint32_t GetNrUcdSent (void) const; - + /** + * \returns the DL subframe start time + */ Time GetDlSubframeStartTime (void) const; + /** + * \returns the UL subframe start time + */ Time GetUlSubframeStartTime (void) const; + /** + * \returns the ranging opp number + */ uint8_t GetRangingOppNumber (void) const; /** * \returns a pointer to the SS manager @@ -192,7 +224,6 @@ class BaseStationNetDevice : public WimaxNetDevice * \returns The BS scheduler installed on the BS */ Ptr GetBSScheduler (void) const; - /** * \param linkManager The link manager installed on the BS */ @@ -206,35 +237,92 @@ class BaseStationNetDevice : public WimaxNetDevice */ void SetBsClassifier (Ptr classifier); + /** + * \returns PS duration + */ Time GetPsDuration (void) const; + /** + * \returns symbol duration + */ Time GetSymbolDuration (void) const; - + /** + * \brief Start device + */ void Start (void); + /** + * \brief Stop device + */ void Stop (void); /** * \brief Enqueue a packet into a connection queue * \param packet the packet to be enqueued * \param hdrType the mac header type to be appended to the packet * \param connection the connection to be used + * \return true if successful */ bool Enqueue (Ptr packet, const MacHeaderType &hdrType, Ptr connection); + /** + * \param cid connection ID + * \returns a pointer to the connection + */ Ptr GetConnection (Cid cid); + /** + * \brief Mark uplink allocations + */ void MarkUplinkAllocations (void); + /** + * \brief Mark ranging opp start + * \param rangingOppStartTime start time + */ void MarkRangingOppStart (Time rangingOppStartTime); - + /** + * \returns service flow manager + */ Ptr GetServiceFlowManager (void) const; + /** + * \brief Set service flow manager + */ void SetServiceFlowManager (Ptr ); private: - void DoDispose (void); + virtual void DoDispose (void); + /** + * \brief Start frame function + */ void StartFrame (void); + /** + * \brief Start DL subframe function + */ void StartDlSubFrame (void); + /** + * \brief End DL subframe function + */ void EndDlSubFrame (void); + /** + * \brief Start UL subframe function + */ void StartUlSubFrame (void); + /** + * \brief End UL subframe function + */ void EndUlSubFrame (void); + /** + * \brief End frame function + */ void EndFrame (void); - + /** + * \brief Send packet + * \param packet to send + * \param source MAC address + * \param dest destination MAC address + * \param protocolNumber protocol number + * \returns true if successful + */ bool DoSend (Ptr packet, const Mac48Address& source, const Mac48Address& dest, uint16_t protocolNumber); + /** + * \brief Receive packet + * \param packet to send + */ void DoReceive (Ptr packet); /** * \brief creates the MAC management messages DL-MAP and UL-MAP @@ -244,79 +332,127 @@ class BaseStationNetDevice : public WimaxNetDevice * \brief creates the channel descriptor MAC management messages DCD and UCD */ void CreateDescriptorMessages (bool sendDcd, bool senUcd); + /** + * \brief Send burst function + */ void SendBursts (void); + /** + * \brief Create DL map + * \returns packet + */ Ptr CreateDlMap (void); + /** + * \brief Create DCD + * \returns packet + */ Ptr CreateDcd (void); + /** + * \brief Create UL map + * \returns packet + */ Ptr CreateUlMap (void); + /** + * \brief Create UCD + * \returns packet + */ Ptr CreateUcd (void); + /** + * \brief Send DL burst profiles + * \param dcd burst profile + */ void SetDlBurstProfiles (Dcd *dcd); + /** + * \brief Send UL burst profiles + * \param ucd burst profile + */ void SetUlBurstProfiles (Ucd *ucd); + /** + * \brief Mark uplink allocation start + * \param allocationStartTime allocation start time + */ void MarkUplinkAllocationStart (Time allocationStartTime); + /** + * \brief Mark uplink allocation end + * \param allocationEndTime allocation end time + * \param cid connection ID + * \param uiuc + */ void MarkUplinkAllocationEnd (Time allocationEndTime, Cid cid, uint8_t uiuc); + /** + * \brief Uplink allocation start + */ void UplinkAllocationStart (void); + /** + * \brief Uplink allocation end + * \param cid connection ID + * \param uiuc + */ void UplinkAllocationEnd (Cid cid, uint8_t uiuc); + /** + * \brief Ranging opp start + */ void RangingOppStart (void); // parameters defined in Table 342 - Time m_initialRangInterval; // in seconds - Time m_dcdInterval; // in seconds - Time m_ucdInterval; // in seconds - Time m_intervalT8; // in milliseconds, wait for DSA/DSC Acknowledge timeout + Time m_initialRangInterval; ///< in seconds + Time m_dcdInterval; ///< in seconds + Time m_ucdInterval; ///< in seconds + Time m_intervalT8; ///< in milliseconds, wait for DSA/DSC Acknowledge timeout - uint8_t m_maxRangCorrectionRetries; - uint8_t m_maxInvitedRangRetries; - uint8_t m_rangReqOppSize; // in symbols - uint8_t m_bwReqOppSize; // in symbols + uint8_t m_maxRangCorrectionRetries; ///< maximum range correction retries + uint8_t m_maxInvitedRangRetries; ///< maximum invited range retries + uint8_t m_rangReqOppSize; ///< in symbols + uint8_t m_bwReqOppSize; ///< in symbols - uint32_t m_nrDlSymbols; - uint32_t m_nrUlSymbols; + uint32_t m_nrDlSymbols; ///< number of DL symbols + uint32_t m_nrUlSymbols; ///< number of UL symbols // to keep track total number of a certain management messages sent by the BS - uint32_t m_nrDlMapSent; - uint32_t m_nrUlMapSent; + uint32_t m_nrDlMapSent; ///< number DL map sent + uint32_t m_nrUlMapSent; ///< number UL map sent // number of DCDs and UCDs sent even if same - uint32_t m_nrDcdSent; - uint32_t m_nrUcdSent; + uint32_t m_nrDcdSent; ///< number DCD sent + uint32_t m_nrUcdSent; ///< number UCD sent - uint32_t m_dcdConfigChangeCount; - uint32_t m_ucdConfigChangeCount; + uint32_t m_dcdConfigChangeCount; ///< DCD config change count + uint32_t m_ucdConfigChangeCount; ///< UCD config change count - uint32_t m_framesSinceLastDcd; - uint32_t m_framesSinceLastUcd; + uint32_t m_framesSinceLastDcd; ///< frames since last DCD + uint32_t m_framesSinceLastUcd; ///< frames since last UCD // uint32_t m_nrFrames; //temporarily defined in wimax-net-device, as static - uint32_t m_nrDlFrames; - uint32_t m_nrUlFrames; + uint32_t m_nrDlFrames; ///< number DL frames + uint32_t m_nrUlFrames; ///< number UL frames // to keep track if number of SSs have changed since the last frame - uint16_t m_nrSsRegistered; + uint16_t m_nrSsRegistered; ///< number SS registered - uint16_t m_nrDlAllocations; - uint16_t m_nrUlAllocations; + uint16_t m_nrDlAllocations; ///< number DL allocations + uint16_t m_nrUlAllocations; ///< number UL allocations - Time m_dlSubframeStartTime; - Time m_ulSubframeStartTime; + Time m_dlSubframeStartTime; ///< DL subframe start time + Time m_ulSubframeStartTime; ///< UL subframe start time - uint8_t m_ulAllocationNumber; // to see UL burst number - uint8_t m_rangingOppNumber; // current ranging TO number + uint8_t m_ulAllocationNumber; ///< to see UL burst number + uint8_t m_rangingOppNumber; ///< current ranging TO number - CidFactory *m_cidFactory; + CidFactory *m_cidFactory; ///< the CID factory - uint32_t m_allocationStartTime; + uint32_t m_allocationStartTime; ///< allocation start time - Ptr m_ssManager; - Ptr m_uplinkScheduler; - Ptr m_scheduler; - Ptr m_linkManager; - Ptr m_bsClassifier; - Ptr m_serviceFlowManager; + Ptr m_ssManager; ///< the SS manager + Ptr m_uplinkScheduler; ///< the uplink scheduler + Ptr m_scheduler; ///< the base station scheduler + Ptr m_linkManager; ///< the link manager + Ptr m_bsClassifier; ///< the base station classifier + Ptr m_serviceFlowManager; ///< the service flow manager // same fields as in PHY, for quick access - Time m_psDuration; - Time m_symbolDuration; + Time m_psDuration; ///< ps duration + Time m_symbolDuration; ///< symbol duration - TracedCallback, Mac48Address, Cid> m_traceBSRx; + TracedCallback, Mac48Address, Cid> m_traceBSRx; ///< the base station receive trace callback /** * The trace source fired when packets come into the "top" of the device @@ -324,7 +460,7 @@ class BaseStationNetDevice : public WimaxNetDevice * * \see class CallBackTraceSource */ - TracedCallback > m_bsTxTrace; + TracedCallback > m_bsTxTrace; ///< the base station transmit trace callback /** * The trace source fired when packets coming into the "top" of the device @@ -332,7 +468,7 @@ class BaseStationNetDevice : public WimaxNetDevice * * \see class CallBackTraceSource */ - TracedCallback > m_bsTxDropTrace; + TracedCallback > m_bsTxDropTrace; ///< base station transmit drop trace callback /** * The trace source fired for packets successfully received by the device @@ -341,7 +477,7 @@ class BaseStationNetDevice : public WimaxNetDevice * * \see class CallBackTraceSource */ - TracedCallback > m_bsPromiscRxTrace; + TracedCallback > m_bsPromiscRxTrace; ///< base station promiscious receive trace callback /** * The trace source fired for packets successfully received by the device @@ -350,7 +486,7 @@ class BaseStationNetDevice : public WimaxNetDevice * * \see class CallBackTraceSource */ - TracedCallback > m_bsRxTrace; + TracedCallback > m_bsRxTrace; ///< base station receive trace callback /** * The trace source fired when packets coming into the "top" of the device @@ -358,7 +494,7 @@ class BaseStationNetDevice : public WimaxNetDevice * * \see class CallBackTraceSource */ - TracedCallback > m_bsRxDropTrace; + TracedCallback > m_bsRxDropTrace; ///< base station receive drop trace callback }; } // namespace ns3 diff --git a/src/wimax/model/bs-scheduler-rtps.h b/src/wimax/model/bs-scheduler-rtps.h index 8b6a94a2417..7121ab14b50 100644 --- a/src/wimax/model/bs-scheduler-rtps.h +++ b/src/wimax/model/bs-scheduler-rtps.h @@ -59,12 +59,21 @@ class BSSchedulerRtps : public BSScheduler { public: BSSchedulerRtps (); + /** + * Constructor + * + * \param bs base station device + */ BSSchedulerRtps (Ptr bs); ~BSSchedulerRtps (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); - /* + /** * \brief This function returns all the downlink bursts scheduled for the next * downlink sub-frame * \returns all the downlink bursts scheduled for the next downlink sub-frame @@ -72,7 +81,7 @@ class BSSchedulerRtps : public BSScheduler std::list > >* GetDownlinkBursts (void) const; - /* + /** * \brief This function adds a downlink burst to the list of downlink bursts * scheduled for the next downlink sub-frame * \param connection a pointer to connection in wich the burst will be sent @@ -107,6 +116,8 @@ class BSSchedulerRtps : public BSScheduler * * The method return the UGS connection that have packets to transmits, * according to the MaxLatency specifications. + * \param connection will point to a connection that have packets to be sent + * \return true if successful */ bool SelectUGSConnection (Ptr &connection); /** @@ -122,37 +133,37 @@ class BSSchedulerRtps : public BSScheduler */ bool SelectBEConnection (Ptr &connection); - /* + /** * \brief Selects a connection from the list of connections having packets to be sent . * \param connection will point to a connection that have packets to be sent * \returns false if no connection has packets to be sent, true otherwise */ bool SelectConnection (Ptr &connection); - /* + /** * \brief schedules the broadcast connections * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerBroadcastConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the IR connections * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerInitialRangingConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the basic connections * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerBasicConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the primary connection * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerPrimaryConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the UGS connection * \param availableSymbols the remaining free OFDM symbols in the current subframe */ @@ -174,19 +185,19 @@ class BSSchedulerRtps : public BSScheduler */ void BSSchedulerRTPSConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the NRTPS connections * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerNRTPSConnection (uint32_t &availableSymbols); - /* + /** * \brief schedules the BE connection * \param availableSymbols the remaining free OFDM symbols in the current subframe */ void BSSchedulerBEConnection (uint32_t &availableSymbols); - /* + /** * \brief Creates a downlink UGS burst * \param serviceFlow the service flow of the burst * \param modulationType the modulation type to be used for the burst @@ -197,7 +208,7 @@ class BSSchedulerRtps : public BSScheduler WimaxPhy::ModulationType modulationType, uint32_t availableSymbols); private: - std::list > > *m_downlinkBursts; + std::list > > *m_downlinkBursts; ///< down link bursts }; } // namespace ns3 diff --git a/src/wimax/model/bs-scheduler-simple.h b/src/wimax/model/bs-scheduler-simple.h index eeaca2c9d20..d7abf3132b6 100644 --- a/src/wimax/model/bs-scheduler-simple.h +++ b/src/wimax/model/bs-scheduler-simple.h @@ -44,19 +44,28 @@ class BSSchedulerSimple : public BSScheduler { public: BSSchedulerSimple (); + /** + * Constructor + * + * \param bs base station device + */ BSSchedulerSimple (Ptr bs); ~BSSchedulerSimple (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); - /* + /** * \brief This function returns all the downlink bursts scheduled for the next * downlink sub-frame * \returns all the downlink bursts scheduled for the next downlink sub-frame */ std::list > >* GetDownlinkBursts (void) const; - /* + /** * \brief This function adds a downlink burst to the list of downlink bursts * scheduled for the next downlink sub-frame * \param connection a pointer to connection in wich the burst will be sent @@ -67,17 +76,17 @@ class BSSchedulerSimple : public BSScheduler void AddDownlinkBurst (Ptr connection, uint8_t diuc, WimaxPhy::ModulationType modulationType, Ptr burst); - /* + /** * \brief the scheduling function for the downlink subframe. */ void Schedule (void); - /* + /** * \brief Selects a connection from the list of connections having packets to be sent . * \param connection will point to a connection that have packets to be sent * \returns false if no connection has packets to be sent, true otherwise */ bool SelectConnection (Ptr &connection); - /* + /** * \brief Creates a downlink UGS burst * \param serviceFlow the service flow of the burst * \param modulationType the modulation type to be used for the burst @@ -88,7 +97,7 @@ class BSSchedulerSimple : public BSScheduler WimaxPhy::ModulationType modulationType, uint32_t availableSymbols); private: - std::list > > *m_downlinkBursts; + std::list > > *m_downlinkBursts; ///< down link bursts }; } // namespace ns3 diff --git a/src/wimax/model/bs-scheduler.h b/src/wimax/model/bs-scheduler.h index 3e616709879..cba8638acd8 100644 --- a/src/wimax/model/bs-scheduler.h +++ b/src/wimax/model/bs-scheduler.h @@ -44,19 +44,28 @@ class BSScheduler : public Object { public: BSScheduler (); + /** + * Constructor + * + * \param bs base station device + */ BSScheduler (Ptr bs); ~BSScheduler (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); - /* + /** * \brief This function returns all the downlink bursts scheduled for the next * downlink sub-frame * \returns all the downlink bursts scheduled for the next downlink sub-frame */ virtual std::list > >* GetDownlinkBursts (void) const = 0; - /* + /** * \brief This function adds a downlink burst to the list of downlink bursts * scheduled for the next downlink sub-frame * \param connection a pointer to connection in wich the burst will be sent @@ -69,18 +78,18 @@ class BSScheduler : public Object WimaxPhy::ModulationType modulationType, Ptr burst) = 0; - /* + /** * \brief the scheduling function for the downlink subframe. */ virtual void Schedule (void) = 0; - /* + /** * \brief Selects a connection from the list of connections having packets to be sent . * \param connection will point to a connection that have packets to be sent * \returns false if no connection has packets to be sent, true otherwise */ virtual bool SelectConnection (Ptr &connection) = 0; - /* + /** * \brief Creates a downlink UGS burst * \param serviceFlow the service flow of the burst * \param modulationType the modulation type to be used for the burst @@ -91,10 +100,18 @@ class BSScheduler : public Object WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) = 0; + /** + * \brief Get the base station. + * \returns the base station net device + */ virtual Ptr GetBs (void); + /** + * \brief Set the base station. + * \param bs the base station net device + */ virtual void SetBs (Ptr bs); - /* + /** * \brief Check if the packet fragmentation is possible for transport connection. * \param connection the downlink connection * \param availableSymbols maximum number of OFDM symbols to be used by the burst @@ -105,8 +122,8 @@ class BSScheduler : public Object int availableSymbols, WimaxPhy::ModulationType modulationType); private: - Ptr m_bs; - std::list > > *m_downlinkBursts; + Ptr m_bs; ///< base station + std::list > > *m_downlinkBursts; ///< down link bursts }; } // namespace ns3 diff --git a/src/wimax/model/bs-service-flow-manager.h b/src/wimax/model/bs-service-flow-manager.h index b2618f80474..02aee2cb691 100644 --- a/src/wimax/model/bs-service-flow-manager.h +++ b/src/wimax/model/bs-service-flow-manager.h @@ -39,15 +39,22 @@ class BaseStationNetDevice; /** * \ingroup wimax + * \brief BsServiceFlowManager */ class BsServiceFlowManager : public ServiceFlowManager { public: + /// Confirmation code enumeration enum ConfirmationCode // as per Table 384 (not all codes implemented) { CONFIRMATION_CODE_SUCCESS, CONFIRMATION_CODE_REJECT }; + /** + * Constructor + * + * \param device base station device + */ BsServiceFlowManager (Ptr device); ~BsServiceFlowManager (void); void DoDispose (void); @@ -63,24 +70,35 @@ class BsServiceFlowManager : public ServiceFlowManager */ void AddServiceFlow (ServiceFlow *serviceFlow); /** + * \param sfid the service flow identifier * \return the service flow which has as identifier sfid */ ServiceFlow* GetServiceFlow (uint32_t sfid) const; /** + * \param cid the connection identifier * \return the service flow which has as connection identifier cid */ ServiceFlow* GetServiceFlow (Cid cid) const; /** + * \param schedulingType the scheduling type * \return the list of service flows configured with schedulingType as a QoS class */ std::vector GetServiceFlows (ServiceFlow::SchedulingType schedulingType) const; /** * \brief set the maximum Dynamic ServiceFlow Add (DSA) retries + * \param maxDsaRspRetries the maximum DSA response retries */ void SetMaxDsaRspRetries (uint8_t maxDsaRspRetries); + /** + * \return the DSA ack timeout event + */ EventId GetDsaAckTimeoutEvent (void) const; - + /** + * \brief allocate service flows + * \param dsaReq the DSA request + * \param cid the connection identifier + */ void AllocateServiceFlows (const DsaReq &dsaReq, Cid cid); /** * \brief add a multicast service flow @@ -97,18 +115,31 @@ class BsServiceFlowManager : public ServiceFlowManager * \brief process a DSA-Req message * \param dsaReq the message to process * \param cid the identifier of the connection on which the message was received + * \return a pointer to the service flow */ ServiceFlow* ProcessDsaReq (const DsaReq &dsaReq, Cid cid); private: + /** + * Create DSA response function + * \param serviceFlow service flow + * \param transactionId transaction ID + * \return the DSA response + */ DsaRsp CreateDsaRsp (const ServiceFlow *serviceFlow, uint16_t transactionId); + /** + * \return the maximum DSA response retries + */ uint8_t GetMaxDsaRspRetries (void) const; + /** + * Create DSA response function + */ void ScheduleDsaRsp (ServiceFlow *serviceFlow, Cid cid); - Ptr m_device; - uint32_t m_sfidIndex; - uint8_t m_maxDsaRspRetries; - EventId m_dsaAckTimeoutEvent; - Cid m_inuseScheduleDsaRspCid; + Ptr m_device; ///< the device + uint32_t m_sfidIndex; ///< SFID index + uint8_t m_maxDsaRspRetries; ///< maximum number of DSA response retries + EventId m_dsaAckTimeoutEvent; ///< DSA ack timeout event + Cid m_inuseScheduleDsaRspCid; ///< in use schedule DSA response CID }; } // namespace ns3 diff --git a/src/wimax/model/bs-uplink-scheduler-mbqos.h b/src/wimax/model/bs-uplink-scheduler-mbqos.h index 87bc93f8424..2976d060862 100644 --- a/src/wimax/model/bs-uplink-scheduler-mbqos.h +++ b/src/wimax/model/bs-uplink-scheduler-mbqos.h @@ -70,44 +70,113 @@ class UplinkSchedulerMBQoS : public UplinkScheduler { public: UplinkSchedulerMBQoS (); + /** + * Constructor + * + * \param time the time + */ UplinkSchedulerMBQoS (Time time); ~UplinkSchedulerMBQoS (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Get uplink allocations + * \returns std::list + */ std::list GetUplinkAllocations (void) const; /** * Determines if channel descriptors sent in the current frame are * required to be updated + * \param updateDcd update DCD if true + * \param updateUcd update UCD if true + * \param sendDcd send DCD if true + * \param sendUcd send UCD if true + */ + void GetChannelDescriptorsToUpdate (bool &updateDcd, bool &updateUcd, bool &sendDcd, bool &sendUcd); + /** + * Calculate allocation start time + * \returns the allocation start time */ - void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&); uint32_t CalculateAllocationStartTime (void); + /** + * Add uplink allocation + * \param ulMapIe the UL map IE + * \param allocationSize the allocation size + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void AddUplinkAllocation (OfdmUlMapIe &ulMapIe, const uint32_t &allocationSize, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Schedule function + */ void Schedule (void); + /** + * Service unsolicited grants + * \param ssRecord the SS record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceUnsolicitedGrants (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service bandwidth requests + * \param ssRecord the SS record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceBandwidthRequests (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service bandwidth requests + * \param serviceFlow the service flow + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + * \returns true if successful + */ bool ServiceBandwidthRequests (ServiceFlow *serviceFlow, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Allocate initial ranging interval + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Setup service flow + * \param ssRecord the SS record + * \param serviceFlow the service flow + */ void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow); /** @@ -149,6 +218,7 @@ class UplinkSchedulerMBQoS : public UplinkScheduler /** * \param priority Priority of queue + * \return Ptr * * \brief Dequeue a job from a priority queue. */ @@ -158,6 +228,7 @@ class UplinkSchedulerMBQoS : public UplinkScheduler /** * \param serviceFlow Service flow of connection + * \return Time * * \brief Calculates deadline of a request. */ @@ -170,6 +241,7 @@ class UplinkSchedulerMBQoS : public UplinkScheduler /** * \param jobs List of jobs + * \returns the symbols count * * Sum the amount of symbols of each job of a queue */ @@ -177,26 +249,48 @@ class UplinkSchedulerMBQoS : public UplinkScheduler /** * \param job job + * \returns the symbols count * * Count the amount of symbols of a job. */ uint32_t CountSymbolsJobs (Ptr job); + /** + * Set requested bandwidth + */ void OnSetRequestedBandwidth (ServiceFlowRecord *sfr); /** * \param ssRecord Subscriber station record * \param schedType Service flow type * \param reqType Type of packet + * \return Ptr * * Create and fill information of a job. */ Ptr CreateUlJob (SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedType, ReqType reqType); + /** + * \param serviceFlow ServiceFlow + * \return Ptr + * + * Get pending size. + */ uint32_t GetPendingSize (ServiceFlow* serviceFlow); + /** + * Service bandwidth requests bytes. + * \param serviceFlow the service flow + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + * \param allocationSizeBytes the allocation size in bytes + * \returns true if successful + */ bool ServiceBandwidthRequestsBytes (ServiceFlow *serviceFlow, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, @@ -204,15 +298,15 @@ class UplinkSchedulerMBQoS : public UplinkScheduler uint32_t &symbolsToAllocation, uint32_t &availableSymbols, uint32_t allocationSizeBytes); private: - std::list m_uplinkAllocations; + std::list m_uplinkAllocations; ///< uplink allocations // queues for scheduler - std::list > m_uplinkJobs_high; - std::list > m_uplinkJobs_inter; - std::list > m_uplinkJobs_low; + std::list > m_uplinkJobs_high; ///< uplink jobs high priority + std::list > m_uplinkJobs_inter; ///< uplink jobs intermedite priority + std::list > m_uplinkJobs_low; ///< uplink jobs low priority // interval to reset window - Time m_windowInterval; + Time m_windowInterval; ///< windows interval }; } // namespace ns3 diff --git a/src/wimax/model/bs-uplink-scheduler-rtps.h b/src/wimax/model/bs-uplink-scheduler-rtps.h index 3dcc34069e4..6d608c91116 100644 --- a/src/wimax/model/bs-uplink-scheduler-rtps.h +++ b/src/wimax/model/bs-uplink-scheduler-rtps.h @@ -54,19 +54,47 @@ class UplinkSchedulerRtps : public UplinkScheduler { public: UplinkSchedulerRtps (); + /** + * Constructor + * + * \param bs base station device + */ UplinkSchedulerRtps (Ptr bs); ~UplinkSchedulerRtps (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * \brief Get uplink allocations. + * \returns std::list + */ std::list GetUplinkAllocations (void) const; /** * Determines if channel descriptors sent in the current frame are * required to be updated + * \param updateDcd if true update DCD + * \param updateUcd if true update UCD + * \param sendDcd if true send DCD + * \param sendUcd if true send UCD + */ + void GetChannelDescriptorsToUpdate (bool &updateDcd, bool &updateUcd, bool &sendDcd, bool &sendUcd); + /** + * Calculate allocation start time function + * \returns the allocation start time value */ - void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&); uint32_t CalculateAllocationStartTime (void); + /** + * Add Uplink Allocation function + * \param ulMapIe the UL map IE + * \param allocationSize the allocation size + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void AddUplinkAllocation (OfdmUlMapIe &ulMapIe, const uint32_t &allocationSize, uint32_t &symbolsToAllocation, @@ -75,18 +103,46 @@ class UplinkSchedulerRtps : public UplinkScheduler * \brief Schedule function. */ void Schedule (void); + /** + * Service Unsolicited Grants function + * \param ssRecord Subscriber station record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceUnsolicitedGrants (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service Bandwidth Requests function + * \param ssRecord Subscriber station record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceBandwidthRequests (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service bandwidth requests function + * \param serviceFlow the service flow + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + * \returns true if successful + */ bool ServiceBandwidthRequests (ServiceFlow *serviceFlow, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, @@ -111,17 +167,37 @@ class UplinkSchedulerRtps : public UplinkScheduler * is called to redistribute the available bandwidth. */ void ULSchedulerRTPSConnection (uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Allocate Initial Ranging Interval function + * + * \param symbolsToAllocation symbols to allocation for UpLink Subframe + * \param availableSymbols available symbols for rtPS flows + */ void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Setup service flow function + * \param ssRecord Subscriber station record + * \param serviceFlow the service flow + */ void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow); - + + /** + * Process bandwidth requet function + * \param bwRequestHdr the bandwidth request header + */ void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr); + /// Init once function void InitOnce (void); + /** + * Set requested bandwidth function + * \param sfr the service flow record + */ void OnSetRequestedBandwidth (ServiceFlowRecord *sfr); private: - std::list m_uplinkAllocations; + std::list m_uplinkAllocations; ///< uplink allocations }; diff --git a/src/wimax/model/bs-uplink-scheduler-simple.h b/src/wimax/model/bs-uplink-scheduler-simple.h index ec967b6e80b..25aaee759a8 100644 --- a/src/wimax/model/bs-uplink-scheduler-simple.h +++ b/src/wimax/model/bs-uplink-scheduler-simple.h @@ -41,9 +41,18 @@ class UplinkSchedulerSimple : public UplinkScheduler { public: UplinkSchedulerSimple (void); + /** + * Constructor + * + * \param bs base station device + */ UplinkSchedulerSimple (Ptr bs); ~UplinkSchedulerSimple (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); std::list GetUplinkAllocations (void) const; @@ -59,35 +68,83 @@ class UplinkSchedulerSimple : public UplinkScheduler uint32_t &symbolsToAllocation, uint32_t &availableSymbols); void Schedule (void); + /** + * Service Unsolicited Grants function + * \param ssRecord Subscriber station record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceUnsolicitedGrants (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service Bandwidth Requests function + * \param ssRecord Subscriber station record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ void ServiceBandwidthRequests (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Service bandwidth requests function + * \param serviceFlow the service flow + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + * \returns true if successful + */ bool ServiceBandwidthRequests (ServiceFlow *serviceFlow, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Allocate Initial Ranging Interval function + * + * \param symbolsToAllocation symbols to allocation for UpLink Subframe + * \param availableSymbols available symbols for rtPS flows + */ void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols); + /** + * Setup service flow function + * \param ssRecord Subscriber station record + * \param serviceFlow the service flow + */ void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow); + /** + * Process bandwidth requet function + * \param bwRequestHdr the bandwidth request header + */ void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr); + /// Init once function void InitOnce (void); + /** + * Set requested bandwidth function + * \param sfr the service flow record + */ void OnSetRequestedBandwidth (ServiceFlowRecord *sfr); private: - std::list m_uplinkAllocations; + std::list m_uplinkAllocations; ///< uplink allocations }; diff --git a/src/wimax/model/bs-uplink-scheduler.h b/src/wimax/model/bs-uplink-scheduler.h index 097de0e592e..18d01bd4ede 100644 --- a/src/wimax/model/bs-uplink-scheduler.h +++ b/src/wimax/model/bs-uplink-scheduler.h @@ -43,79 +43,202 @@ class UplinkScheduler : public Object { public: UplinkScheduler (void); + /** + * Constructor + * + * \param bs base station device + */ UplinkScheduler (Ptr bs); virtual ~UplinkScheduler (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * \return the number of IR opps allocated + */ virtual uint8_t GetNrIrOppsAllocated (void) const; + /** + * \brief Set the number of IR opps allocated + * \param nrIrOppsAllocated number of IR opps allocated + */ virtual void SetNrIrOppsAllocated (uint8_t nrIrOppsAllocated); + /** + * \return true if the IR interval is allocated + */ virtual bool GetIsIrIntrvlAllocated (void) const; + /** + * \brief Set if the IR interval is allocated + * \param isIrIntrvlAllocated + */ virtual void SetIsIrIntrvlAllocated (bool isIrIntrvlAllocated); + /** + * \return true if the Inv IR interval is allocated + */ virtual bool GetIsInvIrIntrvlAllocated (void) const; + /** + * \brief Set if the Inv IR interval is allocated + * \param isInvIrIntrvlAllocated + */ virtual void SetIsInvIrIntrvlAllocated (bool isInvIrIntrvlAllocated); + /** + * \return uplink allocations + */ virtual std::list GetUplinkAllocations (void) const; + /** + * \return the timestamp of the IR interval + */ virtual Time GetTimeStampIrInterval (void); + /** + * \brief Set timestamp IR interval + * \param timeStampIrInterval + */ virtual void SetTimeStampIrInterval (Time timeStampIrInterval); + /** + * \return the DCD timestamp + */ virtual Time GetDcdTimeStamp (void) const; + /** + * \brief Set DCD timestamp + * \param dcdTimeStamp + */ virtual void SetDcdTimeStamp (Time dcdTimeStamp); + /** + * \return the UCD timestamp + */ virtual Time GetUcdTimeStamp (void) const; + /** + * \brief Set UCD timestamp + * \param ucdTimeStamp + */ virtual void SetUcdTimeStamp (Time ucdTimeStamp); + /** + * \return the base station device + */ virtual Ptr GetBs (void); + /** + * \brief Set base station device + * \param bs + */ virtual void SetBs (Ptr bs); /** * Determines if channel descriptors sent in the current frame are * required to be updated */ virtual void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&) = 0; + /** + * \return the calculated allocation start time + */ virtual uint32_t CalculateAllocationStartTime (void) = 0; + /** + * Add uplink allocation + * \param ulMapIe the UL map IE + * \param allocationSize the allocation size + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ virtual void AddUplinkAllocation (OfdmUlMapIe &ulMapIe, const uint32_t &allocationSize, uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0; + /** + * Schedule function + */ virtual void Schedule (void) = 0; + /** + * Service unsolicited grants function + * \param ssRecord the SS record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ virtual void ServiceUnsolicitedGrants (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0; + /** + * Service bandwidth request function + * \param ssRecord the SS record + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ virtual void ServiceBandwidthRequests (const SSRecord *ssRecord, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0; + /** + * Service bandwidth request function + * \param serviceFlow the service flow + * \param schedulingType the scheduling type + * \param ulMapIe the UL map IE + * \param modulationType the modulation type + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + * \returns true if successful + */ virtual bool ServiceBandwidthRequests (ServiceFlow *serviceFlow, enum ServiceFlow::SchedulingType schedulingType, OfdmUlMapIe &ulMapIe, const WimaxPhy::ModulationType modulationType, uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0; + /** + * Allocate initial ranging interval function + * \param symbolsToAllocation the symbols to allocation + * \param availableSymbols the available symbols + */ virtual void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0; + /** + * Setp service flow function + * \param ssRecord the SS record + * \param serviceFlow the service flow + */ virtual void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow) = 0; + /** + * Process bandwidth request function + * \param bwRequestHdr + */ virtual void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr) = 0; + /** + * one time initialization function + */ virtual void InitOnce (void) = 0; + /** + * \brief Set requested bandwidth + * \param sfr service flow record + */ virtual void OnSetRequestedBandwidth (ServiceFlowRecord *sfr) = 0; private: - Ptr m_bs; - std::list m_uplinkAllocations; - Time m_timeStampIrInterval; - uint8_t m_nrIrOppsAllocated; - bool m_isIrIntrvlAllocated; - bool m_isInvIrIntrvlAllocated; - Time m_dcdTimeStamp; - Time m_ucdTimeStamp; + Ptr m_bs; ///< the base station + std::list m_uplinkAllocations; ///< uplink allocations + Time m_timeStampIrInterval; ///< timestamp IR interval + uint8_t m_nrIrOppsAllocated; ///< number IR opps allocated + bool m_isIrIntrvlAllocated; ///< is IR interval allocated + bool m_isInvIrIntrvlAllocated; ///< is Inv IR interval allocated + Time m_dcdTimeStamp; ///< DCD timestamp + Time m_ucdTimeStamp; ///< UCD timestamp }; } // namespace ns3 diff --git a/src/wimax/model/burst-profile-manager.h b/src/wimax/model/burst-profile-manager.h index df0ff673990..9a9bd088728 100644 --- a/src/wimax/model/burst-profile-manager.h +++ b/src/wimax/model/burst-profile-manager.h @@ -37,16 +37,25 @@ class RngReq; class BurstProfileManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param device WIMAX device + */ BurstProfileManager (Ptr device); ~BurstProfileManager (void); void DoDispose (void); - /* + /** * \returns the number of available burst profile */ uint16_t GetNrBurstProfilesToDefine (void); - /* + /** * \brief returns the modulation type of a given iuc * \param direction should be uplink or downlink * \param iuc the iuc @@ -55,25 +64,44 @@ class BurstProfileManager : public Object WimaxPhy::ModulationType GetModulationType (uint8_t iuc, WimaxNetDevice::Direction direction) const; + /** + * \brief returns the burst profile + * \param modulationType + * \param direction should be uplink or downlink + * \returns the modulation type of the selected iuc + */ uint8_t GetBurstProfile (WimaxPhy::ModulationType modulationType, WimaxNetDevice::Direction direction) const; - /* - * \brief during initial ranging or periodic ranging (or when RNG-REQ is used instead of - * DBPC) calculates the least robust burst profile for SS, e.g., based on distance, - * power, signal etc - * + /** + * \brief Get burst profile for SS + * \param modulationType + * \param ssRecord + * \param rngreq + * \returns the burst profile for SS */ uint8_t GetBurstProfileForSS (const SSRecord *ssRecord, const RngReq *rngreq, WimaxPhy::ModulationType &modulationType); + /** + * \brief Get module ation type for SS + * \param ssRecord + * \param rngreq + * \returns the burst profile for SS + */ WimaxPhy::ModulationType GetModulationTypeForSS (const SSRecord *ssRecord, const RngReq *rngreq); + /** + * \brief Get burst profile to request + * \returns the burst profile for SS + */ uint8_t GetBurstProfileToRequest (void); private: + /// Type conversion operator BurstProfileManager (const BurstProfileManager &); + /// Assignment operator BurstProfileManager& operator= (const BurstProfileManager &); - Ptr m_device; + Ptr m_device; ///< the device }; } // namespace ns3 diff --git a/src/wimax/model/bvec.h b/src/wimax/model/bvec.h index 446a3bcf012..c9804ae12bc 100644 --- a/src/wimax/model/bvec.h +++ b/src/wimax/model/bvec.h @@ -25,6 +25,7 @@ #include namespace ns3 { +/// boolean vector typedef typedef std::vector bvec; } diff --git a/src/wimax/model/cid-factory.h b/src/wimax/model/cid-factory.h index 0d1a8d4c021..111cb39118b 100644 --- a/src/wimax/model/cid-factory.h +++ b/src/wimax/model/cid-factory.h @@ -69,26 +69,46 @@ class CidFactory * \returns the next Multicast CID. */ Cid AllocateMulticast (void); - + /** + * \brief This function returns the next CID for the specified type. + * \param type CID type + * \returns the next CID. + */ Cid Allocate (enum Cid::Type type); + /** + * \brief This function determines if the CID is a transport. + * \param cid CID type + * \returns true if the CID is a transport. + */ bool IsTransport (Cid cid) const; + /** + * \brief This function determines if the CID is primary. + * \param cid CID type + * \returns true if the CID is primary. + */ bool IsPrimary (Cid cid) const; + /** + * \brief This function determines if the CID is basic. + * \param cid CID type + * \returns true if the CID is basic. + */ bool IsBasic (Cid cid) const; /** * Notify the factory that the connection associated to this * cid has been killed and that this cid can be reused. + * \param cid CID type */ void FreeCid (Cid cid); private: - uint16_t m_m; + uint16_t m_m; ///< m - uint16_t m_basicIdentifier; - uint16_t m_primaryIdentifier; - uint16_t m_transportOrSecondaryIdentifier; - uint16_t m_multicastPollingIdentifier; + uint16_t m_basicIdentifier; ///< basic identifier + uint16_t m_primaryIdentifier; ///< primary identifier + uint16_t m_transportOrSecondaryIdentifier; ///< transport or secondary identifier + uint16_t m_multicastPollingIdentifier; ///< multicast polling identifier }; } // namespace ns3 diff --git a/src/wimax/model/cid.cc b/src/wimax/model/cid.cc index 59f51540f19..30aa81fb276 100644 --- a/src/wimax/model/cid.cc +++ b/src/wimax/model/cid.cc @@ -84,18 +84,36 @@ Cid::InitialRanging (void) return 0; } +/** + * \brief equality operator + * \param lhs left hand side + * \param rhs right hand side + * \returns true if equal + */ bool operator == (const Cid &lhs, const Cid &rhs) { return lhs.m_identifier == rhs.m_identifier; } +/** + * \brief inequality operator + * \param lhs left hand side + * \param rhs right hand side + * \returns true if not equal + */ bool operator != (const Cid &lhs, const Cid &rhs) { return !(lhs == rhs); } +/** + * \brief output stream output opertor + * \param os output stream + * \param cid CID + * \returns output stream + */ std::ostream & operator << (std::ostream &os, const Cid &cid) { os << cid.GetIdentifier (); diff --git a/src/wimax/model/cid.h b/src/wimax/model/cid.h index 09f2077bca3..298489802b2 100644 --- a/src/wimax/model/cid.h +++ b/src/wimax/model/cid.h @@ -31,10 +31,13 @@ namespace ns3 { /** * \ingroup wimax + * \class Cid + * \brief Cid class */ class Cid { public: + /// Type enumeration enum Type { BROADCAST = 1, @@ -46,8 +49,13 @@ class Cid PADDING }; - // Create a cid of unknown type + /// Create a cid of unknown type Cid (void); + /** + * Constructor + * + * \param cid + */ Cid (uint16_t cid); ~Cid (void); /** @@ -85,8 +93,9 @@ class Cid private: friend class CidFactory; + /// equality operator friend bool operator == (const Cid &lhs, const Cid &rhs); - uint16_t m_identifier; + uint16_t m_identifier; ///< identiifier }; bool operator == (const Cid &lhs, const Cid &rhs); diff --git a/src/wimax/model/connection-manager.h b/src/wimax/model/connection-manager.h index f0f187e1bfe..af7059cc0eb 100644 --- a/src/wimax/model/connection-manager.h +++ b/src/wimax/model/connection-manager.h @@ -44,10 +44,18 @@ class SubscriberStationNetDevice; class ConnectionManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); ConnectionManager (void); ~ConnectionManager (void); void DoDispose (void); + /** + * Set CID factory + * \param cidFactory the CID factory + */ void SetCidFactory (CidFactory *cidFactory); /** * \brief allocates the management connection for an ss record. This method is only used by BS @@ -58,6 +66,7 @@ class ConnectionManager : public Object /** * \brief create a connection of type type * \param type type of the connection to create + * \return a smart pointer to the created WimaxConnection */ Ptr CreateConnection (Cid::Type type); /** @@ -67,25 +76,33 @@ class ConnectionManager : public Object */ void AddConnection (Ptr connection, Cid::Type type); /** - * \return the connection which has as identifier cid + * \param cid the connection identifier + * \return the connection corresponding to cid */ Ptr GetConnection (Cid cid); /** - * \return a listy of all connection which have as type type + * \param type the type of connection to add + * \return a vector of all connections matching the input type */ std::vector > GetConnections (Cid::Type type) const; + /** + * \brief get number of packets + * \param type the type of connection to add + * \param schedulingType the scheduling type + * \returns number of packets + */ uint32_t GetNPackets (Cid::Type type, ServiceFlow::SchedulingType schedulingType) const; /** * \return true if one of the managed connection has at least one packet to send, false otherwise */ bool HasPackets (void) const; private: - std::vector > m_basicConnections; - std::vector > m_primaryConnections; - std::vector > m_transportConnections; - std::vector > m_multicastConnections; + std::vector > m_basicConnections; ///< basic connections + std::vector > m_primaryConnections; ///< primary connections + std::vector > m_transportConnections; ///< transport connections + std::vector > m_multicastConnections; ///< multicast connections // only for BS - CidFactory *m_cidFactory; + CidFactory *m_cidFactory; ///< the factory }; } // namespace ns3 diff --git a/src/wimax/model/crc8.cc b/src/wimax/model/crc8.cc index 76bf0e910cb..5803b8e93a7 100644 --- a/src/wimax/model/crc8.cc +++ b/src/wimax/model/crc8.cc @@ -27,6 +27,7 @@ namespace ns3 { * x^8 + x^2 + x^1 + x^0 */ +/// crc8 table static uint8_t crc8table[256] = { 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E, diff --git a/src/wimax/model/cs-parameters.h b/src/wimax/model/cs-parameters.h index fd4e5c7c069..064109ace64 100644 --- a/src/wimax/model/cs-parameters.h +++ b/src/wimax/model/cs-parameters.h @@ -30,10 +30,12 @@ namespace ns3 { /** * \ingroup wimax + * \brief CsParameters class */ class CsParameters { public: + /// Action enumeration enum Action { ADD = 0, @@ -52,6 +54,7 @@ class CsParameters CsParameters (enum Action classifierDscAction, IpcsClassifierRecord classifier); /** * \brief sets the dynamic service classifier action to ADD, Change or delete. Only ADD is supported + * \param action the action enumeration */ void SetClassifierDscAction (enum Action action); /** @@ -73,8 +76,8 @@ class CsParameters Tlv ToTlv (void) const; private: - enum Action m_classifierDscAction; - IpcsClassifierRecord m_packetClassifierRule; + enum Action m_classifierDscAction; ///< classifier DSC action + IpcsClassifierRecord m_packetClassifierRule; ///< packet classifier rule }; } diff --git a/src/wimax/model/dl-mac-messages.h b/src/wimax/model/dl-mac-messages.h index 2982ceacc48..a375740b70a 100644 --- a/src/wimax/model/dl-mac-messages.h +++ b/src/wimax/model/dl-mac-messages.h @@ -31,36 +31,83 @@ namespace ns3 { /** * \ingroup wimax - * \brief This class implements the DCD channel encodings as described by "IEEE Standard for + * This class implements the DCD channel encodings as described by "IEEE Standard for * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" * 11.4.1 DCD channel encodings, page 659 - * - */ + */ class DcdChannelEncodings { public: DcdChannelEncodings (void); virtual ~DcdChannelEncodings (void); + /** + * Set BS EIRP field + * \param bs_eirp the BS EIRP + */ void SetBsEirp (uint16_t bs_eirp); + /** + * Set EIRX IR MAX field + * \param rss_ir_max the EIRRX IR MAX + */ void SetEirxPIrMax (uint16_t rss_ir_max); + /** + * Set frequency field + * \param frequency the frequency + */ void SetFrequency (uint32_t frequency); + /** + * Get BS EIRP field + * \returns the BS EIRP + */ uint16_t GetBsEirp (void) const; + /** + * Get EIRX IR MAX field + * \returns the EIRX IR MAX + */ uint16_t GetEirxPIrMax (void) const; + /** + * Get frequency functon + * \returns the frequency + */ uint32_t GetFrequency (void) const; + /** + * Get size field + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: + /** + * Write item + * \param start iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const = 0; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoRead (Buffer::Iterator start) = 0; - uint16_t m_bsEirp; - uint16_t m_eirXPIrMax; - uint32_t m_frequency; + uint16_t m_bsEirp; ///< BS EIRP + uint16_t m_eirXPIrMax; ///< EIRX IR MAX + uint32_t m_frequency; ///< frequency }; @@ -78,48 +125,107 @@ class DcdChannelEncodings namespace ns3 { +/** + * This class implements the OFDM DCD channel encodings as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + */ class OfdmDcdChannelEncodings : public DcdChannelEncodings { - /** - * \brief This class implements the DCD channel encodings as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 11.4.1 DCD channel encodings, page 659 - * - */ - public: OfdmDcdChannelEncodings (void); ~OfdmDcdChannelEncodings (void); + /** + * Set channel number field + * \param channelNr the channel number + */ void SetChannelNr (uint8_t channelNr); + /** + * Set TTG field + * \param ttg the TTG + */ void SetTtg (uint8_t ttg); + /** + * Set RTG field + * \param rtg the RTG + */ void SetRtg (uint8_t rtg); + /** + * Set base station ID field + * \param baseStationId the base station ID + */ void SetBaseStationId (Mac48Address baseStationId); + /** + * Set frame duration code field + * \param frameDurationCode the frame duration code + */ void SetFrameDurationCode (uint8_t frameDurationCode); + /** + * Set frame number field + * \param frameNumber the frame number + */ void SetFrameNumber (uint32_t frameNumber); + /** + * Get channel number field + * \returns the channel number + */ uint8_t GetChannelNr (void) const; + /** + * Get TTG field + * \returns the TTG + */ uint8_t GetTtg (void) const; + /** + * Get RTG field + * \returns the RTG + */ uint8_t GetRtg (void) const; + /** + * Get base station ID field + * \returns the base station MAC address + */ Mac48Address GetBaseStationId (void) const; + /** + * Get frame duration code field + * \returns the frame duration code + */ uint8_t GetFrameDurationCode (void) const; + /** + * Get frame number field + * \returns the frame number + */ uint32_t GetFrameNumber (void) const; + /** + * Get size field + * \returns the size + */ uint16_t GetSize (void) const; private: + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoRead (Buffer::Iterator start); - uint8_t m_channelNr; - uint8_t m_ttg; - uint8_t m_rtg; + uint8_t m_channelNr; ///< channel number + uint8_t m_ttg; ///< TTG + uint8_t m_rtg; ///< RTG - uint32_t m_chnlSwitchFrameNr; - Mac48Address m_baseStationId; - uint8_t m_frameDurationCode; - uint32_t m_frameNumber; + uint32_t m_chnlSwitchFrameNr; ///< channel switch frame number + Mac48Address m_baseStationId; ///< base station ID + uint8_t m_frameDurationCode; ///< frame duration code + uint32_t m_frameNumber; ///< frame number }; } // namespace ns3 @@ -136,15 +242,16 @@ class OfdmDcdChannelEncodings : public DcdChannelEncodings namespace ns3 { +/** + * This class implements the OFDM Downlink burst profile descriptor as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 8.2.1.10 Burst profile formats page 416 + * + */ class OfdmDlBurstProfile { - /** - * \brief This class implements the OFDM Downlink burst profile descriptor as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 8.2.1.10 Burst profile formats page 416 - * - */ public: + /// DIUC enumeration enum Diuc { DIUC_STC_ZONE = 0, @@ -167,29 +274,55 @@ class OfdmDlBurstProfile OfdmDlBurstProfile (void); ~OfdmDlBurstProfile (void); + /** + * Set type field + * \param type the type to set + */ void SetType (uint8_t type); + /** + * Set length field + * \param length the length to set + */ void SetLength (uint8_t length); + /** + * Set DIUC field + * \param diuc the DIUC + */ void SetDiuc (uint8_t diuc); + /** + * Set FEC code type + * \param fecCodeType the FEC code type + */ void SetFecCodeType (uint8_t fecCodeType); + /** + * Get type functon + * \returns the type + */ uint8_t GetType (void) const; + /// Get length field uint8_t GetLength (void) const; + /// Get DIUC field uint8_t GetDiuc (void) const; + /// Get FEC code type functon uint8_t GetFecCodeType (void) const; + /// Get size uint16_t GetSize (void) const; + /// Write item Buffer::Iterator Write (Buffer::Iterator start) const; + /// Read item Buffer::Iterator Read (Buffer::Iterator start); private: - uint8_t m_type; - uint8_t m_length; - uint8_t m_diuc; + uint8_t m_type; ///< type + uint8_t m_length; ///< length + uint8_t m_diuc; ///< diuc // TLV Encoded information - uint8_t m_fecCodeType; + uint8_t m_fecCodeType; ///< FEC code type }; } // namespace ns3 @@ -207,29 +340,68 @@ class OfdmDlBurstProfile namespace ns3 { +/** + * This class implements Downlink channel descriptor as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.1 Downlink Channel Descriptor (DCD) message, page 45 + */ class Dcd : public Header { - /** - * \brief This class implements Downlink channel descriptor as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.1 Downlink Channel Descriptor (DCD) message, page 45 - * - */ public: Dcd (void); virtual ~Dcd (void); + /** + * Set configuration change count field + * \param configurationChangeCount the configuration change count + */ void SetConfigurationChangeCount (uint8_t configurationChangeCount); + /** + * Set channel encodings field + * \param channelEncodings the channel encodings + */ void SetChannelEncodings (OfdmDcdChannelEncodings channelEncodings); + /** + * Add DL burst profile field + * \param dlBurstProfile the DL burst profile + */ void AddDlBurstProfile (OfdmDlBurstProfile dlBurstProfile); + /** + * Set number DL burst profile field + * \param nrDlBurstProfiles the number of DL burst profiles + */ void SetNrDlBurstProfiles (uint8_t nrDlBurstProfiles); + /** + * Get configuration change count field + * \returns the configuration change count + */ uint8_t GetConfigurationChangeCount (void) const; + /** + * Get channel encodings field + * \returns the channel encodings + */ OfdmDcdChannelEncodings GetChannelEncodings (void) const; + /** + * Get DL burst profile field + * \returns the DL burst profiles + */ std::vector GetDlBurstProfiles (void) const; + /** + * Get number DL burst profiles field + * \returns the number of DL burst profiles + */ uint8_t GetNrDlBurstProfiles (void) const; + /** + * Get name field + * \returns the name string + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -237,12 +409,12 @@ class Dcd : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_reserved; // changed as per the amendment 802.16e-2005 - uint8_t m_configurationChangeCount; - OfdmDcdChannelEncodings m_channelEncodings; // TLV Encoded information for the overall channel - std::vector m_dlBurstProfiles; // vector of download burst profiles + uint8_t m_reserved; ///< changed as per the amendment 802.16e-2005 + uint8_t m_configurationChangeCount; ///< configuration change count + OfdmDcdChannelEncodings m_channelEncodings; ///< TLV Encoded information for the overall channel + std::vector m_dlBurstProfiles; ///< vector of download burst profiles - uint8_t m_nrDlBurstProfiles; + uint8_t m_nrDlBurstProfiles; ///< number DL purst profiles }; } // namespace ns3 @@ -259,37 +431,82 @@ class Dcd : public Header namespace ns3 { +/** + * This class implements the OFDM DL-MAP information element as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.43.6 Compact DL-MAP IE page 109 + */ class OfdmDlMapIe { - /** - * \brief This class implements DL-map ie as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.43.6 Compact DL-MAP IE page 109 - * - */ public: OfdmDlMapIe (void); ~OfdmDlMapIe (void); + /** + * Set CID functon + * \param cid the CID + */ void SetCid (Cid cid); + /** + * Set DIUC field + * \param diuc the DIUC + */ void SetDiuc (uint8_t diuc); + /** + * Set preamble present field + * \param preamblePresent the preamble present + */ void SetPreamblePresent (uint8_t preamblePresent); + /** + * Set start time field + * \param startTime the start time value + */ void SetStartTime (uint16_t startTime); + /** + * Set CID field + * \returns the CID + */ Cid GetCid (void) const; + /** + * Get DIUC field + * \returns the DIUC + */ uint8_t GetDiuc (void) const; + /** + * Get preamble present field + * \returns the preamble present indicator + */ uint8_t GetPreamblePresent (void) const; + /** + * Get start time field + * \returns the start time + */ uint16_t GetStartTime (void) const; + /** + * Get size + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Wrtie item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: - Cid m_cid; - uint8_t m_diuc; - uint8_t m_preamblePresent; - uint16_t m_startTime; + Cid m_cid; ///< CID + uint8_t m_diuc; ///< DIUC + uint8_t m_preamblePresent; ///< preamble present + uint16_t m_startTime; ///< start time }; @@ -309,28 +526,58 @@ class OfdmDlMapIe namespace ns3 { +/** + * This class implements DL-MAP as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 8.2.1.8.1 Compressed DL-MAP, page 402 + */ class DlMap : public Header { - /** - * \brief This class implements DL-map ie as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 8.2.1.8.1 Compressed DL-MAP, page 402 - * - */ - public: DlMap (void); virtual ~DlMap (void); + /** + * Set DCD count field + * \param dcdCount the DCD count + */ void SetDcdCount (uint8_t dcdCount); + /** + * Set base station ID field + * \param baseStationID the base station ID + */ void SetBaseStationId (Mac48Address baseStationID); + /** + * Add DL Map element field + * \param dlMapElement the DL map element + */ void AddDlMapElement (OfdmDlMapIe dlMapElement); + /** + * Get DCD count field + * \returns the DCD count + */ uint8_t GetDcdCount (void) const; + /** + * Get base station ID field + * \returns the MAC address + */ Mac48Address GetBaseStationId (void) const; + /** + * Get DL Map elements field + * \returns the DL map elements + */ std::list GetDlMapElements (void) const; + /** + * Get name field + * \returns the name string + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -338,9 +585,9 @@ class DlMap : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_dcdCount; - Mac48Address m_baseStationId; - std::list m_dlMapElements; + uint8_t m_dcdCount; ///< DCD count + Mac48Address m_baseStationId; ///< base station ID + std::list m_dlMapElements; ///< DL Map elements // m_paddingNibble; //fields to be implemented later on: }; diff --git a/src/wimax/model/ipcs-classifier-record.h b/src/wimax/model/ipcs-classifier-record.h index 8500649052e..a15e18ad29a 100644 --- a/src/wimax/model/ipcs-classifier-record.h +++ b/src/wimax/model/ipcs-classifier-record.h @@ -30,6 +30,7 @@ namespace ns3 { /** * \ingroup wimax + * \brief IpcsClassifierRecord class */ class IpcsClassifierRecord { @@ -112,6 +113,7 @@ class IpcsClassifierRecord * \param srcPort the source port of the packet * \param dstPort the destination port of the packet * \param proto The L4 protocol of the packet + * \return true if there is a match */ bool CheckMatch (Ipv4Address srcAddress, Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, @@ -136,34 +138,61 @@ class IpcsClassifierRecord private: + /** + * Check match source address function + * \param srcAddress source IP address to check + * \returns true if a match + */ bool CheckMatchSrcAddr (Ipv4Address srcAddress) const; + /** + * Check match destination address function + * \param dstAddress destination IP address to check + * \returns true if a match + */ bool CheckMatchDstAddr (Ipv4Address dstAddress) const; + /** + * Check match source port function + * \param srcPort source port to check + * \returns true if a match + */ bool CheckMatchSrcPort (uint16_t srcPort) const; + /** + * Check match destination port function + * \param dstPort destination port to check + * \returns true if a match + */ bool CheckMatchDstPort (uint16_t dstPort) const; + /** + * Check match protocol function + * \param proto protocol number to check + * \returns true if a match + */ bool CheckMatchProtocol (uint8_t proto) const; + /// PortRange structure struct PortRange { - uint16_t PortLow; - uint16_t PortHigh; + uint16_t PortLow; ///< port low + uint16_t PortHigh; ///< port high }; + /// ipv4Addr structure struct ipv4Addr { - Ipv4Address Address; - Ipv4Mask Mask; + Ipv4Address Address; ///< IP address + Ipv4Mask Mask; ///< net mask }; - uint8_t m_priority; - uint16_t m_index; - uint8_t m_tosLow; - uint8_t m_tosHigh; - uint8_t m_tosMask; - std::vector m_protocol; - std::vector m_srcAddr; - std::vector m_dstAddr; - std::vector m_srcPortRange; - std::vector m_dstPortRange; + uint8_t m_priority; ///< priority + uint16_t m_index; ///< index + uint8_t m_tosLow; ///< TOS low + uint8_t m_tosHigh; ///< TOS high + uint8_t m_tosMask; ///< TOS mask + std::vector m_protocol; ///< protocol + std::vector m_srcAddr; ///< source address + std::vector m_dstAddr; ///< destination address + std::vector m_srcPortRange; ///< surce port range + std::vector m_dstPortRange; ///< destination port range - uint16_t m_cid; + uint16_t m_cid; ///< the CID }; } // namespace ns3 diff --git a/src/wimax/model/ipcs-classifier.h b/src/wimax/model/ipcs-classifier.h index 4c2c55f314e..98f0e37fee6 100644 --- a/src/wimax/model/ipcs-classifier.h +++ b/src/wimax/model/ipcs-classifier.h @@ -37,6 +37,10 @@ class SsServiceFlowManager; class IpcsClassifier : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); IpcsClassifier (void); ~IpcsClassifier (void); diff --git a/src/wimax/model/mac-messages.h b/src/wimax/model/mac-messages.h index 5572c70042e..d8643bc558d 100644 --- a/src/wimax/model/mac-messages.h +++ b/src/wimax/model/mac-messages.h @@ -37,13 +37,13 @@ namespace ns3 { /** * \ingroup wimax + * Mac Management messages + * Section 6.3.2.3 MAC Management messages page 42, Table 14 page 43 */ class ManagementMessageType : public Header { public: - /* - * Section 6.3.2.3 MAC Management messages page 42, Table 14 page 43 - */ + /// Message type enumeration enum MessageType { MESSAGE_TYPE_UCD = 0, @@ -60,12 +60,30 @@ class ManagementMessageType : public Header }; ManagementMessageType (void); + /** + * Constructor + * + * \param type message type + */ ManagementMessageType (uint8_t type); virtual ~ManagementMessageType (void); + /** + * Set type field + * \param type the type + */ void SetType (uint8_t type); + /** + * Get type field + * \returns the type value + */ uint8_t GetType (void) const; + /// Get name field std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -73,7 +91,7 @@ class ManagementMessageType : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_type; + uint8_t m_type; ///< type }; } // namespace ns3 @@ -94,15 +112,14 @@ class ManagementMessageType : public Header namespace ns3 { +/** + * \ingroup wimax + * This class implements the ranging response message described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.6 Ranging response (RNG-RSP) message, page 50 + */ class RngRsp : public Header { - /** - * \brief This class implements the ranging response message described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.6 Ranging response (RNG-RSP) message, page 50 - * - */ - public: RngRsp (void); virtual ~RngRsp (void); @@ -126,6 +143,10 @@ class RngRsp : public Header * \param offsetFreqAdjust */ void SetOffsetFreqAdjust (uint32_t offsetFreqAdjust); + /** + * \brief set the range status. + * \param rangStatus + */ void SetRangStatus (uint8_t rangStatus); /** * \brief set the Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging. @@ -137,15 +158,47 @@ class RngRsp : public Header * \param ulChnlIdOverride the uplink channel index */ void SetUlChnlIdOverride (uint8_t ulChnlIdOverride); + /** + * \brief set the DL oper burst profile + * \param dlOperBurstProfile the oper burt profile + */ void SetDlOperBurstProfile (uint16_t dlOperBurstProfile); + /** + * \brief set the MAC address + * \param macAddress the MAC address + */ void SetMacAddress (Mac48Address macAddress); + /** + * \brief set basic CID. + * \param basicCid + */ void SetBasicCid (Cid basicCid); + /** + * \brief set primary CID. + * \param primaryCid + */ void SetPrimaryCid (Cid primaryCid); + /** + * \brief set AAS broadcast permission. + * \param aasBdcastPermission + */ void SetAasBdcastPermission (uint8_t aasBdcastPermission); + /** + * \brief set frame number. + * \param frameNumber + */ void SetFrameNumber (uint32_t frameNumber); + /** + * \brief set initial range opp number. + * \param initRangOppNumber + */ void SetInitRangOppNumber (uint8_t initRangOppNumber); + /** + * \brief set range sub channel. + * \param rangSubchnl + */ void SetRangSubchnl (uint8_t rangSubchnl); /** * \return Tx timing offset adjustment (signed 32-bit). The time required to advance SS transmission so frames @@ -164,6 +217,9 @@ class RngRsp : public Header * the BS. This is fine-frequency adjustment within a channel, not reassignment to a different channel. */ uint32_t GetOffsetFreqAdjust (void) const; + /** + * \return the range status. + */ uint8_t GetRangStatus (void) const; /** * \return Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging. @@ -177,15 +233,43 @@ class RngRsp : public Header * \return DlOperBurstProfile: This parameter is sent in response to the RNG-REQ Requested Downlink Burst Profile parameter */ uint16_t GetDlOperBurstProfile (void) const; + /** + * \return MAC address + */ Mac48Address GetMacAddress (void) const; + /** + * \return basic CID + */ Cid GetBasicCid (void) const; + /** + * \return primary CID + */ Cid GetPrimaryCid (void) const; + /** + * \return AAS broadcast permission + */ uint8_t GetAasBdcastPermission (void) const; + /** + * \return frame number + */ uint32_t GetFrameNumber (void) const; + /** + * \return initial range opp number + */ uint8_t GetInitRangOppNumber (void) const; + /** + * \return range sub channel + */ uint8_t GetRangSubchnl (void) const; + /** + * \return name string + */ std::string GetName (void) const; + /** + * Register this type. + * \return The TypeId. + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -193,52 +277,72 @@ class RngRsp : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_reserved; // changed as per the amendment 802.16e-2005 + uint8_t m_reserved; ///< changed as per the amendment 802.16e-2005 // TLV Encoded Information - // Tx timing offset adjustment (signed 32-bit). The time required to advance SS transmission so frames - // arrive at the expected time instance at the BS. + /** + * Tx timing offset adjustment (signed 32-bit). The time required to advance SS transmission so frames + * arrive at the expected time instance at the BS. + */ uint32_t m_timingAdjust; - // Specifies the relative change in transmission power level that the SS is to make in order that - // transmissions arrive at the BS at the desired power. When subchannelization is employed, the - // subscriber shall interpret the power offset adjustment as a required change to the transmitted power - // density. + /** + * Specifies the relative change in transmission power level that the SS is to make in order that + * transmissions arrive at the BS at the desired power. When subchannelization is employed, the + * subscriber shall interpret the power offset adjustment as a required change to the transmitted power + * density. + */ uint8_t m_powerLevelAdjust; - // Specifies the relative change in transmission frequency that the SS is to make in order to better match - // the BS. This is fine-frequency adjustment within a channel, not reassignment to a different channel. + /** + * Specifies the relative change in transmission frequency that the SS is to make in order to better match + * the BS. This is fine-frequency adjustment within a channel, not reassignment to a different channel. + */ uint32_t m_offsetFreqAdjust; + + /** + * range status. + */ uint8_t m_rangStatus; - // Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging. + /// Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging. uint32_t m_dlFreqOverride; - // Licensed bands: The identifier of the uplink channel with which the SS is to redo initial ranging (not - // used with PHYs without channelized uplinks). + /** + * Licensed bands: The identifier of the uplink channel with which the SS is to redo initial ranging (not + * used with PHYs without channelized uplinks). + */ uint8_t m_ulChnlIdOverride; - // This parameter is sent in response to the RNG-REQ Requested Downlink Burst Profile parameter. - // Byte 0: Specifies the least robust DIUC that may be used by the BS for transmissions to the SS. - // Byte 1: Configuration Change Count value of DCD defining the burst profile associated with DIUC. + /** + * This parameter is sent in response to the RNG-REQ Requested Downlink Burst Profile parameter. + * Byte 0: Specifies the least robust DIUC that may be used by the BS for transmissions to the SS. + * Byte 1: Configuration Change Count value of DCD defining the burst profile associated with DIUC. + */ uint16_t m_dlOperBurstProfile; - Mac48Address m_macAddress; - Cid m_basicCid; - Cid m_primaryCid; - uint8_t m_aasBdcastPermission; + Mac48Address m_macAddress; ///< MAC address + Cid m_basicCid; ///< basic CID + Cid m_primaryCid; ///< primary CID + uint8_t m_aasBdcastPermission; ///< AAS broadcast permission - // Frame number where the associated RNG_REQ message was detected by the BS. Usage is mutually - // exclusive with SS MAC Address + /** + * Frame number where the associated RNG_REQ message was detected by the BS. Usage is mutually + * exclusive with SS MAC Address + */ uint32_t m_frameNumber; - // Initial Ranging opportunity (1–255) in which the associated RNG_REQ message was detected by the BS. - // Usage is mutually exclusive with SS MAC Address + /** + * Initial Ranging opportunity (1–255) in which the associated RNG_REQ message was detected by the BS. + * Usage is mutually exclusive with SS MAC Address + */ uint8_t m_initRangOppNumber; - // Used to indicate the OFDM subchannel reference that was used to transmit the initial ranging message - // (OFDM with subchannelization). + /** + * Used to indicate the OFDM subchannel reference that was used to transmit the initial ranging message + * (OFDM with subchannelization). + */ uint8_t m_rangSubchnl; }; @@ -259,27 +363,28 @@ class RngRsp : public Header namespace ns3 { class serviceFlow; + +/** + * \ingroup wimax + * This class implements the DSA-REQ message described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.10 DSA-REQ message, page 62 + */ class DsaReq : public Header { - /** - * \brief This class implements the ranging request message described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.7 Registration request (REG-REQ) message, page 51 - * - * \verbatim - * 0 7 15 23 - * +-------------+-------------+-------------+ - * |Mngt msg type| Transaction ID | - * +-------------+-------------+-------------+ - * | Service Flow TLV | - * +~~~~~~~~~~~~~+~~~~~~~~~~~~~+~~~~~~~~~~~~~+ - * \endverbatim - * - */ public: DsaReq (); ~DsaReq (); + /** + * Constructor + * + * \param sf service flow + */ DsaReq (ServiceFlow sf); + /** + * \brief set the transaction ID + * \param transactionId + */ void SetTransactionId (uint16_t transactionId); /** * \brief set the service flow identifier @@ -300,6 +405,9 @@ class DsaReq : public Header * \return the service flow requested by this message */ ServiceFlow GetServiceFlow (void) const; + /** + * \return the transaction ID + */ uint16_t GetTransactionId (void) const; /** * \return the service flow identifier @@ -309,7 +417,14 @@ class DsaReq : public Header * \return the connection identifier */ Cid GetCid (void) const; + /** + * \return the service name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -318,11 +433,11 @@ class DsaReq : public Header uint32_t Deserialize (Buffer::Iterator start); private: - uint16_t m_transactionId; + uint16_t m_transactionId; ///< transaction ID // TLV Encoded Information - uint32_t m_sfid; - Cid m_cid; - ServiceFlow m_serviceFlow; + uint32_t m_sfid; ///< SFID + Cid m_cid; ///< CID + ServiceFlow m_serviceFlow; ///< service flow }; } // namespace ns3 @@ -341,31 +456,45 @@ class DsaReq : public Header namespace ns3 { +/** + * \ingroup wimax + * This class implements the DSA-RSP message described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.11 DSA-RSP message, page 63 + * + * \verbatim + * 0 7 15 23 + * +-------------+-------------+-------------+ + * |Mngt msg type| Transaction ID | + * +-------------+-------------+-------------+ + * | Conf Code | Service Flow TLV | + * +~~~~~~~~~~~~~+~~~~~~~~~~~~~+~~~~~~~~~~~~~+ + * \endverbatim + */ class DsaRsp : public Header { - /** - * \brief This class implements the DSA-RSP message described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.11 DSA-RSP message, page 63 - * - * \verbatim - * 0 7 15 23 - * +-------------+-------------+-------------+ - * |Mngt msg type| Transaction ID | - * +-------------+-------------+-------------+ - * | Conf Code | Service Flow TLV | - * +~~~~~~~~~~~~~+~~~~~~~~~~~~~+~~~~~~~~~~~~~+ - * \endverbatim - */ - public: DsaRsp (void); ~DsaRsp (void); + /** + * \brief set the transaction ID + * \param transactionId + */ void SetTransactionId (uint16_t transactionId); + /** + * \return the transaction ID + */ uint16_t GetTransactionId (void) const; + /** + * \brief set the confirmation code + * \param confirmationCode + */ void SetConfirmationCode (uint16_t confirmationCode); + /** + * \return the confirmation code + */ uint16_t GetConfirmationCode (void) const; /** * \brief set the service flow identifier @@ -395,7 +524,14 @@ class DsaRsp : public Header */ ServiceFlow GetServiceFlow (void) const; + /** + * \return the service name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -403,12 +539,12 @@ class DsaRsp : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint16_t m_transactionId; - uint8_t m_confirmationCode; + uint16_t m_transactionId; ///< transaction ID + uint8_t m_confirmationCode; ///< confirmation code // TLV Encoded Information - ServiceFlow m_serviceFlow; - uint32_t m_sfid; - Cid m_cid; + ServiceFlow m_serviceFlow; ///< service flow + uint32_t m_sfid; ///< SFID + Cid m_cid; ///< CID }; @@ -427,25 +563,50 @@ class DsaRsp : public Header namespace ns3 { +/** + * \ingroup wimax + * This class implements the DSA-ACK message described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.12 DSA-ACK message, page 64 + */ class DsaAck : public Header { - /** - * \brief This class implements the DSA-ACK message described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.12 DSA-ACK message, page 64 - */ public: DsaAck (void); ~DsaAck (void); + /** + * Set transaction ID field + * \param transactionId the transaction ID + */ void SetTransactionId (uint16_t transactionId); + /** + * Get transaction ID field + * \returns the transaction ID + */ uint16_t GetTransactionId (void) const; + /** + * Set confirmation code field + * \param confirmationCode the confirmation code + */ void SetConfirmationCode (uint16_t confirmationCode); + /** + * Get confirmation code field + * \returns the confirmation code + */ uint16_t GetConfirmationCode (void) const; + /** + * Get name field + * \return the name string + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -453,8 +614,8 @@ class DsaAck : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint16_t m_transactionId; - uint8_t m_confirmationCode; + uint16_t m_transactionId; ///< transaction ID + uint8_t m_confirmationCode; ///< confirmation code }; } // namespace ns3 @@ -473,41 +634,73 @@ class DsaAck : public Header namespace ns3 { +/** + * \ingroup wimax + * This class implements the ranging request message described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + */ class RngReq : public Header { - /** - * \brief This class implements the DSA-REQ message described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.10 DSA-REQ message, page 62 - */ - public: RngReq (void); virtual ~RngReq (void); + /** + * Set request DL burst profile field + * \param reqDlBurstProfile the request DL burst profile + */ void SetReqDlBurstProfile (uint8_t reqDlBurstProfile); + /** + * Set MAC address field + * \param macAddress the MAC address + */ void SetMacAddress (Mac48Address macAddress); + /** + * Set ranging anomalies field + * \param rangingAnomalies the rnaging anomalies + */ void SetRangingAnomalies (uint8_t rangingAnomalies); + /** + * Get request DL burst profile field + * \returns the request DL burst profile + */ uint8_t GetReqDlBurstProfile (void) const; + /** + * Get MAC address field + * \returns the MAC address + */ Mac48Address GetMacAddress (void) const; + /** + * Get ranging anomalies field + * \returns the ranging anomalies + */ uint8_t GetRangingAnomalies (void) const; + /** + * \brief Get name field + * \returns the name string + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; + /// Print debug function void PrintDebug (void) const; uint32_t GetSerializedSize (void) const; void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_reserved; // changed as per the amendment 802.16e-2005 + uint8_t m_reserved; ///< changed as per the amendment 802.16e-2005 // TLV Encoded Information - uint8_t m_reqDlBurstProfile; - Mac48Address m_macAddress; - uint8_t m_rangingAnomalies; + uint8_t m_reqDlBurstProfile; ///< request DL burst profile + Mac48Address m_macAddress; ///< MAC address + uint8_t m_rangingAnomalies; ///< ranging anomalies }; } // namespace ns3 diff --git a/src/wimax/model/ofdm-downlink-frame-prefix.h b/src/wimax/model/ofdm-downlink-frame-prefix.h index 059453ba035..2fd2670dd30 100644 --- a/src/wimax/model/ofdm-downlink-frame-prefix.h +++ b/src/wimax/model/ofdm-downlink-frame-prefix.h @@ -28,8 +28,8 @@ namespace ns3 { /** * \ingroup wimax - *\brief This class implements the DL Frame Prefix IE as described by IEEE-802.16 standard - *\brief The DL Frame Prefix IE is contained in DLFP (Downlink Frame Prefix) in OFDM PHY + * \brief This class implements the DL Frame Prefix IE as described by IEEE-802.16 standard + * \brief The DL Frame Prefix IE is contained in DLFP (Downlink Frame Prefix) in OFDM PHY */ class DlFramePrefixIe { @@ -37,28 +37,82 @@ class DlFramePrefixIe DlFramePrefixIe (); ~DlFramePrefixIe (); + /** + * Set rate ID field + * \param rateId the rate ID + */ void SetRateId (uint8_t rateId); + /** + * Set DIUC field + * \param diuc the DIUC + */ void SetDiuc (uint8_t diuc); + /** + * Set preamble present field + * \param preamblePresent the preambel present + */ void SetPreamblePresent (uint8_t preamblePresent); + /** + * Set length field + * \param length the length + */ void SetLength (uint16_t length); + /** + * Set start time field + * \param startTime the start time + */ void SetStartTime (uint16_t startTime); + /** + * Get rate ID field + * \returns the rate ID + */ uint8_t GetRateId (void) const; + /** + * Get DIUC field + * \returns the DIUC + */ uint8_t GetDiuc (void) const; + /** + * Get preamble present field + * \returns the preamble present + */ uint8_t GetPreamblePresent (void) const; + /** + * Get length field + * \returns the length + */ uint16_t GetLength (void) const; + /** + * Get start time field + * \returns the start time + */ uint16_t GetStartTime (void) const; + /** + * Get size field + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Write item function + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item function + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: - uint8_t m_rateId; - uint8_t m_diuc; - uint8_t m_preamblePresent; - uint16_t m_length; - uint16_t m_startTime; + uint8_t m_rateId; ///< rate ID + uint8_t m_diuc; ///< DIUC + uint8_t m_preamblePresent; ///< preamble present + uint16_t m_length; ///< length + uint16_t m_startTime; ///< start time // shall actually contain m_startTime if DIUC is 0. see Table 225, page 452 @@ -77,6 +131,9 @@ class DlFramePrefixIe namespace ns3 { +/** + * OfdmDownlinkFramePrefix + */ class OfdmDownlinkFramePrefix : public Header { public: @@ -89,29 +146,73 @@ class OfdmDownlinkFramePrefix : public Header */ static TypeId GetTypeId (void); + /** + * Set base station ID field + * \param baseStationId the base station ID + */ void SetBaseStationId (Mac48Address baseStationId); + /** + * Set frame number field + * \param frameNumber the frame number + */ void SetFrameNumber (uint32_t frameNumber); + /** + * Set configuration change count field + * \param configurationChangeCount the configuration change count + */ void SetConfigurationChangeCount (uint8_t configurationChangeCount); + /** + * Add DL frame prefix element field + * \param dlFramePrefixElement the DL frane prefix element + */ void AddDlFramePrefixElement (DlFramePrefixIe dlFramePrefixElement); + /** + * Set HCS field + * \param hcs the HCS + */ void SetHcs (uint8_t hcs); + /** + * Get base station ID field + * \returns the base station ID + */ Mac48Address GetBaseStationId (void) const; + /** + * Get frame number field + * \returns the frame number + */ uint32_t GetFrameNumber (void) const; + /** + * Get configuration change count field + * \returns the configuration change count + */ uint8_t GetConfigurationChangeCount (void) const; + /** + * Get DL frame prefix elements + * \returns the DL frame prefix elements + */ std::vector GetDlFramePrefixElements (void) const; + /** + * Get HCS field + * \returns the HCS + */ uint8_t GetHcs (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; void Print (std::ostream &os) const; uint32_t GetSerializedSize (void) const; void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - Mac48Address m_baseStationId; - uint32_t m_frameNumber; // shall actually be only 4 LSB of the same field in OFDM DCD Channel Encodings - uint8_t m_configurationChangeCount; // shall actually be only 4 LSB of the same field in DCD - std::vector m_dlFramePrefixElements; // vector of dl frame prefix elements - uint8_t m_hcs; // Header Check Sequence + Mac48Address m_baseStationId; ///< base station ID + uint32_t m_frameNumber; ///< shall actually be only 4 LSB of the same field in OFDM DCD Channel Encodings + uint8_t m_configurationChangeCount; ///< shall actually be only 4 LSB of the same field in DCD + std::vector m_dlFramePrefixElements; ///< vector of dl frame prefix elements + uint8_t m_hcs; ///< Header Check Sequence }; } // namespace ns3 diff --git a/src/wimax/model/send-params.h b/src/wimax/model/send-params.h index d2c355e5e95..835b13bc1c7 100644 --- a/src/wimax/model/send-params.h +++ b/src/wimax/model/send-params.h @@ -61,34 +61,49 @@ class SendParams namespace ns3 { +/** + * OfdmSendParams class + */ class OfdmSendParams : public SendParams { +public: /** - * \see SendParams + * Constructor + * + * \param burst packet burst object + * \param modulationType modulation type + * \param direction the direction */ -public: - OfdmSendParams (Ptr burst, uint8_t modulationType, - uint8_t direction); + OfdmSendParams (Ptr burst, uint8_t modulationType, uint8_t direction); ~OfdmSendParams (); + /** + * \return the packet burst + */ Ptr GetBurst () const { return m_burst; } + /** + * \return the modulation type + */ uint8_t GetModulationType () const { return m_modulationType; } + /** + * \return the direction + */ uint8_t GetDirection () const { return m_direction; } private: - Ptr m_burst; - uint8_t m_modulationType; - uint8_t m_direction; + Ptr m_burst; ///< packet burst + uint8_t m_modulationType; ///< modulation type + uint8_t m_direction; ///< direction }; } // namespace ns3 diff --git a/src/wimax/model/service-flow-manager.h b/src/wimax/model/service-flow-manager.h index 8592e95e963..86eb24b0926 100644 --- a/src/wimax/model/service-flow-manager.h +++ b/src/wimax/model/service-flow-manager.h @@ -42,20 +42,45 @@ class WimaxConnection; class ServiceFlowManager : public Object { public: - enum ConfirmationCode // as per Table 384 (not all codes implemented) + /// confirmation code enumeration as per Table 384 (not all codes implemented) + enum ConfirmationCode { - CONFIRMATION_CODE_SUCCESS, CONFIRMATION_CODE_REJECT + CONFIRMATION_CODE_SUCCESS, + CONFIRMATION_CODE_REJECT }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); ServiceFlowManager (); ~ServiceFlowManager (void); void DoDispose (void); + /** + * Add service flow function + * \param serviceFlow the service flow + */ void AddServiceFlow (ServiceFlow * serviceFlow); + /** + * Get service flow by flow id + * \param sfid the service flow id + * \returns pointer to the service flow object corresponding to the flow id + */ ServiceFlow* GetServiceFlow (uint32_t sfid) const; + /** + * Get service flow by CID + * \param cid the CID + * \returns pointer to the service flow object corresponding to the CID + */ ServiceFlow* GetServiceFlow (Cid cid) const; + /** + * Get service flows function + * \param schedulingType the scheduling type + * \returns vector of pointers to service flows corresponding to the schedulin type + */ std::vector GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const; /** @@ -63,17 +88,17 @@ class ServiceFlowManager : public Object */ bool AreServiceFlowsAllocated (); /** - * \param serviceFlows the list of the service flows to be checked + * \param serviceFlows vector of pointers to service flows to be checked * \return true if all service flows are allocated, false otherwise */ bool AreServiceFlowsAllocated (std::vector* serviceFlows); /** - * \param serviceFlows the list of the service flows to be checked + * \param serviceFlows vector of pointers to service flows to be checked * \return true if all service flows are allocated, false otherwise */ bool AreServiceFlowsAllocated (std::vector serviceFlows); /** - * \return the next service flow to be allocated + * \return pointer to the next service flow to be allocated */ ServiceFlow* GetNextServiceFlowToAllocate (); @@ -98,7 +123,7 @@ class ServiceFlowManager : public Object uint8_t Proto, ServiceFlow::Direction dir) const; private: - std::vector * m_serviceFlows; + std::vector * m_serviceFlows; ///< the service flows }; } // namespace ns3 diff --git a/src/wimax/model/service-flow-record.h b/src/wimax/model/service-flow-record.h index 3ce33075825..716d08f7d23 100644 --- a/src/wimax/model/service-flow-record.h +++ b/src/wimax/model/service-flow-record.h @@ -60,7 +60,7 @@ class ServiceFlowRecord Time GetGrantTimeStamp (void) const; /** * \brief Set the DlTimeStamp. - * \param dlTimeStamp: time when this service flow's traffic was last sent. + * \param dlTimeStamp time when this service flow's traffic was last sent. */ void SetDlTimeStamp (Time dlTimeStamp); /** @@ -82,7 +82,7 @@ class ServiceFlowRecord */ uint32_t GetPktsSent (void) const; /** - * \brief Set the number of received packet + * \brief Set the number of received packets * \param pktsRcvd The number of received packets */ void SetPktsRcvd (uint32_t pktsRcvd); @@ -124,55 +124,128 @@ class ServiceFlowRecord */ uint32_t GetBytesRcvd (void) const; + /** + * \brief set the requested bandwidth + * \param requestedBandwidth the requested bandwidth + */ void SetRequestedBandwidth (uint32_t requestedBandwidth); + /** + * \brief update the requested bandwidth + * \param requestedBandwidth the requested bandwidth update + */ void UpdateRequestedBandwidth (uint32_t requestedBandwidth); + /** + * \return The requested bandwidth + */ uint32_t GetRequestedBandwidth (void); + /** + * \brief set the granted bandwidth + * \param grantedBandwidth the granted bandwidth + */ void SetGrantedBandwidth (uint32_t grantedBandwidth); + /** + * \brief update the granted bandwidth + * \param grantedBandwidth the granted bandwidth update + */ void UpdateGrantedBandwidth (uint32_t grantedBandwidth); + /** + * \return The granted bandwidth + */ uint32_t GetGrantedBandwidth (void); + /** + * \brief set the temporary granted bandwidth + * \param grantedBandwidthTemp the temporary granted bandwidth + */ void SetGrantedBandwidthTemp (uint32_t grantedBandwidthTemp); + /** + * \brief update the temporary granted bandwidth + * \param grantedBandwidthTemp the temporary granted bandwidth + */ void UpdateGrantedBandwidthTemp (uint32_t grantedBandwidthTemp); + /** + * \return The temporary granted bandwidth + */ uint32_t GetGrantedBandwidthTemp (void); + /** + * \brief set BW since last expiry + * \param bwSinceLastExpiry bandwidth since last expiry + */ void SetBwSinceLastExpiry (uint32_t bwSinceLastExpiry); + /** + * \brief update BW since last expiry + * \param bwSinceLastExpiry bandwith since last expiry + */ void UpdateBwSinceLastExpiry (uint32_t bwSinceLastExpiry); + /** + * \return The bandwidth since last expiry + */ uint32_t GetBwSinceLastExpiry (void); + /** + * \brief set last grant time + * \param grantTime grant time to set + */ void SetLastGrantTime (Time grantTime); + /** + * \return The last grant time + */ Time GetLastGrantTime (void) const; + /** + * \brief set backlogged + * \param backlogged number of backlogged + */ void SetBacklogged (uint32_t backlogged); + /** + * \brief increase backlogged + * \param backlogged the number of backlogged to update + */ void IncreaseBacklogged (uint32_t backlogged); + /** + * \return The number of backlogged + */ uint32_t GetBacklogged (void) const; + /** + * \brief set temporary back logged + * \param backloggedTemp the temporary backlogged value + */ void SetBackloggedTemp (uint32_t backloggedTemp); + /** + * \brief increase temporary back logged + * \param backloggedTemp the temporary backlogged value + */ void IncreaseBackloggedTemp (uint32_t backloggedTemp); + /** + * \return The value of temporary backlogged + */ uint32_t GetBackloggedTemp (void) const; private: - uint32_t m_grantSize; // only used for UGS flow - Time m_grantTimeStamp; // allocation (for data) for UGS flows and unicast poll (for bandwidth requests) for non-UGS flows - Time m_dlTimeStamp; // time when this service flow's traffic was last sent + uint32_t m_grantSize; ///< only used for UGS flow + Time m_grantTimeStamp; ///< allocation (for data) for UGS flows and unicast poll (for bandwidth requests) for non-UGS flows + Time m_dlTimeStamp; ///< time when this service flow's traffic was last sent // stats members - uint32_t m_pktsSent; - uint32_t m_pktsRcvd; + uint32_t m_pktsSent; ///< packets sent + uint32_t m_pktsRcvd; ///< packets received - uint32_t m_bytesSent; - uint32_t m_bytesRcvd; + uint32_t m_bytesSent; ///< bytes sent + uint32_t m_bytesRcvd; ///< bytes received - uint32_t m_requestedBandwidth; - uint32_t m_grantedBandwidth; - uint32_t m_grantedBandwidthTemp; // Temporary variable used to sort list. Necessary to keep original order + uint32_t m_requestedBandwidth; ///< requested bandwidth + uint32_t m_grantedBandwidth; ///< granted badnwidth + uint32_t m_grantedBandwidthTemp; ///< Temporary variable used to sort list. Necessary to keep original order - /* bandwidth granted since last expiry of minimum reserved traffic rate interval, - /only for nrtPS, to make sure minimum reserved traffic rate is maintained */ + /** bandwidth granted since last expiry of minimum reserved traffic rate interval, + * only for nrtPS, to make sure minimum reserved traffic rate is maintained */ uint32_t m_bwSinceLastExpiry; - Time m_lastGrantTime; - int32_t m_backlogged; - int32_t m_backloggedTemp; + Time m_lastGrantTime; ///< last grant time + int32_t m_backlogged; ///< back logged + int32_t m_backloggedTemp; ///< back logged temp }; diff --git a/src/wimax/model/service-flow.h b/src/wimax/model/service-flow.h index a39cfeece86..dd833c7286b 100644 --- a/src/wimax/model/service-flow.h +++ b/src/wimax/model/service-flow.h @@ -39,39 +39,60 @@ class WimaxConnection; class ServiceFlow { public: + /// Direction enumeration enum Direction { - SF_DIRECTION_DOWN, SF_DIRECTION_UP + SF_DIRECTION_DOWN, + SF_DIRECTION_UP }; + /// Type enumeration enum Type { - SF_TYPE_PROVISIONED, SF_TYPE_ADMITTED, SF_TYPE_ACTIVE + SF_TYPE_PROVISIONED, + SF_TYPE_ADMITTED, + SF_TYPE_ACTIVE }; - // section 11.13.11 Service flow scheduling type, page 701 + /// section 11.13.11 Service flow scheduling type, page 701 enum SchedulingType { - SF_TYPE_NONE = 0, SF_TYPE_UNDEF = 1, SF_TYPE_BE = 2, SF_TYPE_NRTPS = 3, - SF_TYPE_RTPS = 4, SF_TYPE_UGS = 6, SF_TYPE_ALL = 255 + SF_TYPE_NONE = 0, + SF_TYPE_UNDEF = 1, + SF_TYPE_BE = 2, + SF_TYPE_NRTPS = 3, + SF_TYPE_RTPS = 4, + SF_TYPE_UGS = 6, + SF_TYPE_ALL = 255 }; - // section 11.13.19.2 CS parameter encoding rules, page 707 + /// section 11.13.19.2 CS parameter encoding rules, page 707 enum CsSpecification { - ATM = 99, IPV4 = 100, IPV6 = 101, ETHERNET = 102, VLAN = 103, - IPV4_OVER_ETHERNET = 104, IPV6_OVER_ETHERNET = 105, IPV4_OVER_VLAN = 106, + ATM = 99, + IPV4 = 100, + IPV6 = 101, + ETHERNET = 102, + VLAN = 103, + IPV4_OVER_ETHERNET = 104, + IPV6_OVER_ETHERNET = 105, + IPV4_OVER_VLAN = 106, IPV6_OVER_VLAN = 107 }; - enum ModulationType // Table 356 and 362 + /// Modulation type enumeration, Table 356 and 362 + enum ModulationType { - MODULATION_TYPE_BPSK_12, MODULATION_TYPE_QPSK_12, MODULATION_TYPE_QPSK_34, MODULATION_TYPE_QAM16_12, - MODULATION_TYPE_QAM16_34, MODULATION_TYPE_QAM64_23, MODULATION_TYPE_QAM64_34 + MODULATION_TYPE_BPSK_12, + MODULATION_TYPE_QPSK_12, + MODULATION_TYPE_QPSK_34, + MODULATION_TYPE_QAM16_12, + MODULATION_TYPE_QAM16_34, + MODULATION_TYPE_QAM64_23, + MODULATION_TYPE_QAM64_34 }; /** * \brief creates a TLV from this service flow * \return the created tlv - * */ Tlv ToTlv (void) const; /** @@ -92,149 +113,477 @@ class ServiceFlow uint16_t srcPort, uint16_t dstPort, uint8_t proto) const; - ServiceFlow (enum Direction direction); + /// default constructor ServiceFlow (); + /** + * Constructor + * + * \param direction the direction + */ + ServiceFlow (enum Direction direction); + /** + * Constructor + * + * \param sf service flow + */ ServiceFlow (const ServiceFlow & sf); + /** + * Constructor + * + * \param sfid the SFID + * \param direction the direction + * \param connection the connection object + */ ServiceFlow (uint32_t sfid, enum Direction direction, Ptr connection); ~ServiceFlow (void); + /// assignment operator ServiceFlow & operator = (ServiceFlow const& o); + /// Initial values void InitValues (void); + /** + * Set direction + * \param direction the direction value + */ void SetDirection (enum Direction direction); + /** + * Get direction + * \returns the direction + */ enum Direction GetDirection (void) const; + /** + * Copy parameters from another service flow + * \param sf the service flow + */ void CopyParametersFrom (ServiceFlow sf); + /** + * Set type of service flow + * \param type the type value + */ void SetType (enum Type type); + /** + * Get type of service flow + * \returns the type + */ enum Type GetType (void) const; + /** + * Set connection + * \param connection the connection + */ void SetConnection (Ptr connection); - // Can return a null connection is this service flow has not - // been associated yet to a connection. + /** + * Can return a null connection is this service flow has not + * been associated yet to a connection. + * \returns pointer to the WimaxConnection + */ Ptr GetConnection (void) const; + /** + * Set is enabled flag + * \param isEnabled is enabled flag + */ void SetIsEnabled (bool isEnabled); + /** + * Get is enabled flag + * \returns is enabled + */ bool GetIsEnabled (void) const; + /** + * Set service flow record + * \param record pointer to the service flow record + */ void SetRecord (ServiceFlowRecord *record); + /** + * Get service flow record + * \returns pointer to the service flow record + */ ServiceFlowRecord* GetRecord (void) const; // wrapper functions + /** + * Get pointer to queue + * \returns pointer to the wimax mac queue + */ Ptr GetQueue (void) const; + /** + * Get scheduling type + * \returns the scheduling type + */ enum ServiceFlow::SchedulingType GetSchedulingType (void) const; + /** + * Check if packets are present + * \returns true if there are packets + */ bool HasPackets (void) const; + /** + * Check if packets of particular type are present + * \param packetType the packet type to select + * \returns true if there are packets of the packet type + */ bool HasPackets (MacHeaderType::HeaderType packetType) const; - // shall be called only by BS + /// shall be called only by BS void CleanUpQueue (void); + /// Print QOS parameters void PrintQoSParameters (void) const; + /** + * Get scheduling type string + * \returns the name of the scheduling type + */ char* GetSchedulingTypeStr (void) const; + /** + * Get SFID + * \returns the SFID + */ uint32_t GetSfid (void) const; + /** + * Get CID + * \returns the CID + */ uint16_t GetCid (void) const; + /** + * Get service class name + * \returns the service class name + */ std::string GetServiceClassName () const; + /** + * Get QOS parameter set type + * \returns the QOS parameter set type + */ uint8_t GetQosParamSetType (void) const; + /** + * Get traffic priority + * \returns the traffic priority + */ uint8_t GetTrafficPriority (void) const; + /** + * Get max sustained traffic rate + * \returns the maximum sustained traffic rate + */ uint32_t GetMaxSustainedTrafficRate (void) const; + /** + * Get max traffic burst + * \returns the maximum traffic burst + */ uint32_t GetMaxTrafficBurst (void) const; + /** + * Get minimum reserved traffic rate + * \returns the minimum reserved traffic rate + */ uint32_t GetMinReservedTrafficRate (void) const; + /** + * Get minimum tolerable traffic rate + * \returns the minimum tolerable traffic rate + */ uint32_t GetMinTolerableTrafficRate (void) const; + /** + * Get service scheduling type + * \returns the scheduling type + */ enum ServiceFlow::SchedulingType GetServiceSchedulingType (void) const; + /** + * Get request transmission policy + * \returns the request transmission policy + */ uint32_t GetRequestTransmissionPolicy (void) const; + /** + * Get tolerated jitter + * \returns the tolerated jitter + */ uint32_t GetToleratedJitter (void) const; + /** + * Get maximum latency + * \returns the maximum latency + */ uint32_t GetMaximumLatency (void) const; + /** + * Get fixed versus varaiable SDU indicator + * \returns the fixed vs variable SDU indicator + */ uint8_t GetFixedversusVariableSduIndicator (void) const; + /** + * Get SDU size + * \returns the SDU size + */ uint8_t GetSduSize (void) const; + /** + * Get target SAID + * \returns the target SAID + */ uint16_t GetTargetSAID (void) const; + /** + * Get ARQ enable + * \returns the ARQ enable + */ uint8_t GetArqEnable (void) const; + /** + * Get ARQ retry timeout transmit + * \returns the ARQ retry timeout + */ uint16_t GetArqWindowSize (void) const; + /** + * Get ARQ retry timeout transmit + * \returns the ARQ retry timeout transmit + */ uint16_t GetArqRetryTimeoutTx (void) const; + /** + * Get ARQ retry timeout receive + * \returns the ARQ retry timeout receive + */ uint16_t GetArqRetryTimeoutRx (void) const; + /** + * Get ARQ block lifetime + * \returns the ARQ block lifetime + */ uint16_t GetArqBlockLifeTime (void) const; + /** + * Get ARQ sync loss + * \returns the ARQ snyc loss value + */ uint16_t GetArqSyncLoss (void) const; + /** + * Get ARQ deliver in order + * \returns the ARQ deliver in order + */ uint8_t GetArqDeliverInOrder (void) const; + /** + * Get ARQ purge timeout + * \returns the ARQ purge timeout value + */ uint16_t GetArqPurgeTimeout (void) const; + /** + * Get ARQ block size + * \returns the ARQ block size + */ uint16_t GetArqBlockSize (void) const; + /** + * Get CS specification + * \returns the CS specification + */ enum CsSpecification GetCsSpecification (void) const; + /** + * Get convergence sublayer + * \returns the convergence sublayer + */ CsParameters GetConvergenceSublayerParam (void) const; + /** + * Get unsolicited grant interval + * \returns the unsolicited grant interval + */ uint16_t GetUnsolicitedGrantInterval (void) const; + /** + * Get unsolicited polling interval + * \returns the unsolicited polling interval + */ uint16_t GetUnsolicitedPollingInterval (void) const; + /** + * Get is multicast + * \returns the is multicast flag + */ bool GetIsMulticast (void) const; + /** + * Get modulation + * \returns the modulation + */ enum WimaxPhy::ModulationType GetModulation (void) const; - void SetSfid (uint32_t); - void SetServiceClassName (std::string); - void SetQosParamSetType (uint8_t); - void SetTrafficPriority (uint8_t); - void SetMaxSustainedTrafficRate (uint32_t); - void SetMaxTrafficBurst (uint32_t); - void SetMinReservedTrafficRate (uint32_t); - void SetMinTolerableTrafficRate (uint32_t); - void SetServiceSchedulingType (enum ServiceFlow::SchedulingType); - void SetRequestTransmissionPolicy (uint32_t); - void SetToleratedJitter (uint32_t); - void SetMaximumLatency (uint32_t); - void SetFixedversusVariableSduIndicator (uint8_t); - void SetSduSize (uint8_t); - void SetTargetSAID (uint16_t); - void SetArqEnable (uint8_t); - void SetArqWindowSize (uint16_t); - void SetArqRetryTimeoutTx (uint16_t); - void SetArqRetryTimeoutRx (uint16_t); - void SetArqBlockLifeTime (uint16_t); - void SetArqSyncLoss (uint16_t); - void SetArqDeliverInOrder (uint8_t); - void SetArqPurgeTimeout (uint16_t); - void SetArqBlockSize (uint16_t); - void SetCsSpecification (enum CsSpecification); - void SetConvergenceSublayerParam (CsParameters); - - void SetUnsolicitedGrantInterval (uint16_t); - void SetUnsolicitedPollingInterval (uint16_t); + /** + * Set SFID + * \param sfid the SFID + */ + void SetSfid (uint32_t sfid); + /** Set service class name + * \param name the service class name + */ + void SetServiceClassName (std::string name); + /** + * Set QOS parameter set type + * \param type the QOS paraneter set type + */ + void SetQosParamSetType (uint8_t type); + /** + * Set traffic priority + * \param priority the traffic priority + */ + void SetTrafficPriority (uint8_t priority); + /** + * Set max sustained traffic rate + * \param maxSustainedRate the maximum sustained traffic rate + */ + void SetMaxSustainedTrafficRate (uint32_t maxSustainedRate); + /** + * Set maximum traffic burst + * \param maxTrafficBurst the maximum traffic burst + */ + void SetMaxTrafficBurst (uint32_t maxTrafficBurst); + /** + * Set minimum reserved traffic rate + * \param minResvRate the minimum reserved traffic rate + */ + void SetMinReservedTrafficRate (uint32_t minResvRate); + /** + * Set minimum tolerable traffic rate + * \param minJitter the minimum tolerable traffic rate + */ + void SetMinTolerableTrafficRate (uint32_t minJitter); + /** + * Set service scheduling type + * \param schedType the service scheduling type + */ + void SetServiceSchedulingType (enum ServiceFlow::SchedulingType schedType); + /** + * Set request transmission policy + * \param policy the request transmission policy + */ + void SetRequestTransmissionPolicy (uint32_t policy); + /** + * Set tolerated jitter + * \param jitter the tolerated jitter + */ + void SetToleratedJitter (uint32_t jitter); + /** + * Set maximum latency + * \param MaximumLatency the maximjum latency + */ + void SetMaximumLatency (uint32_t MaximumLatency); + /** + * Set fixed versus variable SDU indicator + * \param sduIndicator fixed vs variable SDU indicator + */ + void SetFixedversusVariableSduIndicator (uint8_t sduIndicator); + /** + * Set SDU size + * \param sduSize the SDU size + */ + void SetSduSize (uint8_t sduSize); + /** + * Set target SAID + * \param targetSaid the target SAID value + */ + void SetTargetSAID (uint16_t targetSaid); + /** + * Set ARQ enable + * \param arqEnable the ARQ enable setting + */ + void SetArqEnable (uint8_t arqEnable); + /** + * Set ARQ retry timeout transmit + * \param arqWindowSize the ARQ retry timeout transmit + */ + void SetArqWindowSize (uint16_t arqWindowSize); + /** + * Set ARQ retry timeout transmit + * \param timeout the ARQ retry timeout transmit + */ + void SetArqRetryTimeoutTx (uint16_t timeout); + /** + * Set ARQ retry timeout receive + * \param timeout the timeout + */ + void SetArqRetryTimeoutRx (uint16_t timeout); + /** + * Set ARQ block lifetime + * \param lifeTime the ARQ block life time + */ + void SetArqBlockLifeTime (uint16_t lifeTime); + /** + * Set ARQ sync loss + * \param syncLoss the ARQ sync loss + */ + void SetArqSyncLoss (uint16_t syncLoss); + /** + * Set ARQ deliver in order + * /param inOrder the deliver in order setting + */ + void SetArqDeliverInOrder (uint8_t inOrder); + /** + * Set ARQ purge timeout + * \param timeout the timeout value + */ + void SetArqPurgeTimeout (uint16_t timeout); + /** + * Set ARQ block size + * \param size the size + */ + void SetArqBlockSize (uint16_t size); + /** + * Set CS specification + * \param spec the CS specification + */ + void SetCsSpecification (enum CsSpecification spec); + /** + * Set convergence sublayer parameters + * \param csparam the convergence sublayer parameters + */ + void SetConvergenceSublayerParam (CsParameters csparam); + + /** + * Set unsolicied grant interval + * \param unsolicitedGrantInterval the unsolicited grant interval + */ + void SetUnsolicitedGrantInterval (uint16_t unsolicitedGrantInterval); + /** + * Set unsolicited polling interval + * \param unsolicitedPollingInterval the unsolicited polling interval + */ + void SetUnsolicitedPollingInterval (uint16_t unsolicitedPollingInterval); + /** + * Set is multicast + * \param isMulticast the is multicast flag + */ void SetIsMulticast (bool isMulticast); + /** + * Set modulation + * \param modulationType the modulation type + */ void SetModulation (enum WimaxPhy::ModulationType modulationType); private: - uint32_t m_sfid; - std::string m_serviceClassName; - uint8_t m_qosParamSetType; - uint8_t m_trafficPriority; - uint32_t m_maxSustainedTrafficRate; - uint32_t m_maxTrafficBurst; - uint32_t m_minReservedTrafficRate; - uint32_t m_minTolerableTrafficRate; - enum ServiceFlow::SchedulingType m_schedulingType; - uint32_t m_requestTransmissionPolicy; - uint32_t m_toleratedJitter; - uint32_t m_maximumLatency; - uint8_t m_fixedversusVariableSduIndicator; - uint8_t m_sduSize; - uint16_t m_targetSAID; - uint8_t m_arqEnable; - uint16_t m_arqWindowSize; - uint16_t m_arqRetryTimeoutTx; - uint16_t m_arqRetryTimeoutRx; - uint16_t m_arqBlockLifeTime; - uint16_t m_arqSyncLoss; - uint8_t m_arqDeliverInOrder; - uint16_t m_arqPurgeTimeout; - uint16_t m_arqBlockSize; - enum CsSpecification m_csSpecification; - CsParameters m_convergenceSublayerParam; - uint16_t m_unsolicitedGrantInterval; - uint16_t m_unsolicitedPollingInterval; - Direction m_direction; - Type m_type; - Ptr m_connection; - bool m_isEnabled; - bool m_isMulticast; - enum WimaxPhy::ModulationType m_modulationType; + uint32_t m_sfid; ///< SFID + std::string m_serviceClassName; ///< service class name + uint8_t m_qosParamSetType; ///< QOS parameter type + uint8_t m_trafficPriority; ///< traffic priority + uint32_t m_maxSustainedTrafficRate; ///< maximum sustained traffic rate + uint32_t m_maxTrafficBurst; ///< maximum traffic burst + uint32_t m_minReservedTrafficRate; ///< minimum reserved traffic rate + uint32_t m_minTolerableTrafficRate; ///< minimum tolerable traffic rate + enum ServiceFlow::SchedulingType m_schedulingType; ///< scheduling type + uint32_t m_requestTransmissionPolicy; ///< request transmission policy + uint32_t m_toleratedJitter; ///< tolerated jitter + uint32_t m_maximumLatency; ///< maximum latency + uint8_t m_fixedversusVariableSduIndicator; ///< fixed versus varaible SDI indicator + uint8_t m_sduSize; ///< SDU size + uint16_t m_targetSAID; ///< traget SAID + uint8_t m_arqEnable; ///< ARQ enable + uint16_t m_arqWindowSize; ///< ARQ window size + uint16_t m_arqRetryTimeoutTx; ///< ARQ retry timeout transmit + uint16_t m_arqRetryTimeoutRx; ///< ARQ retry timeout receive + uint16_t m_arqBlockLifeTime; ///< ARQ block life time + uint16_t m_arqSyncLoss; ///< ARQ sync loss + uint8_t m_arqDeliverInOrder; ///< ARQ deliver in order + uint16_t m_arqPurgeTimeout; ///< ARQ purge timeout + uint16_t m_arqBlockSize; ///< ARQ block size + enum CsSpecification m_csSpecification; ///< CS specification + CsParameters m_convergenceSublayerParam; ///< convergence sublayer parameters + uint16_t m_unsolicitedGrantInterval; ///< unsolicited grant interval + uint16_t m_unsolicitedPollingInterval; ///< unsolicited polling interval + Direction m_direction; ///< direction + Type m_type; ///< type + Ptr m_connection; ///< connection + bool m_isEnabled; ///< is enabled? + bool m_isMulticast; ///< is multicast? + enum WimaxPhy::ModulationType m_modulationType; ///< modulation type // will be used by the BS - ServiceFlowRecord *m_record; + ServiceFlowRecord *m_record; ///< service flow record }; } // namespace ns3 diff --git a/src/wimax/model/simple-ofdm-send-param.h b/src/wimax/model/simple-ofdm-send-param.h index d3500f96743..be62b4213df 100644 --- a/src/wimax/model/simple-ofdm-send-param.h +++ b/src/wimax/model/simple-ofdm-send-param.h @@ -32,15 +32,38 @@ namespace ns3 { /** * \ingroup wimax + * simpleOfdmSendParam class */ class simpleOfdmSendParam { public: simpleOfdmSendParam (void); + /** + * Constructor + * + * \param fecBlock FEC block + * \param burstSize burst size + * \param isFirstBlock is the first block + * \param Frequency frequency + * \param modulationType modulation type + * \param direction the direction + * \param rxPowerDbm receive power + */ simpleOfdmSendParam (const bvec &fecBlock, uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPowerDbm); + /** + * Constructor + * + * \param burstSize burst size + * \param isFirstBlock is the first block + * \param Frequency frequency + * \param modulationType modulation type + * \param direction the direction + * \param rxPowerDbm receive power + * \param burst packet burst object + */ simpleOfdmSendParam (uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, WimaxPhy::ModulationType modulationType, uint8_t direction, @@ -110,14 +133,14 @@ class simpleOfdmSendParam Ptr GetBurst (void); private: - bvec m_fecBlock; - uint32_t m_burstSize; - bool m_isFirstBlock; - uint64_t m_frequency; - WimaxPhy::ModulationType m_modulationType; - uint8_t m_direction; - double m_rxPowerDbm; - Ptr m_burst; + bvec m_fecBlock; ///< FEC block + uint32_t m_burstSize; ///< burst size + bool m_isFirstBlock; ///< is frist block + uint64_t m_frequency; ///< frequency + WimaxPhy::ModulationType m_modulationType; ///< modulation type + uint8_t m_direction; ///< direction + double m_rxPowerDbm; ///< receive power dbM + Ptr m_burst; ///< burst }; } // namespace ns3 diff --git a/src/wimax/model/simple-ofdm-wimax-channel.h b/src/wimax/model/simple-ofdm-wimax-channel.h index 173ac2a7dc8..fc9ab69de3b 100644 --- a/src/wimax/model/simple-ofdm-wimax-channel.h +++ b/src/wimax/model/simple-ofdm-wimax-channel.h @@ -37,6 +37,7 @@ class SimpleOfdmWimaxPhy; /** * \ingroup wimax + * \brief SimpleOfdmWimaxChannel class */ class SimpleOfdmWimaxChannel : public WimaxChannel { @@ -44,6 +45,7 @@ class SimpleOfdmWimaxChannel : public WimaxChannel SimpleOfdmWimaxChannel (void); ~SimpleOfdmWimaxChannel (void); + /// PropModel enumeration enum PropModel { RANDOM_PROPAGATION, @@ -99,12 +101,30 @@ class SimpleOfdmWimaxChannel : public WimaxChannel int64_t AssignStreams (int64_t stream); private: + /** + * Attach functiion + * \param phy the phy layer + */ void DoAttach (Ptr phy); - std::list > m_phyList; + std::list > m_phyList; ///< phy list + /** + * Get number of devices function + * \returns the number of devices + */ uint32_t DoGetNDevices (void) const; + /** + * End send dummy block function + * \param rxphy the Ptr + * \param param the simpleOfdmSendParam * + */ void EndSendDummyBlock (Ptr rxphy, simpleOfdmSendParam * param); + /** + * Get device function + * \param i the device index + * \returns the device + */ Ptr DoGetDevice (uint32_t i) const; - Ptr m_loss; + Ptr m_loss; ///< loss }; } // namespace ns3 diff --git a/src/wimax/model/simple-ofdm-wimax-phy.h b/src/wimax/model/simple-ofdm-wimax-phy.h index be5248fde63..b2e787fa4cc 100644 --- a/src/wimax/model/simple-ofdm-wimax-phy.h +++ b/src/wimax/model/simple-ofdm-wimax-phy.h @@ -42,18 +42,34 @@ class SimpleOfdmWimaxChannel; /** * \ingroup wimax + * \brief SimpleOfdmWimaxPhy class */ class SimpleOfdmWimaxPhy : public WimaxPhy { public: + /// Frame duration code enumeration enum FrameDurationCode { - FRAME_DURATION_2_POINT_5_MS, FRAME_DURATION_4_MS, FRAME_DURATION_5_MS, FRAME_DURATION_8_MS, FRAME_DURATION_10_MS, - FRAME_DURATION_12_POINT_5_MS, FRAME_DURATION_20_MS + FRAME_DURATION_2_POINT_5_MS, + FRAME_DURATION_4_MS, + FRAME_DURATION_5_MS, + FRAME_DURATION_8_MS, + FRAME_DURATION_10_MS, + FRAME_DURATION_12_POINT_5_MS, + FRAME_DURATION_20_MS }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); SimpleOfdmWimaxPhy (void); + /** + * Constructor + * + * \param tracesPath trace path + */ SimpleOfdmWimaxPhy (char * tracesPath); ~SimpleOfdmWimaxPhy (void); /** @@ -85,6 +101,7 @@ class SimpleOfdmWimaxPhy : public WimaxPhy void Send (Ptr burst, WimaxPhy::ModulationType modulationType, uint8_t direction); /** * \brief Sends a burst on the channel + * \param params parameters * \see SendParams */ void Send (SendParams *params); @@ -143,36 +160,42 @@ class SimpleOfdmWimaxPhy : public WimaxPhy /** * Public method used to fire a PhyTxBegin trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyTxBegin (Ptr burst); /** * Public method used to fire a PhyTxEnd trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyTxEnd (Ptr burst); /** * Public method used to fire a PhyTxDrop trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyTxDrop (Ptr burst); /** * Public method used to fire a PhyRxBegin trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyRxBegin (Ptr burst); /** * Public method used to fire a PhyRxEnd trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyRxEnd (Ptr burst); /** * Public method used to fire a PhyRxDrop trace. Implemented for encapsulation * purposes. + * \param burst the packet burst */ void NotifyRxDrop (Ptr burst); @@ -187,87 +210,263 @@ class SimpleOfdmWimaxPhy : public WimaxPhy int64_t AssignStreams (int64_t stream); private: + /** + * Get transmission time + * \param size the size + * \param modulationType the modulation type + * \returns the transmission time + */ Time DoGetTransmissionTime (uint32_t size, WimaxPhy::ModulationType modulationType) const; + /** + * Get number of symbols + * \param size the size + * \param modulationType the modulation type + * \returns the number of symbols + */ uint64_t DoGetNrSymbols (uint32_t size, WimaxPhy::ModulationType modulationType) const; + /** + * Get number of bytes + * \param symbols the symbols + * \param modulationType the modulation type + * \returns the number of bytes + */ uint64_t DoGetNrBytes (uint32_t symbols, WimaxPhy::ModulationType modulationType) const; + /** + * Convert burst to bits + * \param burst the packet burst + * \returns the BVEC + */ bvec ConvertBurstToBits (Ptr burst); + /** + * Convert bits to burst + * \param buffer the BVEC + * \returns the packet burst + */ Ptr ConvertBitsToBurst (bvec buffer); + /** + * Create FEC blocks + * \param buffer the BVEC + * \param modulationType the modulation type + */ void CreateFecBlocks (const bvec &buffer, WimaxPhy::ModulationType modulationType); + /** + * Recreate buffer + * \returns BVEC + */ bvec RecreateBuffer (); + /** + * Get FEC block size + * \param type the modulation type + * \returns the FEC block size + */ uint32_t GetFecBlockSize (WimaxPhy::ModulationType type) const; + /** + * Get coded FEC block size + * \param modulationType the modulation type + * \returns the coded FEC block size + */ uint32_t GetCodedFecBlockSize (WimaxPhy::ModulationType modulationType) const; + /** + * Set block parameters + * \param burstSize the burst size + * \param modulationType the modulation type + */ void SetBlockParameters (uint32_t burstSize, WimaxPhy::ModulationType modulationType); + /** + * Get number of blocks + * \param burstSize the burst size + * \param modulationType the modulation type + * \returns the number of blocks + */ uint16_t GetNrBlocks (uint32_t burstSize, WimaxPhy::ModulationType modulationType) const; void DoDispose (void); + /// End send void EndSend (void); + /** + * End send FEC block + * \param modulationType the modulation type + * \param direction the direction + */ void EndSendFecBlock (WimaxPhy::ModulationType modulationType, uint8_t direction); + /** + * End receive + * \param burst + */ void EndReceive (Ptr burst); + /** + * End receive FEC block + * \param burstSize the burst size + * \param modulationType the modulation type + * \param direction the direction + * \param drop the drop + * \param burst the burst + */ void EndReceiveFecBlock (uint32_t burstSize, WimaxPhy::ModulationType modulationType, uint8_t direction, uint8_t drop, Ptr burst); + /** + * Start end dummy FEC block + * \param isFirstBlock is the first block? + * \param modulationType the modulation type + * \param direction the direction + */ void StartSendDummyFecBlock (bool isFirstBlock, WimaxPhy::ModulationType modulationType, uint8_t direction); + /** + * Get block transmission time + * \param modulationType the modulation type + * \returns the block transmission time + */ Time GetBlockTransmissionTime (WimaxPhy::ModulationType modulationType) const; + /// Set data rates void DoSetDataRates (void); + /// Initialize simple OFDM WIMAX Phy void InitSimpleOfdmWimaxPhy (void); + /** + * Get moduleation FEC parameters + * \param modulationType the modulation type + * \param bitsPerSymbol the number of bits per symbol + * \param fecCode the FEC code + */ void GetModulationFecParams (WimaxPhy::ModulationType modulationType, uint8_t &bitsPerSymbol, double &fecCode) const; + /** + * Calculate data rate + * \param modulationType the modulation type + * \returns the data rate + */ uint32_t CalculateDataRate (WimaxPhy::ModulationType modulationType) const; + /** + * Get data rate + * \param modulationType the modulation type + * \returns the data rate + */ uint32_t DoGetDataRate (WimaxPhy::ModulationType modulationType) const; + /** + * Get TTG + * \returns the TTG + */ uint16_t DoGetTtg (void) const; + /** + * Get RTG + * \returns the RTG + */ uint16_t DoGetRtg (void) const; + /** + * Get frame duration code + * \returns the frame duration code + */ uint8_t DoGetFrameDurationCode (void) const; + /** + * Get frame duration + * \param frameDurationCode the frame duration code + * \returns the frame duration + */ Time DoGetFrameDuration (uint8_t frameDurationCode) const; + /// Set Phy parameters void DoSetPhyParameters (void); + /** + * Get NFFT + * \returns the NFFT + */ uint16_t DoGetNfft (void) const; - void DoSetNfft (uint16_t); + /** + * Set NFFT + * \param nfft the NFFT + */ + void DoSetNfft (uint16_t nfft); + /** + * Get sampling factor + * \returns the sampling factor + */ double DoGetSamplingFactor (void) const; + /** + * Get sampling frequency + * \returns the sampling frequency + */ double DoGetSamplingFrequency (void) const; + /** + * Get G value + * \returns the G value + */ double DoGetGValue (void) const; - void DoSetGValue (double); + /** + * Set G value + * \param g the G value + */ + void DoSetGValue (double g); + /** + * Get receive gain + * \returns the receive gain + */ double GetRxGain (void) const; + /** + * Set receive gsain + * \param rxgain the receive gain + */ void SetRxGain (double rxgain); + /** + * Get transmit gain + * \returns the transmit gain + */ double GetTxGain (void) const; + /** + * Set transmit gain + * \param txgain the transmit gain + */ void SetTxGain (double txgain); + /** + * Get trace file path + * \returns the trace file path name + */ std::string GetTraceFilePath (void) const; + /** + * Set trace file path + * \param path the trace file path + */ void SetTraceFilePath (std::string path); - uint16_t m_fecBlockSize; // in bits, size of FEC block transmitted after PHY operations - uint32_t m_currentBurstSize; + uint16_t m_fecBlockSize; ///< in bits, size of FEC block transmitted after PHY operations + uint32_t m_currentBurstSize; ///< current burst size - std::list *m_receivedFecBlocks; // a list of received FEC blocks until they are combined to recreate the full burst buffer - uint32_t m_nrFecBlocksSent; // counting the number of FEC blocks sent (within a burst) - std::list *m_fecBlocks; - Time m_blockTime; + std::list *m_receivedFecBlocks; ///< a list of received FEC blocks until they are combined to recreate the full burst buffer + uint32_t m_nrFecBlocksSent; ///< counting the number of FEC blocks sent (within a burst) + std::list *m_fecBlocks; ///< the FEC blocks + Time m_blockTime; ///< block time - TracedCallback > m_traceRx; - TracedCallback > m_traceTx; + TracedCallback > m_traceRx; ///< trace receive callback + TracedCallback > m_traceTx; ///< trace transmit callback // data rates for this Phy - uint32_t m_dataRateBpsk12, m_dataRateQpsk12, m_dataRateQpsk34, m_dataRateQam16_12, m_dataRateQam16_34, - m_dataRateQam64_23, m_dataRateQam64_34; + uint32_t m_dataRateBpsk12; ///< data rate + uint32_t m_dataRateQpsk12; ///< data rate + uint32_t m_dataRateQpsk34; ///< data rate + uint32_t m_dataRateQam16_12; ///< data rate + uint32_t m_dataRateQam16_34; ///< data rate + uint32_t m_dataRateQam64_23; ///< data rate + uint32_t m_dataRateQam64_34; ///< data rate // parameters to store for a per burst life-time - uint16_t m_nrBlocks; - uint16_t m_nrRemainingBlocksToSend; - Ptr m_currentBurst; - uint16_t m_blockSize; - uint32_t m_paddingBits; - uint16_t m_nbErroneousBlock; - uint16_t m_nrRecivedFecBlocks; - uint16_t m_nfft; - double m_g; - double m_bandWidth; - double m_txPower; - double m_noiseFigure; - double m_txGain; - double m_rxGain; + uint16_t m_nrBlocks; ///< number of blocks + uint16_t m_nrRemainingBlocksToSend; ///< number of remaining blocks to send + Ptr m_currentBurst; ///< current burst + uint16_t m_blockSize; ///< block size + uint32_t m_paddingBits; ///< padding bits + uint16_t m_nbErroneousBlock; ///< erroneous blocks + uint16_t m_nrRecivedFecBlocks; ///< number received FEC blocks + uint16_t m_nfft; ///< NFFT + double m_g; ///< G value + double m_bandWidth; ///< bandwidth + double m_txPower; ///< transmit power + double m_noiseFigure; ///< noise figure + double m_txGain; ///< transmit gain + double m_rxGain; ///< receive gain /** * The trace source fired when a packet begins the transmission process on * the medium. @@ -327,10 +526,10 @@ class SimpleOfdmWimaxPhy : public WimaxPhy */ TracedCallback > m_phyRxDropTrace; - SNRToBlockErrorRateManager * m_snrToBlockErrorRateManager; + SNRToBlockErrorRateManager * m_snrToBlockErrorRateManager; ///< SNR to block error rate manager /// Provides uniform random variables. - Ptr m_URNG; + Ptr m_URNG; ///< URNG }; diff --git a/src/wimax/model/snr-to-block-error-rate-manager.h b/src/wimax/model/snr-to-block-error-rate-manager.h index d0c9b8a3244..6ef13e6a9d8 100644 --- a/src/wimax/model/snr-to-block-error-rate-manager.h +++ b/src/wimax/model/snr-to-block-error-rate-manager.h @@ -100,12 +100,14 @@ class SNRToBlockErrorRateManager */ void ActivateLoss (bool loss); private: + /// Clear records function void ClearRecords (void); - uint8_t m_activateLoss; + uint8_t m_activateLoss; ///< activate loss + /// trace file path size static const unsigned int TRACE_FILE_PATH_SIZE = 1024; - char m_traceFilePath[TRACE_FILE_PATH_SIZE]; + char m_traceFilePath[TRACE_FILE_PATH_SIZE]; ///< trace file path - std::vector * m_recordModulation[7]; + std::vector * m_recordModulation[7]; ///< record modulation }; } diff --git a/src/wimax/model/snr-to-block-error-rate-record.h b/src/wimax/model/snr-to-block-error-rate-record.h index ed808bd5846..d769d0902c6 100644 --- a/src/wimax/model/snr-to-block-error-rate-record.h +++ b/src/wimax/model/snr-to-block-error-rate-record.h @@ -100,12 +100,12 @@ class SNRToBlockErrorRateRecord void SetI2 (double); private: - double m_snrValue; - double m_bitErrorRate; - double m_blockErrorRate; - double m_sigma2; - double m_i1; // The lower boundary of the confidence interval - double m_i2; // The upper boundary of the confidence interval + double m_snrValue; ///< SNR vaue + double m_bitErrorRate; ///< bit error rate + double m_blockErrorRate; ///< block error rate + double m_sigma2; ///< sigma2 + double m_i1; ///< The lower boundary of the confidence interval + double m_i2; ///< The upper boundary of the confidence interval }; } diff --git a/src/wimax/model/ss-link-manager.h b/src/wimax/model/ss-link-manager.h index d00d04ada3c..45de54d34b0 100644 --- a/src/wimax/model/ss-link-manager.h +++ b/src/wimax/model/ss-link-manager.h @@ -41,75 +41,172 @@ namespace ns3 { class SSLinkManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param ss subscriber station device + */ SSLinkManager (Ptr ss); ~SSLinkManager (void); void DoDispose (void); + /** + * Set BS EIRP + * \param bs_eirp the BS EIRP + */ void SetBsEirp (uint16_t bs_eirp); + /** + * Set EIRX IR maximum + * \param eir_x_p_ir_max the EIRX IR maximum + */ void SetEirXPIrMax (uint16_t eir_x_p_ir_max); + /** + * Set ranging interval found + * \param rangingIntervalFound the ranging interval found + */ void SetRangingIntervalFound (bool rangingIntervalFound); + /** + * Get ranging interval found + * \returns the ranging interval found + */ bool GetRangingIntervalFound (void) const; + /** + * Ser NR ranging trans opps + * \param nrRangingTransOpps the NR ranging trans opps + */ void SetNrRangingTransOpps (uint8_t nrRangingTransOpps); + /** + * Set ranging CW + * \param rangingCW the ranging CW + */ void SetRangingCW (uint8_t rangingCW); + /// Increment NR invited polls received void IncrementNrInvitedPollsRecvd (void); + /** + * Get DL map sync timeput event + * \returns the event ID + */ EventId GetDlMapSyncTimeoutEvent (void); + /** + * Perform ranging + * \param cid the CID + * \param rngrsp the ranging response + */ void PerformRanging (Cid cid, RngRsp rngrsp); + /** + * Start scanning + * \param type the event type + * \param deleteParameters the delete parameters + */ void StartScanning (SubscriberStationNetDevice::EventType type, bool deleteParameters); + /** + * Send ranging request + * \param uiuc the UIUC + * \param allocationSize the allocation size + */ void SendRangingRequest (uint8_t uiuc, uint16_t allocationSize); + /// Start contention resolution void StartContentionResolution (void); + /// Perfrom backoff void PerformBackoff (void); + /** + * Is UL channel usable + * \returns the UL channel usable flag + */ bool IsUlChannelUsable (void); + /** + * Schedule scanning request + * \param interval the scanning request interval + * \param eventType event type + * \param deleteUlParameters the delete UL parameters + * \param eventId the event ID + */ void ScheduleScanningRestart (Time interval, SubscriberStationNetDevice::EventType eventType, bool deleteUlParameters, EventId &eventId); private: + /// type conversion operator SSLinkManager (const SSLinkManager &); + /// assignment operator SSLinkManager & operator= (const SSLinkManager &); + /** + * End scanning + * \param status the end status + * \param frequency the frequency + */ void EndScanning (bool status, uint64_t frequency); + /// Start synchronizing void StartSynchronizing (void); + /** + * Search for DL channel + * \param channel the DL channel + * \returns true if found + */ bool SearchForDlChannel (uint8_t channel); + /// Select random backoff void SelectRandomBackoff (void); + /// Increase rnaging request CW void IncreaseRangingRequestCW (void); + /// Reset ranging request CW void ResetRangingRequestCW (void); + /// Delete uplink parameters void DeleteUplinkParameters (void); + /** + * Adjust ranging parameters + * \param rngrsp the ranging response + */ void AdjustRangingParameters (const RngRsp &rngrsp); + /// Negotiate basic capabilities void NegotiateBasicCapabilities (void); + /** + * Calculate maximum IR signal strength + * \returns the maximum IR signal strength + */ uint16_t CalculateMaxIRSignalStrength (void); + /** + * Get minimum transmit power level + * \returns the minimum transmit power level + */ uint16_t GetMinTransmitPowerLevel (void); - Ptr m_ss; + Ptr m_ss; ///< subscriber station device - WimaxNetDevice::RangingStatus m_rangingStatus; + WimaxNetDevice::RangingStatus m_rangingStatus; ///< ranging status // initial ranging parameters obtained from DCD (in channel encodings) - uint16_t m_bsEirp; - uint16_t m_eirXPIrMax; // initial ranging maximum equivalent isotropic received power at BS - uint16_t m_pTxIrMax; // maximum transmit signal strength for initial ranging calculated by SS + uint16_t m_bsEirp; ///< BS EIRP + uint16_t m_eirXPIrMax; ///< initial ranging maximum equivalent isotropic received power at BS + uint16_t m_pTxIrMax; ///< maximum transmit signal strength for initial ranging calculated by SS - uint8_t m_initRangOppNumber; // Initial Ranging opportunity (1–255) in which SS transmitted the RNG_REQ - uint8_t m_contentionRangingRetries; - uint32_t m_rngReqFrameNumber; // frame number in which SS sent RNG_REQ message - RngReq m_rngreq; + uint8_t m_initRangOppNumber; ///< Initial Ranging opportunity (1–255) in which SS transmitted the RNG_REQ + uint8_t m_contentionRangingRetries; ///< contention ranging retries + uint32_t m_rngReqFrameNumber; ///< frame number in which SS sent RNG_REQ message + RngReq m_rngreq; ///< rng request - uint8_t m_dlChnlNr; // indicates the channel/frequency currently the SS is scanning - uint64_t m_frequency; // frequency on which it is currently operating, i.e., where scanning was successful - bool m_rangingIntervalFound; + uint8_t m_dlChnlNr; ///< indicates the channel/frequency currently the SS is scanning + uint64_t m_frequency; ///< frequency on which it is currently operating, i.e., where scanning was successful + bool m_rangingIntervalFound; ///< ranging interval found // stats members - uint16_t m_nrRngReqsSent; - uint16_t m_nrRngRspsRecvd; - uint16_t m_nrInvitedPollsRecvd; - - uint8_t m_rangingCW; - uint8_t m_rangingBO; - uint8_t m_nrRangingTransOpps; - bool m_isBackoffSet; - uint8_t m_rangingAnomalies; - - EventId m_waitForRngRspEvent, m_dlMapSyncTimeoutEvent; + uint16_t m_nrRngReqsSent; ///< number rang requests sent + uint16_t m_nrRngRspsRecvd; ///< number rang responses received + uint16_t m_nrInvitedPollsRecvd; ///< number invited polls received + + uint8_t m_rangingCW; ///< ranging CW + uint8_t m_rangingBO; ///< ranging BO + uint8_t m_nrRangingTransOpps; ///< number ranging trans opps + bool m_isBackoffSet; ///< is backoff set + uint8_t m_rangingAnomalies; ///< ranging anomalies + + EventId m_waitForRngRspEvent; ///< wait for rang response event + EventId m_dlMapSyncTimeoutEvent; ///< DL map sync timeout event }; } // namespace ns3 diff --git a/src/wimax/model/ss-manager.h b/src/wimax/model/ss-manager.h index 1a6410045a1..fda595c1962 100644 --- a/src/wimax/model/ss-manager.h +++ b/src/wimax/model/ss-manager.h @@ -31,16 +31,30 @@ namespace ns3 { /** * \ingroup wimax - * \brief this class manages a list of SSrecord + * \brief this class manages a list of SSrecords * \see SSrecord */ class SSManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); SSManager (void); ~SSManager (void); + /** + * Create SS record + * \param macAddress the MAC address + * \returns pointer to the SS record + */ SSRecord* CreateSSRecord (const Mac48Address &macAddress); + /** + * Get SS record + * \param macAddress the MAC address + * \returns pointer to the SS record + */ SSRecord* GetSSRecord (const Mac48Address &macAddress) const; /** * \brief returns the ssrecord which has been assigned this cid. Since @@ -48,18 +62,49 @@ class SSManager : public Object * different values, all cids (basic, primary and transport) of the * ssrecord are matched. * \param cid the cid to be matched - * \return the ss record that has the cid + * \return pointer to the ss record matching the cid */ SSRecord* GetSSRecord (Cid cid) const; + /** + * Get SS records + * \returns a vector of pointers to the SS records + */ std::vector* GetSSRecords (void) const; + /** + * Check if address is in record + * \param macAddress the MAC address + * \returns whether the address is in the record + */ bool IsInRecord (const Mac48Address &macAddress) const; + /** + * Check if address is registered + * \param macAddress the MAC address + * \returns whether the address is registered + */ bool IsRegistered (const Mac48Address &macAddress) const; + /** + * Delete SS record + * \param cid the CID + */ void DeleteSSRecord (Cid cid); + /** + * Get MAC address by CID + * \param cid the CID + * \returns the MAC address + */ Mac48Address GetMacAddress (Cid cid) const; + /** + * Get number of SSs + * \returns the number of SSs + */ uint32_t GetNSSs (void) const; + /** + * Get number of registered SSs + * \returns the number of registered SSs + */ uint32_t GetNRegisteredSSs (void) const; private: - std::vector *m_ssRecords; + std::vector *m_ssRecords; ///< the SS records }; } // namespace ns3 diff --git a/src/wimax/model/ss-net-device.cc b/src/wimax/model/ss-net-device.cc index ed5c4c08b91..a72476eb0fe 100644 --- a/src/wimax/model/ss-net-device.cc +++ b/src/wimax/model/ss-net-device.cc @@ -1263,12 +1263,12 @@ SubscriberStationNetDevice::IsRegistered (void) const } Time -SubscriberStationNetDevice::GetTimeToAllocation (Time defferTime) +SubscriberStationNetDevice::GetTimeToAllocation (Time deferTime) { Time timeAlreadyElapsed = Simulator::Now () - m_frameStartTime; Time timeToUlSubframe = Seconds (m_allocationStartTime * GetPhy ()->GetPsDuration ().GetSeconds ()) - timeAlreadyElapsed; - return timeToUlSubframe + defferTime; + return timeToUlSubframe + deferTime; } void diff --git a/src/wimax/model/ss-net-device.h b/src/wimax/model/ss-net-device.h index 24748d45dcf..36858f09d08 100644 --- a/src/wimax/model/ss-net-device.h +++ b/src/wimax/model/ss-net-device.h @@ -43,28 +43,53 @@ class IpcsClassifier; /** * \ingroup wimax + * SubscriberStationNetDevice subclass of WimaxNetDevice */ class SubscriberStationNetDevice : public WimaxNetDevice { public: + /// State enumeration enum State { - SS_STATE_IDLE, SS_STATE_SCANNING, SS_STATE_SYNCHRONIZING, SS_STATE_ACQUIRING_PARAMETERS, + SS_STATE_IDLE, + SS_STATE_SCANNING, + SS_STATE_SYNCHRONIZING, + SS_STATE_ACQUIRING_PARAMETERS, SS_STATE_WAITING_REG_RANG_INTRVL, // regular ranging interval SS_STATE_WAITING_INV_RANG_INTRVL, // invited ranging interval - SS_STATE_WAITING_RNG_RSP, SS_STATE_ADJUSTING_PARAMETERS, SS_STATE_REGISTERED, SS_STATE_TRANSMITTING, // currently not being used anywhere + SS_STATE_WAITING_RNG_RSP, + SS_STATE_ADJUSTING_PARAMETERS, + SS_STATE_REGISTERED, + SS_STATE_TRANSMITTING, // currently not being used anywhere SS_STATE_STOPPED }; + /// EventType enumeration enum EventType { - EVENT_NONE, EVENT_WAIT_FOR_RNG_RSP, EVENT_DL_MAP_SYNC_TIMEOUT, EVENT_LOST_DL_MAP, EVENT_LOST_UL_MAP, - EVENT_DCD_WAIT_TIMEOUT, EVENT_UCD_WAIT_TIMEOUT, EVENT_RANG_OPP_WAIT_TIMEOUT + EVENT_NONE, + EVENT_WAIT_FOR_RNG_RSP, + EVENT_DL_MAP_SYNC_TIMEOUT, + EVENT_LOST_DL_MAP, + EVENT_LOST_UL_MAP, + EVENT_DCD_WAIT_TIMEOUT, + EVENT_UCD_WAIT_TIMEOUT, + EVENT_RANG_OPP_WAIT_TIMEOUT }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); SubscriberStationNetDevice (void); - SubscriberStationNetDevice (Ptr, Ptr ); + /** + * Constructor + * + * \param node the node + * \param phy the wimax phy + */ + SubscriberStationNetDevice (Ptr node, Ptr phy); ~SubscriberStationNetDevice (void); /** @@ -75,7 +100,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice * \param lostDlMapInterval time since last received DL-MAP message before downlink synchronization is considered lost */ void SetLostDlMapInterval (Time lostDlMapInterval); - /* + /** * \returns the time since last received DL-MAP message before downlink synchronization is considered lost */ Time GetLostDlMapInterval (void) const; @@ -84,7 +109,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetLostUlMapInterval (Time lostUlMapInterval); /** - * returns the time since last received UL-MAP before uplink synchronization is considered lost + * \returns the time since last received UL-MAP before uplink synchronization is considered lost */ Time GetLostUlMapInterval (void) const; /** @@ -92,7 +117,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetMaxDcdInterval (Time maxDcdInterval); /** - * returns the maximum time between transmission of DCD messages + * \returns the maximum time between transmission of DCD messages */ Time GetMaxDcdInterval (void) const; /** @@ -100,15 +125,15 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetMaxUcdInterval (Time maxUcdInterval); /** - * returns the maximum time between transmission of UCD messages + * \returns the maximum time between transmission of UCD messages */ Time GetMaxUcdInterval (void) const; /** - * \param interval1 Wait for DCD timeout + * \param interval1 Wait for DCD timeout value */ void SetIntervalT1 (Time interval1); /** - * returns the wait for DCD timeout + * \returns the wait for DCD timeout */ Time GetIntervalT1 (void) const; /** @@ -116,7 +141,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT2 (Time interval2); /** - * returns the wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity + * \returns the wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity */ Time GetIntervalT2 (void) const; /** @@ -124,7 +149,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT3 (Time interval3); /** - * returns the ranging Response reception timeout following the transmission of a ranging request + * \returns the ranging Response reception timeout following the transmission of a ranging request */ Time GetIntervalT3 (void) const; /** @@ -132,7 +157,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT7 (Time interval7); /** - * returns the wait for DSA/DSC/DSD Response timeout + * \returns the wait for DSA/DSC/DSD Response timeout */ Time GetIntervalT7 (void) const; /** @@ -140,7 +165,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT12 (Time interval12); /** - * returns the wait for UCD descriptor timeout + * \returns the wait for UCD descriptor timeout */ Time GetIntervalT12 (void) const; /** @@ -148,7 +173,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT20 (Time interval20); /** - * returns the Time the SS searches for preambles on a given channel + * \returns the Time the SS searches for preambles on a given channel */ Time GetIntervalT20 (void) const; /** @@ -156,7 +181,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetIntervalT21 (Time interval21); /** - * returns the time the SS searches for (decodable) DL-MAP on a given channel + * \returns the time the SS searches for (decodable) DL-MAP on a given channel */ Time GetIntervalT21 (void) const; /** @@ -180,7 +205,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetPrimaryConnection (Ptr primaryConnection); /** - * returns the primary connection currently usde + * \returns the primary connection currently used */ Ptr GetPrimaryConnection (void) const; /** @@ -198,7 +223,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetModulationType (WimaxPhy::ModulationType modulationType); /** - * returns the most efficient modulation and coding scheme (MCS) supported by the device + * /returns the most efficient modulation and coding scheme (MCS) supported by the device */ WimaxPhy::ModulationType GetModulationType (void) const; /** @@ -234,126 +259,187 @@ class SubscriberStationNetDevice : public WimaxNetDevice * \param packet the packet to be enqueued * \param hdrType the mac header type to be appended to the packet * \param connection the connection to be used + * \returns true if successful */ bool Enqueue (Ptr packet, const MacHeaderType &hdrType, Ptr connection); /** * \brief Sends a burst on the uplink frame + * \param uiuc theOfdmUlBurstProfile + * \param nrSymbols number of symbols + * \param connection connection to use + * \param packetType optional HeaderType (default HEADER_TYPE_GENERIC) */ void SendBurst (uint8_t uiuc, uint16_t nrSymbols, Ptr connection, MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC); + /** + * \brief Start the device + */ void Start (void); + /** + * \brief Stop the device + */ void Stop (void); /** * \brief adds a new service flow + * \param sf pointer to service flow to add */ void AddServiceFlow (ServiceFlow *sf); /** * \brief adds a new service flow + * \param sf service flow to add */ void AddServiceFlow (ServiceFlow sf); + /** + * \brief Set timer. If in stopped state, the EventId passed in the first + * argument will be cancelled. If not, the second parameter will be set + * to the value of the first parameter. + * + * \param eventId EventId to cancel or to map to the second argument + * \param event EventId is set to first argument if not in stopped state + */ void SetTimer (EventId eventId, EventId &event); /** * \returns true if the SS is registered to a BS, false otherwise */ bool IsRegistered (void) const; - Time GetTimeToAllocation (Time defferTime); + /** + * \brief Get time to allocation + * \param deferTime defer time + */ + Time GetTimeToAllocation (Time deferTime); - Ptr m_linkManager; + Ptr m_linkManager; ///< link manager /** * \returns a pointer to the CS packet classifier */ Ptr GetIpcsClassifier () const; /** * \brief Sets the packet classifier to be used + * \param classifier the classifier to use */ - void SetIpcsPacketClassifier (Ptr ); + void SetIpcsPacketClassifier (Ptr classifier); /** - * \returns a pointer to the link manger currently used + * \returns a pointer to the link manager currently used */ Ptr GetLinkManager (void) const; /** * \brief sets the link manager to be used + * \param linkManager link manager to use */ - void SetLinkManager (Ptr ); + void SetLinkManager (Ptr linkManager); /** * \returns a pointer to the service flow manager installed on the device */ Ptr GetServiceFlowManager (void) const; /** * \brief Sets the service flow manager to be installed on the device + * \param sfm service flow manager to be used */ - void SetServiceFlowManager (Ptr ); + void SetServiceFlowManager (Ptr sfm); private: + /** + * Get default lost DL map interval + * \returns the default lost DL map interval + */ static Time GetDefaultLostDlMapInterval (); void DoDispose (void); + /** + * Send a packet + * \param packet the packet to send + * \param source the source MAC address + * \param dest the destination MAC address + * \param protocolNumber the protocol number + * \returns true if successful + */ bool DoSend (Ptr packet, const Mac48Address &source, const Mac48Address &dest, uint16_t protocolNumber); + /** + * Receive a packet + * \param packet the packet received + */ void DoReceive (Ptr packet); + /** + * Process DL map + * \param dlmap the DL map + */ void ProcessDlMap (const DlMap &dlmap); + /** + * Process UL map + * \param ulmap the UL map + */ void ProcessUlMap (const UlMap &ulmap); + /** + * Process DCD + * \param dcd the DCD + */ void ProcessDcd (const Dcd &dcd); + /** + * Process UCD + * \param ucd the UCD + */ void ProcessUcd (const Ucd &ucd); // parameters defined in Table 342 - Time m_lostDlMapInterval; // in milliseconds, time since last received DL-MAP before downlink synchronization is considered lost, maximum is 600 - Time m_lostUlMapInterval; // in milliseconds, time since last received UL-MAP before uplink synchronization is considered lost, maximum is 600 - Time m_maxDcdInterval; // in seconds, maximum time between transmission of DCD messages - Time m_maxUcdInterval; // in seconds, maximum time between transmission of UCD messages - Time m_intervalT1; // in seconds, wait for DCD timeout - Time m_intervalT2; // in seconds, wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity - Time m_intervalT3; // in milliseconds, ranging Response reception timeout following the transmission of a ranging request - Time m_intervalT7; // in seconds, wait for DSA/DSC/DSD Response timeout - Time m_intervalT12; // in seconds, wait for UCD descriptor - Time m_intervalT20; // in seconds, time the SS searches for preambles on a given channel - Time m_intervalT21; // in seconds, time the SS searches for (decodable) DL-MAP on a given channel - uint8_t m_maxContentionRangingRetries; + Time m_lostDlMapInterval; ///< in milliseconds, time since last received DL-MAP before downlink synchronization is considered lost, maximum is 600 + Time m_lostUlMapInterval; ///< in milliseconds, time since last received UL-MAP before uplink synchronization is considered lost, maximum is 600 + Time m_maxDcdInterval; ///< in seconds, maximum time between transmission of DCD messages + Time m_maxUcdInterval; ///< in seconds, maximum time between transmission of UCD messages + Time m_intervalT1; ///< in seconds, wait for DCD timeout + Time m_intervalT2; ///< in seconds, wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity + Time m_intervalT3; ///< in milliseconds, ranging Response reception timeout following the transmission of a ranging request + Time m_intervalT7; ///< in seconds, wait for DSA/DSC/DSD Response timeout + Time m_intervalT12; ///< in seconds, wait for UCD descriptor + Time m_intervalT20; ///< in seconds, time the SS searches for preambles on a given channel + Time m_intervalT21; ///< in seconds, time the SS searches for (decodable) DL-MAP on a given channel + uint8_t m_maxContentionRangingRetries; ///< maximum contention ranging retries // parameters obtained from DL-MAP - uint8_t m_dcdCount; - Mac48Address m_baseStationId; + uint8_t m_dcdCount; ///< DCD count + Mac48Address m_baseStationId; ///< base station ID // parameters obtained from UL-MAP - uint8_t m_ucdCount; - double m_allocationStartTime; + uint8_t m_ucdCount; ///< UCD count + double m_allocationStartTime; ///< allocation start time // to keep the number of DL-MAP/UL-MAP IEs found in the last DL-MAP/U-MAP messages - uint16_t m_nrDlMapElements; - uint16_t m_nrUlMapElements; + uint16_t m_nrDlMapElements; ///< number DL Map elements + uint16_t m_nrUlMapElements; ///< number UL Map elements - Ptr m_basicConnection; - Ptr m_primaryConnection; + Ptr m_basicConnection; ///< basci connection + Ptr m_primaryConnection; ///< primary connection - EventId m_lostDlMapEvent, m_lostUlMapEvent, m_dcdWaitTimeoutEvent, m_ucdWaitTimeoutEvent, m_rangOppWaitTimeoutEvent; + EventId m_lostDlMapEvent; ///< lost DL map event + EventId m_lostUlMapEvent; ///< lost UL map event + EventId m_dcdWaitTimeoutEvent; ///< DCD wait timeout event + EventId m_ucdWaitTimeoutEvent; ///< UCD wait timeout event + EventId m_rangOppWaitTimeoutEvent; ///< range opp wait timeout event - uint32_t m_nrDlMapRecvd; - uint32_t m_nrUlMapRecvd; - uint32_t m_nrDcdRecvd; - uint32_t m_nrUcdRecvd; + uint32_t m_nrDlMapRecvd; ///< number DL map received + uint32_t m_nrUlMapRecvd; ///< number UL map received + uint32_t m_nrDcdRecvd; ///< number DCD received + uint32_t m_nrUcdRecvd; ///< number UCD received - OfdmDlBurstProfile *m_dlBurstProfile; - OfdmUlBurstProfile *m_ulBurstProfile; + OfdmDlBurstProfile *m_dlBurstProfile; ///< DL burst profile + OfdmUlBurstProfile *m_ulBurstProfile; ///< UL burst profile /*represents the (least robust) modulation type of the SS which it then requests in RNG-REQ and if accepted by BS uses it for receiving and transmiting. currently it is set by user in simulation script, shall actually be determined based on SS's distance, power, signal etc*/ - WimaxPhy::ModulationType m_modulationType; + WimaxPhy::ModulationType m_modulationType; ///< modulation type - bool m_areManagementConnectionsAllocated; - bool m_areServiceFlowsAllocated; + bool m_areManagementConnectionsAllocated; ///< are management connections allocated + bool m_areServiceFlowsAllocated; ///< are service flows allocated - Ptr m_scheduler; - Ptr m_serviceFlowManager; - Ptr m_classifier; + Ptr m_scheduler; ///< the scheduler + Ptr m_serviceFlowManager; ///< the service flow manager + Ptr m_classifier; ///< the classifier - TracedCallback, Mac48Address, const Cid &> m_traceSSRx; - /** \todo Remove: this TracedCallback is never invoked. */ - TracedCallback, Mac48Address, const Cid &, - WimaxPhy::ModulationType> m_traceSSTx; + TracedCallback, Mac48Address, const Cid &> m_traceSSRx; ///< trace SS receive callback /** * The trace source fired when packets come into the "top" of the device diff --git a/src/wimax/model/ss-record.h b/src/wimax/model/ss-record.h index c205d77775b..d277c47e8ea 100644 --- a/src/wimax/model/ss-record.h +++ b/src/wimax/model/ss-record.h @@ -44,87 +44,239 @@ class SSRecord { public: SSRecord (void); + /** + * Constructor + * + * \param macAddress MAC address + */ SSRecord (Mac48Address macAddress); + /** + * Constructor + * + * \param macAddress MAC address + * \param IPaddress IP address + */ SSRecord (Mac48Address macAddress, Ipv4Address IPaddress); ~SSRecord (void); + /** + * Set basic CID + * \param basicCid the basic CID + */ void SetBasicCid (Cid basicCid); + /** + * Get basic CID + * \returns the basic CID + */ Cid GetBasicCid (void) const; + /** + * Set primary CID + * \param primaryCid priamry CID + */ void SetPrimaryCid (Cid primaryCid); + /** + * Get primary CID + * \returns the CID + */ Cid GetPrimaryCid (void) const; + /** + * Set MAC address + * \param macAddress the MAC address + */ void SetMacAddress (Mac48Address macAddress); + /** + * Get MAC address + * \returns the MAC address + */ Mac48Address GetMacAddress (void) const; + /** + * Get ranging correction retries + * \returns the ranging correction retries + */ uint8_t GetRangingCorrectionRetries (void) const; + /// Reset ranging correction retries void ResetRangingCorrectionRetries (void); + /// Increment ranging correction retries void IncrementRangingCorrectionRetries (void); + /** + * Get invited range retries + * \returns the invited range retries + */ uint8_t GetInvitedRangRetries (void) const; + /// Reset invited ranging retries void ResetInvitedRangingRetries (void); + /// Increment invited ranging retries void IncrementInvitedRangingRetries (void); + /** + * Set modulation type + * \param modulationType the modulation type + */ void SetModulationType (WimaxPhy::ModulationType modulationType); + /** + * Get modulation type + * \returns the modulation type + */ WimaxPhy::ModulationType GetModulationType (void) const; + /** + * Set ranging status + * \param rangingStatus the ranging status + */ void SetRangingStatus (WimaxNetDevice::RangingStatus rangingStatus); + /** + * Get ranging status + * \returns the ranging status + */ WimaxNetDevice::RangingStatus GetRangingStatus (void) const; + /// Enable poll for ranging funtion void EnablePollForRanging (void); + /// Disable poll for ranging void DisablePollForRanging (void); + /** + * Get poll for ranging + * \returns the poll for ranging flag + */ bool GetPollForRanging (void) const; + /** + * Check if service flows are allocated + * \returns true if service flows are allocated + */ bool GetAreServiceFlowsAllocated (void) const; + /** + * Set poll ME bit + * \param pollMeBit the poll me bit + */ void SetPollMeBit (bool pollMeBit); + /** + * Get poll ME bit + * \returns the poll me bit + */ bool GetPollMeBit (void) const; + /** + * Add service flow + * \param serviceFlow the service flow + */ void AddServiceFlow (ServiceFlow *serviceFlow); + /** + * Get service flows + * \param schedulingType the scheduling type + * \returns the service flow + */ std::vector GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const; + /** + * Check if at least one flow has scheduling type SF_TYPE_UGS + * \return true if at least one flow has scheduling type SF_TYPE_UGS + */ bool GetHasServiceFlowUgs (void) const; + /** + * Check if at least one flow has scheduling type SF_TYPE_RTPS + * \return true if at least one flow has scheduling type SF_TYPE_RTPS + */ bool GetHasServiceFlowRtps (void) const; + /** + * Check if at least one flow has scheduling type SF_TYPE_NRTPS + * \return true if at least one flow has scheduling type SF_TYPE_NRTPS + */ bool GetHasServiceFlowNrtps (void) const; + /** + * Check if at least one flow has scheduling type SF_TYPE_BE + * \return true if at least one flow has scheduling type SF_TYPE_BE + */ bool GetHasServiceFlowBe (void) const; + /** + * Set SF transaction ID + * \param sfTransactionId the SF transaction ID + */ void SetSfTransactionId (uint16_t sfTransactionId); + /** + * Get SF transaction ID + * \returns the SF transaction ID + */ uint16_t GetSfTransactionId (void) const; + /** + * Set DSA response retries + * \param dsaRspRetries the DSA response retries + */ void SetDsaRspRetries (uint8_t dsaRspRetries); + /// Increment DAS response retries void IncrementDsaRspRetries (void); + /** + * Get DSA response retries + * \returns the DSA response retries + */ uint8_t GetDsaRspRetries (void) const; + /** + * Set DSA response + * \param dsaRsp the DSA response + */ void SetDsaRsp (DsaRsp dsaRsp); + /** + * Get DSA response + * \returns the DSA response + */ DsaRsp GetDsaRsp (void) const; - void SetIsBroadcastSS (bool); + /** + * Set is broadcast SS + * \param broadcast_enable the broadcast enable flag + */ + void SetIsBroadcastSS (bool broadcast_enable); + /** + * Get is broadcast SS + * \returns the is broadcast SS flag + */ bool GetIsBroadcastSS (void); + /** + * Get IP address + * \returns the IP address + */ Ipv4Address GetIPAddress (void); + /** + * Set IP address + * \param IPaddress the IP address + */ void SetIPAddress (Ipv4Address IPaddress); + /** + * Set are service flows allocated + * \param val the service flows allocated flag + */ void SetAreServiceFlowsAllocated (bool val); private: + /// Initialize void Initialize (void); - Mac48Address m_macAddress; - Ipv4Address m_IPAddress; + Mac48Address m_macAddress; ///< MAC address + Ipv4Address m_IPAddress; ///< IP address - Cid m_basicCid; - Cid m_primaryCid; + Cid m_basicCid; ///< basic CID + Cid m_primaryCid; ///< primary CID - uint8_t m_rangingCorrectionRetries; - uint8_t m_invitedRangingRetries; + uint8_t m_rangingCorrectionRetries; ///< ranging correction retries + uint8_t m_invitedRangingRetries; ///< invited ranging retries - WimaxPhy::ModulationType m_modulationType; // least robust burst profile (modulation type) for this SS - WimaxNetDevice::RangingStatus m_rangingStatus; - bool m_pollForRanging; - bool m_areServiceFlowsAllocated; - bool m_pollMeBit; // if PM (poll me) bit set for this SS - bool m_broadcast; + WimaxPhy::ModulationType m_modulationType; ///< least robust burst profile (modulation type) for this SS + WimaxNetDevice::RangingStatus m_rangingStatus; ///< ranging status + bool m_pollForRanging; ///< poll for ranging + bool m_areServiceFlowsAllocated; ///< are service floes allowed + bool m_pollMeBit; ///< if PM (poll me) bit set for this SS + bool m_broadcast; ///< broadcast? - std::vector *m_serviceFlows; + std::vector *m_serviceFlows; ///< service flows // fields for service flow creation - uint16_t m_sfTransactionId; - uint8_t m_dsaRspRetries; - DsaRsp m_dsaRsp; + uint16_t m_sfTransactionId; ///< SF transaction ID + uint8_t m_dsaRspRetries; ///< DAS response retries + DsaRsp m_dsaRsp; ///< DSA response }; } // namespace ns3 diff --git a/src/wimax/model/ss-scheduler.h b/src/wimax/model/ss-scheduler.h index d6041d4f38d..a3ef55e0e6a 100644 --- a/src/wimax/model/ss-scheduler.h +++ b/src/wimax/model/ss-scheduler.h @@ -36,16 +36,34 @@ class WimaxConnection; /** * \ingroup wimax + * \param SSScheduler class */ class SSScheduler : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param ss subscriber station device + */ SSScheduler (Ptr ss); ~SSScheduler (void); + /** + * Set poll me value + * \param pollMe the poll me flag + */ void SetPollMe (bool pollMe); + /** + * Get the poll me value + * \returns the poll me flag + */ bool GetPollMe (void) const; /** * \return a list of packet to be sent in the next opportunity @@ -62,12 +80,18 @@ class SSScheduler : public Object void DoDispose (void); protected: private: + /// type conversion operator SSScheduler (const SSScheduler &); + /// assignment operator SSScheduler & operator= (const SSScheduler &); + /** + * Select connnection + * \returns pointer to the wimax connection + */ Ptr SelectConnection (void); - Ptr m_ss; - bool m_pollMe; + Ptr m_ss; ///< the subscriber station + bool m_pollMe; ///< poll me flag }; diff --git a/src/wimax/model/ss-service-flow-manager.h b/src/wimax/model/ss-service-flow-manager.h index 823eb2d3df9..31b7e97a308 100644 --- a/src/wimax/model/ss-service-flow-manager.h +++ b/src/wimax/model/ss-service-flow-manager.h @@ -38,18 +38,26 @@ class SubscriberStationNetDevice; /** * \ingroup wimax + * \brief SsServiceFlowManager class */ class SsServiceFlowManager : public ServiceFlowManager { public: + /// Confirmation code enumeration enum ConfirmationCode // as per Table 384 (not all codes implemented) { - CONFIRMATION_CODE_SUCCESS, CONFIRMATION_CODE_REJECT + CONFIRMATION_CODE_SUCCESS, + CONFIRMATION_CODE_REJECT }; /** * \brief creates a service flow manager and attaches it to a device * \param device the device to which the service flow manager will be attached */ + /** + * Constructor + * + * \param device subscriber station device + */ SsServiceFlowManager (Ptr device); ~SsServiceFlowManager (void); void DoDispose (void); @@ -80,37 +88,63 @@ class SsServiceFlowManager : public ServiceFlowManager */ uint8_t GetMaxDsaReqRetries (void) const; + /** + * Get DSA response timeout event + * \returns the DSA response timeout event + */ EventId GetDsaRspTimeoutEvent (void) const; + /** + * Get DSA ack timeout event + * \returns the DSA ack timeput event + */ EventId GetDsaAckTimeoutEvent (void) const; + /// Initiate service flows void InitiateServiceFlows (void); + /** + * Create DSA request + * \param serviceFlow the service flow + * \returns the DSA request + */ DsaReq CreateDsaReq (const ServiceFlow *serviceFlow); + /** + * Create DSA ack + * \returns the packet + */ Ptr CreateDsaAck (void); + /** + * Schedule DSA response + * \param serviceFlow the service flow + */ void ScheduleDsaReq (const ServiceFlow *serviceFlow); + /** + * Process DSA response + * \param dsaRsp the DSA response + */ void ProcessDsaRsp (const DsaRsp &dsaRsp); private: - Ptr m_device; + Ptr m_device; ///< the device - uint8_t m_maxDsaReqRetries; + uint8_t m_maxDsaReqRetries; ///< maximum DSA request retries - EventId m_dsaRspTimeoutEvent; - EventId m_dsaAckTimeoutEvent; + EventId m_dsaRspTimeoutEvent; ///< DSA response timeout event + EventId m_dsaAckTimeoutEvent; ///< DSA ack timeout event - DsaReq m_dsaReq; - DsaAck m_dsaAck; + DsaReq m_dsaReq; ///< DSA request + DsaAck m_dsaAck; ///< DSA ack - uint16_t m_currentTransactionId; - uint16_t m_transactionIdIndex; - uint8_t m_dsaReqRetries; + uint16_t m_currentTransactionId; ///< current transaction ID + uint16_t m_transactionIdIndex; ///< transaction ID index + uint8_t m_dsaReqRetries; ///< DSA request retries // pointer to the service flow currently being configured - ServiceFlow *m_pendingServiceFlow; + ServiceFlow *m_pendingServiceFlow; ///< pending service flow }; diff --git a/src/wimax/model/ul-job.cc b/src/wimax/model/ul-job.cc index 4584a7e5e37..62bc25d8a15 100644 --- a/src/wimax/model/ul-job.cc +++ b/src/wimax/model/ul-job.cc @@ -125,6 +125,12 @@ UlJob::SetSize (uint32_t size) m_size = size; } +/** + * \brief equality operator + * \param a first ULJob + * \param b second ULJob + * \returns true if equal + */ bool operator == (const UlJob &a, const UlJob &b) { UlJob A = a; diff --git a/src/wimax/model/ul-job.h b/src/wimax/model/ul-job.h index 692c4fec48b..35e480956e4 100644 --- a/src/wimax/model/ul-job.h +++ b/src/wimax/model/ul-job.h @@ -33,9 +33,11 @@ namespace ns3 { class SSRecord; class ServiceFlow; +/// Request type enumeration enum ReqType { - DATA, UNICAST_POLLING + DATA, + UNICAST_POLLING }; /** @@ -45,84 +47,177 @@ enum ReqType class UlJob : public Object { public: + /// Job priority enumeration enum JobPriority { - LOW, INTERMEDIATE, HIGH + LOW, + INTERMEDIATE, + HIGH }; UlJob (void); virtual ~UlJob (void); + /** + * Get SS record + * \returns the SS record + */ SSRecord * GetSsRecord (void); + /** + * Set SS record + * \param ssRecord the SS record + */ void SetSsRecord (SSRecord* ssRecord); + /** + * Get scheduling type + * \returns the scheduling type + */ enum ServiceFlow::SchedulingType GetSchedulingType (void); + /** + * Set scheduling type + * \param schedulingType the scheduling type + */ void SetSchedulingType (ServiceFlow::SchedulingType schedulingType); + /** + * Get service flow + * \returns the service flow + */ ServiceFlow * GetServiceFlow (void); + /** + * Set service flow + * \param serviceFlow + */ void SetServiceFlow (ServiceFlow *serviceFlow); + /** + * Get type + * \returns the request type + */ ReqType GetType (void); + /** + * Set type + * \param type the type + */ void SetType (ReqType type); + /** + * Get release time + * \returns the release time + */ Time GetReleaseTime (void); + /** + * Set release time + * \param releaseTime the release time + */ void SetReleaseTime (Time releaseTime); + /** + * Get period + * \returns the period time + */ Time GetPeriod (void); + /** + * Set period + * \param period the period + */ void SetPeriod (Time period); + /** + * Get deadline + * \returns the deadline time + */ Time GetDeadline (void); + /** + * Set deadline + * \param deadline the dead line + */ void SetDeadline (Time deadline); + /** + * Get size + * \returns the size + */ uint32_t GetSize (void); + /** + * Set size + * \param size the size + */ void SetSize (uint32_t size); private: + /// equality operator friend bool operator == (const UlJob &a, const UlJob &b); - Time m_releaseTime; /* The time after which the job can be processed*/ - Time m_period; /* For periodic jobs*/ - Time m_deadline; /* Request should be satisfied by this time */ - uint32_t m_size; /* Number of minislots requested */ - enum ServiceFlow::SchedulingType m_schedulingType; /* Scheduling type of flow */ + Time m_releaseTime; ///< The time after which the job can be processed + Time m_period; ///< For periodic jobs + Time m_deadline; ///< Request should be satisfied by this time + uint32_t m_size; ///< Number of minislots requested + enum ServiceFlow::SchedulingType m_schedulingType; ///< Scheduling type of flow - uint8_t m_flag; /* To delete or not..*/ - uint8_t m_retryCount; - double m_ugsJitter; /* The jitter in the grant, valid only for UGS flows */ - int m_jitterSamples; - double m_last_jitterCalTime; /* Last time avg jitter was calculated */ + uint8_t m_flag; ///< To delete or not + uint8_t m_retryCount; ///< retry count + double m_ugsJitter; ///< The jitter in the grant, valid only for UGS flows + int m_jitterSamples; ///< jitter samples + double m_last_jitterCalTime; ///< Last time avg jitter was calculated - SSRecord *m_ssRecord; /* Pointer to SSRecord */ + SSRecord *m_ssRecord; ///< Pointer to SSRecord - ReqType m_type; /* Type of request, DATA or Unicast req slots */ - ServiceFlow *m_serviceFlow; + ReqType m_type; ///< Type of request, DATA or Unicast req slots + ServiceFlow *m_serviceFlow; ///< service flow }; - +/** + * PriorityUlJob class + */ class PriorityUlJob : public Object { /** - * \brief this class implements an auxiliar struct to compute the priority of the rtPS and nrtPS in + * \brief this class implements an auxiliary struct to compute the priority of the rtPS and nrtPS in * the intermediate queue */ public: PriorityUlJob (); + /** + * Get priority + * \returns the priority + */ int GetPriority (void); + /** + * Set priority + * \param priority the priority + */ void SetPriority (int priority); + /** + * Get UL job functiion + * \returns the UL job + */ Ptr GetUlJob (void); + /** + * Set UL job + * \param job the UL job + */ void SetUlJob (Ptr job); private: - int m_priority; - Ptr m_job; + int m_priority; ///< the priority + Ptr m_job; ///< the job }; +/// SortProcess structure struct SortProcess : public std::binary_function { - bool operator () (PriorityUlJob& left, PriorityUlJob& right) const - { // return true if left is logically less then right for given comparison + /** + * \brief comparison operator + * \param left left side input + * \param right right side input + * \returns true if left is logically less then right for given comparison + */ + bool operator () (PriorityUlJob& left, PriorityUlJob& right) const + { if (left.GetPriority () < right.GetPriority ()) { return true; @@ -147,10 +242,17 @@ struct SortProcess : public std::binary_function, Ptr, bool> { + /** + * \brief comparison operator + * \param left left side input + * \param right right side input + * \returns true if left is logically less then right for given comparison + */ bool operator () (Ptr& left, Ptr& right) const - { //return true if left is logically less then right for given comparison + { if (left->GetPriority () < right->GetPriority ()) { return true; diff --git a/src/wimax/model/ul-mac-messages.h b/src/wimax/model/ul-mac-messages.h index 81a4b9ac09c..345566494a1 100644 --- a/src/wimax/model/ul-mac-messages.h +++ b/src/wimax/model/ul-mac-messages.h @@ -32,10 +32,9 @@ namespace ns3 { /** * \ingroup wimax - * \brief This class implements the UCD channel encodings as described by "IEEE Standard for + * This class implements the UCD channel encodings as described by "IEEE Standard for * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" * 11.3.1 UCD channel encodings, page 651 - * */ class UcdChannelEncodings { @@ -43,26 +42,74 @@ class UcdChannelEncodings UcdChannelEncodings (void); virtual ~UcdChannelEncodings (void); + /** + * Set BW request opp size + * \param bwReqOppSize the bandwidth request opp size + */ void SetBwReqOppSize (uint16_t bwReqOppSize); + /** + * Set range request opp size + * \param rangReqOppSize the ranging request opp size + */ void SetRangReqOppSize (uint16_t rangReqOppSize); + /** + * Set frequency + * \param frequency the frequency + */ void SetFrequency (uint32_t frequency); + /** + * Get BW request opp size + * \returns the bandwidth request opp size + */ uint16_t GetBwReqOppSize (void) const; + /** + * Get range request opp size + * \returns the ragning request opp size + */ uint16_t GetRangReqOppSize (void) const; + /** + * Get frequency + * \returns the frequency + */ uint32_t GetFrequency (void) const; + /** + * Get size + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const = 0; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoRead (Buffer::Iterator start) = 0; - uint16_t m_bwReqOppSize; - uint16_t m_rangReqOppSize; - uint32_t m_frequency; + uint16_t m_bwReqOppSize; ///< BW request opp size + uint16_t m_rangReqOppSize; ///< range request opp size + uint32_t m_frequency; ///< frequency }; } // namespace ns3 @@ -78,31 +125,60 @@ class UcdChannelEncodings namespace ns3 { +/** + * This class implements the OFDM UCD channel encodings as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 11.3.1 UCD channel encodings, page 651 + */ class OfdmUcdChannelEncodings : public UcdChannelEncodings { - /** - * \brief This class implements the UCD channel encodings as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 11.3.1 UCD channel encodings, page 651 - * - */ public: OfdmUcdChannelEncodings (void); ~OfdmUcdChannelEncodings (void); + /** + * Set SB channel reguest region full parameters + * \param sbchnlReqRegionFullParams the channel request region full parameters + */ void SetSbchnlReqRegionFullParams (uint8_t sbchnlReqRegionFullParams); + /** + * Set SB channel for control codes + * \param sbchnlFocContCodes the channel control codes + */ void SetSbchnlFocContCodes (uint8_t sbchnlFocContCodes); + /** + * Get SB channel request region full parameters + * \returns the channel request region full parameters + */ uint8_t GetSbchnlReqRegionFullParams (void) const; + /** + * Get SB channel for control codes + * \returns the channel for control codes + */ uint8_t GetSbchnlFocContCodes (void) const; + /** + * Get size + * \returns the size + */ uint16_t GetSize (void) const; private: + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ virtual Buffer::Iterator DoRead (Buffer::Iterator start); - uint8_t m_sbchnlReqRegionFullParams; - uint8_t m_sbchnlFocContCodes; + uint8_t m_sbchnlReqRegionFullParams; ///< SB channel request region full parameters + uint8_t m_sbchnlFocContCodes; ///< SB channel for control codes }; } // namespace ns3 @@ -119,15 +195,15 @@ class OfdmUcdChannelEncodings : public UcdChannelEncodings namespace ns3 { +/** + * This class implements the UL burst profile as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 11.3.1.1 Uplink burst profile encodings, page 655 + */ class OfdmUlBurstProfile { - /** - * \brief This class implements the UL burst profile as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 11.3.1.1 Uplink burst profile encodings, page 655 - * - */ public: + /// UIUC enumeraton enum Uiuc { UIUC_INITIAL_RANGING = 1, @@ -149,27 +225,73 @@ class OfdmUlBurstProfile OfdmUlBurstProfile (void); ~OfdmUlBurstProfile (void); + /** + * Set type + * \param type the type + */ void SetType (uint8_t type); + /** + * Set length + * \param length the length + */ void SetLength (uint8_t length); + /** + * Set UIUC + * \param uiuc the UIUC + */ void SetUiuc (uint8_t uiuc); + /** + * Set FEC code type + * \param fecCodeType the FEC code type + */ void SetFecCodeType (uint8_t fecCodeType); + /** + * Get type + * \returns the type + */ uint8_t GetType (void) const; + /** + * Get length + * \returns the length + */ uint8_t GetLength (void) const; + /** + * Get UIUC + * \returns the UIUC + */ uint8_t GetUiuc (void) const; + /** + * Get FEC code type + * \returns the FEC code type + */ uint8_t GetFecCodeType (void) const; + /** + * Get size + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: - uint8_t m_type; - uint8_t m_length; - uint8_t m_uiuc; + uint8_t m_type; ///< type + uint8_t m_length; ///< length + uint8_t m_uiuc; ///< UIUC // TLV Encoded information - uint8_t m_fecCodeType; + uint8_t m_fecCodeType; ///< FEC code type }; } // namespace ns3 @@ -187,37 +309,108 @@ class OfdmUlBurstProfile namespace ns3 { +/** + * This class implements the UCD message as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.3 Uplink Channel Descriptor (UCD) message, page 47 + */ class Ucd : public Header { - /** - * \brief This class implements the UCD message as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.3 Uplink Channel Descriptor (UCD) message, page 47 - * - */ public: Ucd (void); virtual ~Ucd (void); + /** + * Set configuration change count + * \param ucdCount the UCD count + */ void SetConfigurationChangeCount (uint8_t ucdCount); + /** + * Set ranging backoff start + * \param rangingBackoffStart ranging backoff start + */ void SetRangingBackoffStart (uint8_t rangingBackoffStart); + /** + * Set ranging backoff end + * \param rangingBackoffEnd the ranging backoff end + */ void SetRangingBackoffEnd (uint8_t rangingBackoffEnd); + /** + * Set request backoff start + * \param requestBackoffStart the request backoff start + */ void SetRequestBackoffStart (uint8_t requestBackoffStart); + /** + * Set request backoff end + * \param requestBackoffEnd the request backoff end + */ void SetRequestBackoffEnd (uint8_t requestBackoffEnd); + /** + * Set channel encodings + * \param channelEncodings the channel encodings + */ void SetChannelEncodings (OfdmUcdChannelEncodings channelEncodings); + /** + * Add UL burst profile + * \param ulBurstProfile the UL burst profile + */ void AddUlBurstProfile (OfdmUlBurstProfile ulBurstProfile); + /** + * Set NR UL burst profiles + * \param nrUlBurstProfiles the NR UL burst profiles + */ void SetNrUlBurstProfiles (uint8_t nrUlBurstProfiles); + /** + * Get configuration change count + * \returns the configuration change count + */ uint8_t GetConfigurationChangeCount (void) const; + /** + * Get ranging backoff start + * \returns the ranging backoff start + */ uint8_t GetRangingBackoffStart (void) const; + /** + * Get ranging backoff end + * \returns the ranging backoff end value + */ uint8_t GetRangingBackoffEnd (void) const; + /** + * Get request backoff start + * \returns the request backoff start value + */ uint8_t GetRequestBackoffStart (void) const; + /** + * Get request backoff end + * \returns the request backoff end value + */ uint8_t GetRequestBackoffEnd (void) const; + /** + * Get channel encodings + * \returns the OFDM UCD channel encodings + */ OfdmUcdChannelEncodings GetChannelEncodings (void) const; + /** + * Get UL burst profiles + * \returns the UL burst profile + */ std::vector GetUlBurstProfiles (void) const; + /** + * Get number UL burst profiles + * \returns the number of UL burst profiles + */ uint8_t GetNrUlBurstProfiles (void) const; + /** + * Get name + * \returns the name string + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -225,15 +418,15 @@ class Ucd : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_configurationChangeCount; - uint8_t m_rangingBackoffStart; - uint8_t m_rangingBackoffEnd; - uint8_t m_requestBackoffStart; - uint8_t m_requestBackoffEnd; - OfdmUcdChannelEncodings m_channelEncodings; // TLV Encoded information for the overall channel - std::vector m_ulBurstProfiles; - - uint8_t m_nrUlBurstProfiles; + uint8_t m_configurationChangeCount; ///< configuration change count + uint8_t m_rangingBackoffStart; ///< ranging backoff start + uint8_t m_rangingBackoffEnd; ///< ranging backoff end + uint8_t m_requestBackoffStart; ///< request backoff start + uint8_t m_requestBackoffEnd; ///< request backoff end + OfdmUcdChannelEncodings m_channelEncodings; ///< TLV Encoded information for the overall channel + std::vector m_ulBurstProfiles; ///< UL burst profiles + + uint8_t m_nrUlBurstProfiles; ///< number UL burst profiles }; } // namespace ns3 @@ -251,44 +444,104 @@ class Ucd : public Header namespace ns3 { +/** + * This class implements the UL-MAP_IE message as described by "IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" + * 6.3.2.3.43.7 UL-MAP_IE, page 115 + */ class OfdmUlMapIe { - /** - * \brief This class implements the UL-MAP_IE message as described by "IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems" - * 6.3.2.3.43.7 UL-MAP_IE, page 115 - * - */ - public: OfdmUlMapIe (void); ~OfdmUlMapIe (void); + /** + * Set CID + * \param cid the CID + */ void SetCid (const Cid &cid); + /** + * Set start time + * \param startTime the start time + */ void SetStartTime (uint16_t startTime); + /** + * Set subchannel index + * \param subchannelIndex + */ void SetSubchannelIndex (uint8_t subchannelIndex); + /** + * Set UIUC + * \param uiuc the UIUC + */ void SetUiuc (uint8_t uiuc); + /** + * Set duration + * \param duration the duration + */ void SetDuration (uint16_t duration); + /** + * Set midambe repetition interval + * \param midambleRepetitionInterval the midambe repetition interval + */ void SetMidambleRepetitionInterval (uint8_t midambleRepetitionInterval); + /** + * Get CID + * \returns the CID + */ Cid GetCid (void) const; + /** + * Get start time + * \returns the start time + */ uint16_t GetStartTime (void) const; + /** + * Get subchannel index + * \returns the subchannel index + */ uint8_t GetSubchannelIndex (void) const; + /** + * Get UIUC + * \returns the UIUC + */ uint8_t GetUiuc (void) const; + /** + * Get duration + * \returns the duration + */ uint16_t GetDuration (void) const; + /** + * Get Midamble repetition interval + * \returns the midamble repetition interval + */ uint8_t GetMidambleRepetitionInterval (void) const; + /** + * Get size + * \returns the size + */ uint16_t GetSize (void) const; + /** + * Write item + * \param start the iterator + * \returns the updated iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; + /** + * Read item + * \param start the iterator + * \returns the udpated iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: - Cid m_cid; - uint16_t m_startTime; - uint8_t m_subchannelIndex; - uint8_t m_uiuc; - uint16_t m_duration; - uint8_t m_midambleRepetitionInterval; + Cid m_cid; ///< CID + uint16_t m_startTime; ///< start time + uint8_t m_subchannelIndex; ///< subchannel index + uint8_t m_uiuc; ///< UIUC + uint16_t m_duration; /// GetUlMapElements (void) const; + /** + * Get name + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -340,11 +624,11 @@ class UlMap : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_reserved; // changed as per the amendment 802.16e-2005 + uint8_t m_reserved; ///< changed as per the amendment 802.16e-2005 - uint8_t m_ucdCount; - uint32_t m_allocationStartTime; - std::list m_ulMapElements; + uint8_t m_ucdCount; ///< UCD count + uint32_t m_allocationStartTime; ///< allocation start time + std::list m_ulMapElements; ///< UL map elements }; } // namespace ns3 diff --git a/src/wimax/model/wimax-channel.h b/src/wimax/model/wimax-channel.h index e154501e3b4..b328990ce5c 100644 --- a/src/wimax/model/wimax-channel.h +++ b/src/wimax/model/wimax-channel.h @@ -35,10 +35,15 @@ class PacketBurst; /** * \ingroup wimax + * The channel object to attach Wimax NetDevices */ class WimaxChannel : public Channel { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WimaxChannel (void); virtual ~WimaxChannel (void); @@ -52,6 +57,7 @@ class WimaxChannel : public Channel */ uint32_t GetNDevices (void) const; /** + * \param i the ith device * \return the ith attached device */ Ptr GetDevice (uint32_t i) const; @@ -67,9 +73,22 @@ class WimaxChannel : public Channel virtual int64_t AssignStreams (int64_t stream) = 0; private: + /** + * Attach a phy to the channel + * \param phy the phy object to attach + */ virtual void DoAttach (Ptr phy) = 0; + /** + * Get number of devices on the channel + * \returns the number of devices + */ virtual uint32_t DoGetNDevices (void) const = 0; + /** + * Get device corresponding to index + * \param i the device index + * \returns the device + */ virtual Ptr DoGetDevice (uint32_t i) const = 0; }; diff --git a/src/wimax/model/wimax-connection.h b/src/wimax/model/wimax-connection.h index 6bb9bae7b98..bc820614444 100644 --- a/src/wimax/model/wimax-connection.h +++ b/src/wimax/model/wimax-connection.h @@ -37,17 +37,36 @@ class Cid; /** * \ingroup wimax + * Class to represent WiMAX connections */ class WimaxConnection : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); + /** + * Constructor + * + * \param cid connection ID + * \param type CID type + */ WimaxConnection (Cid cid, enum Cid::Type type); ~WimaxConnection (void); + /** + * Get CID function + * \returns the CID + */ Cid GetCid (void) const; + /** + * Get type function + * \returns the type + */ enum Cid::Type GetType (void) const; /** * \return the queue of the connection @@ -73,13 +92,24 @@ class WimaxConnection : public Object * \param packet the packet to be enqueued * \param hdrType the header type of the packet * \param hdr the header of the packet + * \return true if successful */ bool Enqueue (Ptr packet, const MacHeaderType &hdrType, const GenericMacHeader &hdr); /** * \brief dequeue a packet from the queue of the connection * \param packetType the type of the packet to dequeue + * \return packet dequeued */ Ptr Dequeue (MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC); + /** + * \brief dequeue a packet from the queue of the connection + * Dequeue the first packet in the queue if its size is lower than + * availableByte, the first availableByte of the first packet otherwise + * + * \param packetType the type of the packet to dequeue + * \param availableByte the number of available bytes + * \return packet dequeued + */ Ptr Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte); /** * \return true if the connection has at least one packet in its queue, false otherwise @@ -88,12 +118,17 @@ class WimaxConnection : public Object /** * \return true if the connection has at least one packet of type packetType in its queue, false otherwise * \param packetType type of packet to check in the queue + * \return true if packets available */ bool HasPackets (MacHeaderType::HeaderType packetType) const; + /** + * Get type string + * \returns the type string + */ std::string GetTypeStr (void) const; - // Definition of Fragments Queue data type + /// Definition of Fragments Queue data type typedef std::list > FragmentsQueue; /** * \brief get a queue of received fragments @@ -112,13 +147,13 @@ class WimaxConnection : public Object private: virtual void DoDispose (void); - Cid m_cid; - enum Cid::Type m_cidType; - Ptr m_queue; - ServiceFlow *m_serviceFlow; + Cid m_cid; ///< CID + enum Cid::Type m_cidType; ///< CID type + Ptr m_queue; ///< queue + ServiceFlow *m_serviceFlow; ///< service flow // FragmentsQueue stores all received fragments - FragmentsQueue m_fragmentsQueue; + FragmentsQueue m_fragmentsQueue; ///< fragments queue }; } // namespace ns3 diff --git a/src/wimax/model/wimax-mac-header.h b/src/wimax/model/wimax-mac-header.h index 9a587ef11a7..6e057520900 100644 --- a/src/wimax/model/wimax-mac-header.h +++ b/src/wimax/model/wimax-mac-header.h @@ -29,28 +29,51 @@ namespace ns3 { /** * \ingroup wimax - * \brief Represents the HT (Header Type) field of generic MAC and bandwidth request headers + * This class Represents the HT (Header Type) field of generic MAC and bandwidth request headers + * \see GenericMacHeader + * \see BandwidthRequestHeader */ class MacHeaderType : public Header { - /** - * \brief this class implements the mac header type field. - * \see GenericMacHeader - * \see BandwidthRequestHeader - */ public: + /// Header type enumeration enum HeaderType { - HEADER_TYPE_GENERIC, HEADER_TYPE_BANDWIDTH + HEADER_TYPE_GENERIC, + HEADER_TYPE_BANDWIDTH }; + /** + * Constructor + */ MacHeaderType (void); + /** + * Constructor + * + * \param type MAC header type + */ MacHeaderType (uint8_t type); virtual ~MacHeaderType (void); + /** + * Set type field + * \param type the type + */ void SetType (uint8_t type); + /** + * Get type field + * \returns the type + */ uint8_t GetType (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -58,7 +81,7 @@ class MacHeaderType : public Header void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_type; + uint8_t m_type; ///< MAC header type }; } // namespace ns3 @@ -77,7 +100,8 @@ class MacHeaderType : public Header namespace ns3 { /** - * \brief this class implements the Generic mac Header as described by IEEE Standard for + * \ingroup wimax + * This class implements the Generic mac Header as described by IEEE Standard for * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems * 6.3.2.1.1 Generic MAC header, page 36 */ @@ -87,43 +111,119 @@ class GenericMacHeader : public Header GenericMacHeader (void); ~GenericMacHeader (void); + /** + * Set EC field + * \param ec the EC + */ void SetEc (uint8_t ec); + /** + * Set type field + * \param type the type + */ void SetType (uint8_t type); + /** + * Set CI field + * \param ci the CI + */ void SetCi (uint8_t ci); + /** + * Set EKS field + * \param eks the EKS + */ void SetEks (uint8_t eks); + /** + * Set length field + * \param len the length + */ void SetLen (uint16_t len); + /** + * Set CID field + * \param cid the CID + */ void SetCid (Cid cid); + /** + * Set HCS field + * \param hcs the HCS + */ void SetHcs (uint8_t hcs); - void SetHt (uint8_t HT); + /** + * Set HT field + * \param ht the HT + */ + void SetHt (uint8_t ht); + /** + * Get EC field + * \returns the EC + */ uint8_t GetEc (void) const; + /** + * Get type field + * \returns the type + */ uint8_t GetType (void) const; + /** + * Get CI field + * \returns the CI + */ uint8_t GetCi (void) const; + /** + * Get EKS field + * \returns the EKS + */ uint8_t GetEks (void) const; + /** + * Get length field + * \returns the length + */ uint16_t GetLen (void) const; + /** + * Get CID field + * \returns the CID + */ Cid GetCid (void) const; + /** + * Get HCS field + * \returns the HCS + */ uint8_t GetHcs (void) const; + /** + * Get HT field + * \returns the HT + */ uint8_t GetHt (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; uint32_t GetSerializedSize (void) const; void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); + /** + * Check HCS + * \returns true if HCS is validated + */ bool check_hcs (void) const; private: - uint8_t m_ht; // Header type - uint8_t m_ec; // Encryption Control - uint8_t m_type; - uint8_t m_esf; - uint8_t m_ci; // CRC Indicator - uint8_t m_eks; // Encryption Key Sequence - uint8_t m_rsv1; - uint16_t m_len; - Cid m_cid; - uint8_t m_hcs; // Header Check Sequence - uint8_t c_hcs; // calculated header check sequence; this is used to check if the received header is correct or not + uint8_t m_ht; ///< Header type + uint8_t m_ec; ///< Encryption Control + uint8_t m_type; ///< type + uint8_t m_esf; ///< ESF + uint8_t m_ci; ///< CRC Indicator + uint8_t m_eks; ///< Encryption Key Sequence + uint8_t m_rsv1; ///< RSV + uint16_t m_len; ///< length + Cid m_cid; ///< CID + uint8_t m_hcs; ///< Header Check Sequence + uint8_t c_hcs; ///< calculated header check sequence; this is used to check if the received header is correct or not }; @@ -143,13 +243,15 @@ class GenericMacHeader : public Header namespace ns3 { /** - * \brief this class implements the bandwidth-request mac Header as described by IEEE Standard for + * \ingroup wimax + * This class implements the bandwidth-request mac Header as described by IEEE Standard for * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems * 6.3.2.1.2 Bandwidth request header, page 38 */ class BandwidthRequestHeader : public Header { public: + /// Header type enumeration enum HeaderType { HEADER_TYPE_INCREMENTAL, HEADER_TYPE_AGGREGATE @@ -158,36 +260,96 @@ class BandwidthRequestHeader : public Header BandwidthRequestHeader (void); ~BandwidthRequestHeader (void); - void SetHt (uint8_t HT); + /** + * Set HT field + * \param ht the HT + */ + void SetHt (uint8_t ht); + /** + * Set EC field + * \param ec the EC + */ void SetEc (uint8_t ec); + /** + * Set type field + * \param type the type + */ void SetType (uint8_t type); + /** + * Set BR field + * \param br the BR + */ void SetBr (uint32_t br); + /** + * Set CID field + * \param cid the CID + */ void SetCid (Cid cid); + /** + * Set HCS field + * \param hcs the HCS + */ void SetHcs (uint8_t hcs); + /** + * Get HT field + * \returns the HT + */ uint8_t GetHt (void) const; + /** + * Get EC field + * \returns the EC + */ uint8_t GetEc (void) const; + /** + * Get type field + * \returns the type + */ uint8_t GetType (void) const; + /** + * Get BR field + * \returns the BR + */ uint32_t GetBr (void) const; + /** + * Get CID field + * \returns the CID + */ Cid GetCid (void) const; + /** + * Get HCS field + * \returns the HCS + */ uint8_t GetHcs (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; uint32_t GetSerializedSize (void) const; void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); + /** + * Check HCS + * \returns true if HCS is validated + */ bool check_hcs (void) const; private: - uint8_t m_ht; // Header type - uint8_t m_ec; // Encryption Control - uint8_t m_type; - uint32_t m_br; // Bandwidth Request - Cid m_cid; // Connection identifier - uint8_t m_hcs; // Header Check Sequence - uint8_t c_hcs; // calculated header check sequence; this is used to check if the received header is correct or not + uint8_t m_ht; ///< Header type + uint8_t m_ec; ///< Encryption Control + uint8_t m_type; ///< type + uint32_t m_br; ///< Bandwidth Request + Cid m_cid; ///< Connection identifier + uint8_t m_hcs; ///< Header Check Sequence + uint8_t c_hcs; ///< calculated header check sequence; this is used to check if the received header is correct or not }; @@ -205,27 +367,59 @@ class BandwidthRequestHeader : public Header namespace ns3 { +/** + * \ingroup wimax + * This class implements the grant management sub-header as described by IEEE Standard for + * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems + * 6.3.2.2.2 Grant Management subheader, page 40 + */ class GrantManagementSubheader : public Header { - /** - * \brief this class implements the grant management sub-header as described by IEEE Standard for - * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems - * 6.3.2.2.2 Grant Management subheader, page 40 - */ - public: GrantManagementSubheader (void); ~GrantManagementSubheader (void); + /** + * Set SI field + * \param si the SI + */ void SetSi (uint8_t si); + /** + * Set PM field + * \param pm the PM + */ void SetPm (uint8_t pm); + /** + * Set PRR field + * \param pbr the PBR + */ void SetPbr (uint16_t pbr); + /** + * Get SI field + * \returns the SI + */ uint8_t GetSi (void) const; + /** + * Get PM field + * \returns the PM + */ uint8_t GetPm (void) const; + /** + * Get PBR field + * \returns the PBR + */ uint16_t GetPbr (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -236,9 +430,9 @@ class GrantManagementSubheader : public Header private: // size of the Grant Management Subheader shall actually be 2 bytes - uint8_t m_si; // Slip Indicator - uint8_t m_pm; // Poll-Me bit (byte in this case) - uint16_t m_pbr; // PiggyBack Request + uint8_t m_si; ///< Slip Indicator + uint8_t m_pm; ///< Poll-Me bit (byte in this case) + uint16_t m_pbr; ///< PiggyBack Request }; } // namespace ns3 @@ -255,11 +449,10 @@ class GrantManagementSubheader : public Header namespace ns3 { /** - * - * \brief this class implements the fragmentation sub-header as described by IEEE Standard for + * \ingroup wimax + * This class implements the fragmentation sub-header as described by IEEE Standard for * Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems * 6.3.2.2.1 Fragmentation subheader, page 39 - * */ class FragmentationSubheader : public Header { @@ -267,13 +460,37 @@ class FragmentationSubheader : public Header FragmentationSubheader (void); ~FragmentationSubheader (void); + /** + * Set FC field + * \param fc the FC + */ void SetFc (uint8_t fc); + /** + * Set FSN field + * \param fsn the FSN + */ void SetFsn (uint8_t fsn); + /** + * Get FC field + * \returns the FC + */ uint8_t GetFc (void) const; + /** + * Get FSN field + * \returns the FSN + */ uint8_t GetFsn (void) const; + /** + * Get name field + * \returns the name + */ std::string GetName (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; void Print (std::ostream &os) const; @@ -282,8 +499,8 @@ class FragmentationSubheader : public Header uint32_t Deserialize (Buffer::Iterator start); private: - uint8_t m_fc; // Fragment Control - uint8_t m_fsn; // Fragment Sequence Number + uint8_t m_fc; ///< Fragment Control + uint8_t m_fsn; ///< Fragment Sequence Number }; } // namespace ns3 diff --git a/src/wimax/model/wimax-mac-queue.h b/src/wimax/model/wimax-mac-queue.h index 5644b8d8e1e..5e4903e1579 100644 --- a/src/wimax/model/wimax-mac-queue.h +++ b/src/wimax/model/wimax-mac-queue.h @@ -33,12 +33,22 @@ namespace ns3 { /** * \ingroup wimax + * Class implementing the device packet queue */ class WimaxMacQueue : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WimaxMacQueue (void); + /** + * Constructor + * + * \param maxSize maximum size of queue + */ WimaxMacQueue (uint32_t maxSize); ~WimaxMacQueue (void); /** @@ -55,11 +65,12 @@ class WimaxMacQueue : public Object * \param packet the packet to enqueue * \param hdrType the mac header type of the packet * \param hdr the header of the packet + * \return true if successful */ bool Enqueue (Ptr packet, const MacHeaderType &hdrType, const GenericMacHeader &hdr); /** - * \brief Dequeue a packet of type packetType from the queue + * \brief Dequeue a packet of type packetType from the queue * \param packetType the type of the packet * \return the first packet in the queue */ @@ -68,107 +79,194 @@ class WimaxMacQueue : public Object * \brief Dequeue a fragment of size availableByte from the queue * \param packetType the type of the packet * \param availableByte the size of the fragment - * \return the first packet in the queue if its size is lower than availableByte, the first availableByte of the - * first packet otherwise + * \return the first packet in the queue if its size is lower than availableByte, the first availableByte of the first packet otherwise */ Ptr Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte); /** - * \brief Same as Dequeue but does not pop from queue + * \brief Exclusively for BS. + * Two versions of Peek function (with Generic MAC Header as parameter) only + * for BS, as BS's scheduler needs to know the CID in Generic MAC Header. + * \param hdr the header of the packet + * \return the first packet in the queue */ - + Ptr Peek (GenericMacHeader &hdr) const; /** - * \brief Exclusive for BS. + * \brief Exclusively for BS. * Two versions of Peek function (with Generic MAC Header as parameter) only * for BS, as BS's scheduler needs to know the CID in Generic MAC Header. + * \param hdr the header of the packet + * \param timeStamp the timestamp of the packet + * \return the first packet in the queue */ - Ptr Peek (GenericMacHeader &hdr) const; Ptr Peek (GenericMacHeader &hdr, Time &timeStamp) const; /** * \brief Two versions for SS without Generic MAC Header parameter, as SS's * scheduler does not require to know the CID in Generic MAC Header. + * \param packetType the type of the packet + * \return the first packet in the queue */ Ptr Peek (MacHeaderType::HeaderType packetType) const; + /** + * \brief Two versions for SS without Generic MAC Header parameter, as SS's + * scheduler does not require to know the CID in Generic MAC Header. + * \param packetType the type of the packet + * \param timeStamp the timestamp of the packet + * \return the first packet in the queue + */ Ptr Peek (MacHeaderType::HeaderType packetType, Time &timeStamp) const; - + /// Check if queue is empty bool IsEmpty (void) const; - /* - Exclusive for SS. + /** + * Exclusively for SS. + * \return true if queue is empty of type packetType + * \param packetType packet type to check */ bool IsEmpty (MacHeaderType::HeaderType packetType) const; + /** + * Get size of queue + * \returns the size + */ uint32_t GetSize (void) const; + /** + * Get number of bytes in queue + * \returns the number of bytes + */ uint32_t GetNBytes (void) const; /** - * \brief Fragmentation utilities + * Check for fragmentation of the first packet of the specified type + * \param packetType the packet type + * \returns true if fragmented */ bool CheckForFragmentation (MacHeaderType::HeaderType packetType); + /** + * Get first packet header size of the specified type + * \param packetType the packet type + * \returns the first packet header size + */ uint32_t GetFirstPacketHdrSize (MacHeaderType::HeaderType packetType); + /** + * Get first packet payload size of the specified type + * \param packetType the packet type + * \returns the first packet payload size + */ uint32_t GetFirstPacketPayloadSize (MacHeaderType::HeaderType packetType); + /** + * Get required number of bytes to hold first packet of packetType + * \param packetType the packet type + * \returns the sum of the first packet header and payload (of specified type) + */ uint32_t GetFirstPacketRequiredByte (MacHeaderType::HeaderType packetType); - + /** + * Get queue length considering also the MAC overhead + * \return queue length + */ uint32_t GetQueueLengthWithMACOverhead (void); - + /// Set fragmentation function + /** + * Set fragmentation state for first packet of type packetType + * \param packetType packetType to check + */ void SetFragmentation (MacHeaderType::HeaderType packetType); + /** + * Set fragment number for first packet of type packetType + * \param packetType packetType to check + */ void SetFragmentNumber (MacHeaderType::HeaderType packetType); + /** + * Set fragment offset for first packet of type packetType + * \param packetType packetType to check + * \param offset offset value to set + */ void SetFragmentOffset (MacHeaderType::HeaderType packetType, uint32_t offset); + /// QueueElement structure struct QueueElement { QueueElement (void); + /** + * Constructor + * + * \param packet the packet + * \param hdrType MAC header type + * \param hdr MAC header + * \param timeStamp time stamp + */ QueueElement (Ptr packet, const MacHeaderType &hdrType, const GenericMacHeader &hdr, Time timeStamp); + /** + * Get size function + * \returns the size + */ uint32_t GetSize (void) const; - Ptr m_packet; - MacHeaderType m_hdrType; - GenericMacHeader m_hdr; - Time m_timeStamp; + Ptr m_packet; ///< packet + MacHeaderType m_hdrType; ///< header type + GenericMacHeader m_hdr; ///< header + Time m_timeStamp; ///< timestamp - /* + /** To manage fragmentation feature, each QueueElement have 3 new fields: - m_fragmentation that became true when the fragmentation starts; - m_fragmentNumber that are incremented when a new fragment is sent - m_fragmentOffset that describe the start of the next fragment into the packet + m_fragmentation that becomes true when the fragmentation starts; + m_fragmentNumber that is incremented when a new fragment is sent + m_fragmentOffset that tracks the start of the next fragment into the packet */ - bool m_fragmentation; - uint32_t m_fragmentNumber; - uint32_t m_fragmentOffset; + bool m_fragmentation; ///< becomes true when the fragmentation starts + uint32_t m_fragmentNumber; ///< incremented when a new fragment is sent + uint32_t m_fragmentOffset; ///< tracks the start of the next fragment into the packet + /// Set fragmentation void SetFragmentation (void); + /// Set fragment number void SetFragmentNumber (void); + /** + * Set fragment offset + * \param offset the offset + */ void SetFragmentOffset (uint32_t offset); }; private: - /* + /** In the case of non-UGS service flows at the SS side the queue will store both data packets and bandwidth request packets. The two are distinguished by their headers. The below two functions are for this purpose exclusively. The Front function returns the first packet of a specific packet type from the queue (which may not necessarily be at the front of the queue), and the Pop function pops that elements. + * \param packetType the type of the packet + * \returns the first packet in the queue of the specified type */ WimaxMacQueue::QueueElement Front (MacHeaderType::HeaderType packetType) const; + /** + * Pop function + * \param packetType the packet type + */ void Pop (MacHeaderType::HeaderType packetType); + /// PacketQueue typedef typedef std::deque PacketQueue; - PacketQueue m_queue; - uint32_t m_maxSize; - uint32_t m_bytes; - uint32_t m_nrDataPackets; - uint32_t m_nrRequestPackets; - - TracedCallback > m_traceEnqueue; - TracedCallback > m_traceDequeue; - TracedCallback > m_traceDrop; + PacketQueue m_queue; ///< the queue + uint32_t m_maxSize; ///< maximum size + uint32_t m_bytes; ///< bytes + uint32_t m_nrDataPackets; ///< number data packets + uint32_t m_nrRequestPackets; ///< number request packets + + TracedCallback > m_traceEnqueue; ///< enqueue trace callback + TracedCallback > m_traceDequeue; ///< dequeue trace callback + TracedCallback > m_traceDrop; ///< drop trace callback public: + /** + * Get packet queue function + * \returns the packet queue + */ const WimaxMacQueue::PacketQueue & GetPacketQueue (void) const; }; diff --git a/src/wimax/model/wimax-mac-to-mac-header.h b/src/wimax/model/wimax-mac-to-mac-header.h index 4d2ef76ada1..206fc2591cd 100644 --- a/src/wimax/model/wimax-mac-to-mac-header.h +++ b/src/wimax/model/wimax-mac-to-mac-header.h @@ -37,17 +37,30 @@ class WimaxMacToMacHeader : public Header public: WimaxMacToMacHeader (); ~WimaxMacToMacHeader (); + /** + * Constructor + * + * \param len length + */ WimaxMacToMacHeader (uint32_t len); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; uint32_t GetSerializedSize (void) const; void Serialize (Buffer::Iterator start) const; uint32_t Deserialize (Buffer::Iterator start); + /** + * Get size of length field + * \returns the size of length field + */ uint8_t GetSizeOfLen (void) const; virtual void Print (std::ostream &os) const; private: - uint32_t m_len; + uint32_t m_len; ///< length }; }; #endif diff --git a/src/wimax/model/wimax-net-device.h b/src/wimax/model/wimax-net-device.h index 3badb053a17..6a4eaba383e 100644 --- a/src/wimax/model/wimax-net-device.h +++ b/src/wimax/model/wimax-net-device.h @@ -54,12 +54,11 @@ class UplinkScheduler; /** * \defgroup wimax WiMAX Models - * * This section documents the API of the ns-3 wimax module. For a generic functional description, please refer to the ns-3 manual. */ /** - * \brief Hold together all Wimax-related objects in a NetDevice. + * \brief Hold together all WiMAX-related objects in a NetDevice. * \ingroup wimax * * This class holds together ns3::WimaxPhy, ns3::WimaxConnection, @@ -69,103 +68,171 @@ class UplinkScheduler; class WimaxNetDevice : public NetDevice { public: + ///Direction enumeration enum Direction { - DIRECTION_DOWNLINK, DIRECTION_UPLINK + DIRECTION_DOWNLINK, + DIRECTION_UPLINK }; + /// RangingStatus enumeration enum RangingStatus { - RANGING_STATUS_EXPIRED, RANGING_STATUS_CONTINUE, RANGING_STATUS_ABORT, RANGING_STATUS_SUCCESS + RANGING_STATUS_EXPIRED, + RANGING_STATUS_CONTINUE, + RANGING_STATUS_ABORT, + RANGING_STATUS_SUCCESS }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WimaxNetDevice (void); virtual ~WimaxNetDevice (void); /** + * Set transmission/receive transition gap * \param ttg transmit/receive transition gap */ void SetTtg (uint16_t ttg); /** + * Get transmission/receive transition gap * \returns transmit/receive transition gap */ uint16_t GetTtg (void) const; /** + * Set receive/transmit transition gap * \param rtg receive/transmit transition gap */ void SetRtg (uint16_t rtg); /** + * Get receive/transmit transition gap * \returns receive/transmit transition gap */ uint16_t GetRtg (void) const; + /** + * Attach device to channel + * \param channel channel to attach + */ void Attach (Ptr channel); /** - * \param phy the phy layer to use. + * Set the physical layer object + * \param phy the phy layer object to use */ void SetPhy (Ptr phy); /** - * \returns a pointer to the physical layer. + * Get the physical layer object + * \returns a pointer to the physical layer object */ Ptr GetPhy (void) const; /** + * Set the channel object * \param wimaxChannel the channel to be used */ void SetChannel (Ptr wimaxChannel); + /** + * Get the channel object by index + * \param index the channel index + * \returns the channel being used. + */ uint64_t GetChannel (uint8_t index) const; + /** + * Set the number of frames + * \param nrFrames the number of frames + */ void SetNrFrames (uint32_t nrFrames); + /** + * Get the number of frames + * \returns the number of frames. + */ uint32_t GetNrFrames (void) const; /** + * Set the MAC address * \param address the mac address of the net device */ void SetMacAddress (Mac48Address address); /** + * Get the MAC address * \returns the mac address of the net device */ Mac48Address GetMacAddress (void) const; + /** + * Set the device state + * \param state the state + */ void SetState (uint8_t state); + /** + * Get the device state + * \returns the state + */ uint8_t GetState (void) const; /** + * Get the initial ranging connection * \returns the initial ranging connection */ Ptr GetInitialRangingConnection (void) const; /** - * \returns the broadcast connection - */ + * Get the broadcast connection + * \returns the broadcast connection + */ Ptr GetBroadcastConnection (void) const; + /** + * Set the current DCD + * \param dcd the DCD + */ void SetCurrentDcd (Dcd dcd); + /** + * Get the current DCD + * \returns the DCD + */ Dcd GetCurrentDcd (void) const; + /** + * Set the current UCD + * \param ucd the UCD + */ void SetCurrentUcd (Ucd ucd); + /** + * Get the current UCD + * \returns the UCD + */ Ucd GetCurrentUcd (void) const; /** + * Get the connection manager of the device * \returns the connection manager of the device */ Ptr GetConnectionManager (void) const; /** + * Set the connection manager of the device * \param connectionManager the commection manager to be installed in the device */ virtual void SetConnectionManager (Ptr connectionManager ); /** + * Get the burst profile manager * \returns the burst profile manager currently installed in the device */ Ptr GetBurstProfileManager (void) const; /** + * Set the burst profile manager * \param burstProfileManager the burst profile manager to be installed on the device */ void SetBurstProfileManager (Ptr burstProfileManager); /** + * Get the bandwidth manager on the device * \returns the bandwidth manager installed on the device */ Ptr GetBandwidthManager (void) const; /** + * Set the bandwidth manager on the device * \param bandwidthManager the bandwidth manager to be installed on the device */ void SetBandwidthManager (Ptr bandwidthManager); @@ -175,48 +242,190 @@ class WimaxNetDevice : public NetDevice */ void CreateDefaultConnections (void); + /// Start function virtual void Start (void) = 0; + /// Stop function virtual void Stop (void) = 0; + /// Set receive callback function void SetReceiveCallback (void); + /** + * Forward a packet to the next layer above the device + * \param packet the packet + * \param source the source MAC address + * \param dest the destination MAC address + */ void ForwardUp (Ptr packet, const Mac48Address &source, const Mac48Address &dest); + /** + * Enqueue a packet + * \param packet the packet + * \param hdrType the header type + * \param connection the wimax connection + * \returns true if successful + */ virtual bool Enqueue (Ptr packet, const MacHeaderType &hdrType, Ptr connection) = 0; + /** + * Forward a packet down the stack + * \param burst the packet burst + * \param modulationType the modulation type + */ void ForwardDown (Ptr burst, WimaxPhy::ModulationType modulationType); // temp, shall be private - static uint8_t m_direction; // downlink or uplink + static uint8_t m_direction; ///< downlink or uplink - static Time m_frameStartTime; // temp, to determine the frame start time at SS side, shall actually be determined by frame start preamble + static Time m_frameStartTime; ///< temp, to determine the frame start time at SS side, shall actually be determined by frame start preamble + /** + * Set device name + * \param name the device name + */ virtual void SetName (const std::string name); + /** + * Get device name + * \returns the device name + */ virtual std::string GetName (void) const; + /** + * Set interface index + * \param index the index + */ virtual void SetIfIndex (const uint32_t index); + /** + * Get interface index + * \returns the interface index + */ virtual uint32_t GetIfIndex (void) const; + /** + * Get the channel (this method is redundant with GetChannel()) + * \returns the channel used by the phy layer + */ virtual Ptr GetPhyChannel (void) const; + /** + * Get the channel + * \returns the channel + */ virtual Ptr GetChannel (void) const; + /** + * Set address of the device + * \param address the address + */ virtual void SetAddress (Address address); + /** + * Get address of the device + * \returns the address + */ virtual Address GetAddress (void) const; + /** + * Set MTU value for the device + * \param mtu the MTU + * \returns true if successful + */ virtual bool SetMtu (const uint16_t mtu); + /** + * Get MTU of the device + * \returns the MTU + */ virtual uint16_t GetMtu (void) const; + /** + * Check if link is up + * \return true if the link is up + */ virtual bool IsLinkUp (void) const; + /** + * Set link change callback function + * \param callback the callback function + */ virtual void SetLinkChangeCallback (Callback callback); + /** + * Check if broadcast enabled + * \returns true if broadcast + */ virtual bool IsBroadcast (void) const; + /** + * Get broadcast address + * \returns the address + */ virtual Address GetBroadcast (void) const; + /** + * Check if multicast enabled + * \returns true if multicast + */ virtual bool IsMulticast (void) const; + /** + * Get multicast address + * \returns the multicast address + */ virtual Address GetMulticast (void) const; + /** + * Make multicast address + * \param multicastGroup the IPv4 address + * \returns the multicast address + */ virtual Address MakeMulticastAddress (Ipv4Address multicastGroup) const; + /** + * Check if device is a point-to-point device + * \returns true if point to point + */ virtual bool IsPointToPoint (void) const; + /** + * Send function + * \param packet the packet + * \param dest the destination address + * \param protocolNumber the protocol number + * \returns true if successful + */ virtual bool Send (Ptr packet, const Address& dest, uint16_t protocolNumber); + /** + * Set node pointer + * \param node the node pointer + */ virtual void SetNode (Ptr node); + /** + * Get node pointer + * \returns the node pointer + */ virtual Ptr GetNode (void) const; + /** + * Check if device needs ARP + * \returns true if ARP required + */ virtual bool NeedsArp (void) const; + /** + * Set receive callback function + * \param cb the receive callback function + */ virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb); + /** + * Add link change callback function + * \param callback the link change callback function + */ virtual void AddLinkChangeCallback (Callback callback); + /** + * Send a packet + * \param packet the packet + * \param source the source address + * \param dest the destination address + * \param protocolNumber the protocol number + * \returns true if successful + */ virtual bool SendFrom (Ptr packet, const Address& source, const Address& dest, uint16_t protocolNumber); + /** + * Set promiscious receive callback function + * \param cb the promiscious mode callback + */ virtual void SetPromiscReceiveCallback (PromiscReceiveCallback cb); + /** + * Get promiscious receive callback function + * \returns the promiscious mode callback + */ NetDevice::PromiscReceiveCallback GetPromiscReceiveCallback (void); + /** + * Check if device supports the SendFrom method + * \returns true if SendFrom is supported + */ virtual bool SupportsSendFrom (void) const; /** @@ -253,62 +462,95 @@ class WimaxNetDevice : public NetDevice virtual Address GetMulticast (Ipv4Address multicastGroup) const; virtual bool IsBridge (void) const; + /** + * Check if device is promiscious + * \returns true if promiscious + */ bool IsPromisc (void); + /** + * Notify promiscious trace of a packet arrival + * \param p the packet + */ void NotifyPromiscTrace (Ptr p); private: + /// copy constructor (disabled) WimaxNetDevice (const WimaxNetDevice &); + /// assignment operator (disabled) WimaxNetDevice & operator= (const WimaxNetDevice &); + /// Maximum MSDU size static const uint16_t MAX_MSDU_SIZE = 1500; - // recommended by wimax forum. + /// recommended by wimax forum. static const uint16_t DEFAULT_MSDU_SIZE = 1400; + /** + * Send a packet + * \param packet the packet + * \param source the source MAC address + * \param dest the destination MAC address + * \param protocolNumber the protocol number + * \returns true if successful + */ virtual bool DoSend (Ptr packet, const Mac48Address& source, const Mac48Address& dest, uint16_t protocolNumber) = 0; + /** + * Receive a packet + * \param packet the packet received + */ virtual void DoReceive (Ptr packet) = 0; + /** + * Get the channel + * \returns the wimax channel + */ virtual Ptr DoGetChannel (void) const; + /** + * Receive a packet burst + * \param burst the packet burst + */ void Receive (Ptr burst); + /// Initialize channels function void InitializeChannels (void); - Ptr m_node; - Ptr m_phy; - NetDevice::ReceiveCallback m_forwardUp; - NetDevice::PromiscReceiveCallback m_promiscRx; + Ptr m_node; ///< the node + Ptr m_phy; ///< the phy + NetDevice::ReceiveCallback m_forwardUp; ///< forward up callback function + NetDevice::PromiscReceiveCallback m_promiscRx; ///< promiscious receive fcallback function - uint32_t m_ifIndex; - std::string m_name; - bool m_linkUp; - Callback m_linkChange; - mutable uint16_t m_mtu; + uint32_t m_ifIndex; ///< IF index + std::string m_name; ///< service name + bool m_linkUp; ///< link up? + Callback m_linkChange; ///< link change callback + mutable uint16_t m_mtu; ///< MTU - // temp, shall be in BS. defined here to allow SS to access. SS shall actually determine it from DLFP, shall be moved to BS after DLFP is implemented - static uint32_t m_nrFrames; + /// temp, shall be in BS. defined here to allow SS to access. SS shall actually determine it from DLFP, shall be moved to BS after DLFP is implemented + static uint32_t m_nrFrames; - // not sure if it shall be included here + /// not sure if it shall be included here std::vector m_dlChannels; - Mac48Address m_address; - uint8_t m_state; - uint32_t m_symbolIndex; + Mac48Address m_address; ///< MAC address + uint8_t m_state; ///< state + uint32_t m_symbolIndex; ///< symbol index - // length of TTG and RTG, in units of PSs + /// length of TTG in units of PSs uint16_t m_ttg; + /// length of RTG in units of PSs uint16_t m_rtg; - Dcd m_currentDcd; - Ucd m_currentUcd; + Dcd m_currentDcd; ///< DCD + Ucd m_currentUcd; ///< UCD - Ptr m_initialRangingConnection; - Ptr m_broadcastConnection; + Ptr m_initialRangingConnection; ///< initial rnaging connection + Ptr m_broadcastConnection; ///< broadcast connection - Ptr m_connectionManager; - Ptr m_burstProfileManager; - Ptr m_bandwidthManager; + Ptr m_connectionManager; ///< connection manager + Ptr m_burstProfileManager; ///< burst profile manager + Ptr m_bandwidthManager; ///< badnwidth manager - Ptr m_mobility; + Ptr m_mobility; ///< modility model }; diff --git a/src/wimax/model/wimax-phy.h b/src/wimax/model/wimax-phy.h index 658e3ba2848..a348c0cea51 100644 --- a/src/wimax/model/wimax-phy.h +++ b/src/wimax/model/wimax-phy.h @@ -45,22 +45,38 @@ class Packet; class WimaxPhy : public Object { public: + /// ModulationType enumeration enum ModulationType // Table 356 and 362 { - MODULATION_TYPE_BPSK_12, MODULATION_TYPE_QPSK_12, MODULATION_TYPE_QPSK_34, MODULATION_TYPE_QAM16_12, - MODULATION_TYPE_QAM16_34, MODULATION_TYPE_QAM64_23, MODULATION_TYPE_QAM64_34 + MODULATION_TYPE_BPSK_12, + MODULATION_TYPE_QPSK_12, + MODULATION_TYPE_QPSK_34, + MODULATION_TYPE_QAM16_12, + MODULATION_TYPE_QAM16_34, + MODULATION_TYPE_QAM64_23, + MODULATION_TYPE_QAM64_34 }; + /// PhyState enumeration enum PhyState { - PHY_STATE_IDLE, PHY_STATE_SCANNING, PHY_STATE_TX, PHY_STATE_RX + PHY_STATE_IDLE, + PHY_STATE_SCANNING, + PHY_STATE_TX, + PHY_STATE_RX }; + /// PhyType enumeration enum PhyType { - SimpleWimaxPhy, simpleOfdmWimaxPhy + SimpleWimaxPhy, + simpleOfdmWimaxPhy }; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WimaxPhy (void); virtual ~WimaxPhy (void); @@ -112,25 +128,29 @@ class WimaxPhy : public Object */ void SetSimplex (uint64_t frequency); /** + * Get the reception frequency * \return the reception frequency */ uint64_t GetRxFrequency (void) const; /** + * Get the transmission frequency * \return the transmission frequency */ uint64_t GetTxFrequency (void) const; /** + * Get the scanning frequency * \return the scanning frequency */ uint64_t GetScanningFrequency (void) const; /** + * Set the number of carriers in the physical frame * \brief Set the number of carriers in the physical frame * \param nrCarriers the number of carriers in the frame */ - void SetNrCarriers (uint8_t nrCarriers); /** - * \return the number of carriers in the frame + * Get the number of carriers in the physical frame + * \return the number of carriers in the physical frame */ uint8_t GetNrCarriers (void) const; /** @@ -139,10 +159,13 @@ class WimaxPhy : public Object */ void SetFrameDuration (Time frameDuration); /** - * \return the frame duration in seconds + * \brief Get the frame duration + * This method is redundant with GetFrameDuration () + * \return the frame duration */ Time GetFrameDurationSec (void) const; /** + * \brief Get the frame duration * \return the frame duration */ Time GetFrameDuration (void) const; @@ -152,6 +175,7 @@ class WimaxPhy : public Object */ void SetFrequency (uint32_t frequency); /** + * Get the frequency on which the device is locked * \return the frequency on which the device is locked */ uint32_t GetFrequency (void) const; @@ -161,41 +185,48 @@ class WimaxPhy : public Object */ void SetChannelBandwidth (uint32_t channelBandwidth); /** + * Get the channel bandwidth * \return the channel bandwidth */ uint32_t GetChannelBandwidth (void) const; /** + * Get the size of the FFT * \return the size of the FFT */ uint16_t GetNfft (void) const; /** + * Get the sampling factor * \return the sampling factor */ double GetSamplingFactor (void) const; /** + * Get the sampling frequency * \return the sampling frequency */ double GetSamplingFrequency (void) const; /** - * \brief set the physical slot duration in seconds + * \brief set the physical slot duration * \param psDuration the physical slot duration */ void SetPsDuration (Time psDuration); /** + * Get the physical slot duration * \return the physical slot duration */ Time GetPsDuration (void) const; /** - * \brief set the OFMD symbol duration in second - * \param symbolDuration the symbol duration is second + * \brief set the OFDM symbol duration + * \param symbolDuration the symbol duration */ void SetSymbolDuration (Time symbolDuration); /** + * Get the OFDM symbol duration * \return the symbol duration in second */ Time GetSymbolDuration (void) const; /** - * \return the guard interval factor (The ratio TG/Td) + * Get the guard interval factor (the ratio TG/Td) + * \return the guard interval factor */ double GetGValue (void) const; /** @@ -204,16 +235,18 @@ class WimaxPhy : public Object */ void SetPsPerSymbol (uint16_t psPerSymbol); /** + * Get the number of physical slots per symbol * \return the number of physical slots per symbol */ uint16_t GetPsPerSymbol (void) const; /** - * \brief set the number of physical slot per frame - * \param psPerFrame the number of physical slot per frame + * \brief set the number of physical slots per frame + * \param psPerFrame the number of physical slots per frame */ void SetPsPerFrame (uint16_t psPerFrame); /** + * Get the number of physical slots per frame * \return the number of physical slot per frame */ uint16_t GetPsPerFrame (void) const; @@ -223,10 +256,12 @@ class WimaxPhy : public Object */ void SetSymbolsPerFrame (uint32_t symbolsPerFrame); /** + * Get the number of symbols per frame * \return the number of symbols per frame */ uint32_t GetSymbolsPerFrame (void) const; /** + * Check if configured in duplex mode * \return true if the device is configured in duplex mode */ bool IsDuplex (void) const; @@ -236,11 +271,12 @@ class WimaxPhy : public Object */ void SetState (PhyState state); /** + * Get the state of the device * \return the state of the device (PHY_STATE_IDLE, PHY_STATE_SCANNING, PHY_STATE_TX, PHY_STATE_RX) */ PhyState GetState (void) const; /** - * \brief scan the frequency frequency for maximum timeout seconds and calls callback if the frequency could be used + * \brief scan a frequency for maximum timeout seconds and call the callback if the frequency can be used * \param frequency the frequency to scan * \param timeout the timout before considering the channel as unusable * \param callback the function to call if the channel could be used @@ -251,44 +287,62 @@ class WimaxPhy : public Object * \brief calls the scanning call back function */ void SetScanningCallback (void) const; + /** + * \brief Get channel search timeout event + * \return event ID + */ EventId GetChnlSrchTimeoutEvent (void) const; /** * \brief calculates the data rate of each modulation and save them for future use */ - void SetDataRates (void); /** - * \return the data rate of the modulation modulationType + * Get the data rate corresponding to a modulation type + * \return the data rate * \param modulationType the modulation that you want to get its data rate */ uint32_t GetDataRate (ModulationType modulationType) const; /** - * \return the time needed to transmit size bytes using the modulation modulationType + * Get transmission time needed to send bytes at a given modulation + * \return the time needed * \param size the number of byte to transmit * \param modulationType the modulation that will be used to transmit the bytes */ Time GetTransmissionTime (uint32_t size, ModulationType modulationType) const; /** - * \return the number of symbols needed to transmit size bytes using the modulation modulationType + * Get the number of symbols needed to transmit size bytes using the modulation modulationType + * \return the number of symbols needed * \param size the number of byte to transmit * \param modulationType the modulation that will be used to transmit the bytes */ uint64_t GetNrSymbols (uint32_t size, ModulationType modulationType) const; /** - * \return the maximum number of bytes that could be carried by symbols symbols using the modulation modulationType + * Get the maximum number of bytes that could be carried by symbols symbols using the modulation modulationType + * \return the maximum number of bytes * \param symbols the number of symbols to use * \param modulationType the modulation that will be used */ uint64_t GetNrBytes (uint32_t symbols, ModulationType modulationType) const; /** + * Get the transmit/receive transition gap * \return the transmit/receive transition gap */ uint16_t GetTtg (void) const; /** + * Get the receive/transmit transition gap * \return the receive/transmit transition gap */ uint16_t GetRtg (void) const; + /** + * Get the frame duration code + * \return the frame duration code + */ uint8_t GetFrameDurationCode (void) const; + /** + * Get the frame duration corresponding to a given code + * \param frameDurationCode the frame duration code to use + * \return the frame duration + */ Time GetFrameDuration (uint8_t frameDurationCode) const; /** * \brief computes the Physical parameters and store them @@ -296,6 +350,7 @@ class WimaxPhy : public Object void SetPhyParameters (void); virtual void DoDispose (void); /** + * Get the mobility model of the device * \return the mobility model of the device */ virtual Ptr GetMobility (void); @@ -316,48 +371,119 @@ class WimaxPhy : public Object virtual int64_t AssignStreams (int64_t stream) = 0; private: + /** + * Get modulation FEC parameters + * \param modulationType the modultion type + * \param bitsPerSymbol the number of bits per symbol page + * \param fecCode the FEC code + */ void GetModulationFecParams (ModulationType modulationType, uint8_t &bitsPerSymbol, double &fecCode) const; + /// End scanning void EndScanning (void); + /** + * Get transmission time + * \param size the transmission size + * \param modulationType the modulation type + * \returns the transmission time + */ virtual Time DoGetTransmissionTime (uint32_t size, ModulationType modulationType) const = 0; + /** + * Attach channel + * \param channel the wimax channel + */ virtual void DoAttach (Ptr channel) = 0; + /// Set data rates virtual void DoSetDataRates (void) = 0; + /** + * Get data rate + * \param modulationType the modulation type + * \returns the data rate + */ virtual uint32_t DoGetDataRate (ModulationType modulationType) const = 0; + /** + * Get number of symbols + * \param size the transmission size + * \param modulationType the modulation type + * \returns the number of symbols + */ virtual uint64_t DoGetNrSymbols (uint32_t size, ModulationType modulationType) const = 0; + /** + * Get number of bytes + * \param symbols the number of symbols + * \param modulationType the modulation type + * \returns the number of bytes + */ virtual uint64_t DoGetNrBytes (uint32_t symbols, ModulationType modulationType) const = 0; + /** + * Get TTG + * \returns the TTG + */ virtual uint16_t DoGetTtg (void) const = 0; + /** + * Get RTG + * \returns the RTG + */ virtual uint16_t DoGetRtg (void) const = 0; + /** + * Get frame duration code + * \returns the frame duration code + */ virtual uint8_t DoGetFrameDurationCode (void) const = 0; + /** + * Get frame duration + * \param frameDurationCode the frame duration code + * \returns the frame duration time + */ virtual Time DoGetFrameDuration (uint8_t frameDurationCode) const = 0; + /** + * Set phy parameters + */ virtual void DoSetPhyParameters (void) = 0; + /** + * Get sampling factor + * \return the sampling factor + */ virtual double DoGetSamplingFactor (void) const = 0; + /** + * Get NFFT + * \returns the NFFT + */ virtual uint16_t DoGetNfft (void) const = 0; + /** + * Get sampling frequency + * \returns the sampling frequency + */ virtual double DoGetSamplingFrequency (void) const = 0; + /** + * Get G value + * \returns he G value + */ virtual double DoGetGValue (void) const = 0; - Ptr m_device; - Ptr m_channel; + Ptr m_device; ///< the device + Ptr m_channel; ///< channel - uint64_t m_txFrequency; - uint64_t m_rxFrequency; - uint64_t m_scanningFrequency; - EventId m_dlChnlSrchTimeoutEvent; - bool m_duplex; - PhyState m_state; + uint64_t m_txFrequency; ///< transmit frequency + uint64_t m_rxFrequency; ///< receive frequency + uint64_t m_scanningFrequency; ///< scanning frequency + EventId m_dlChnlSrchTimeoutEvent; ///< DL channel search timeout event + bool m_duplex; ///< duplex + PhyState m_state; ///< state - Callback > m_rxCallback; - Callback m_scanningCallback; + Callback > m_rxCallback; ///< receive callback function + Callback m_scanningCallback; ///< scanning callback function - uint8_t m_nrCarriers; - Time m_frameDuration; // in seconds - uint32_t m_frequency; // in KHz - uint32_t m_channelBandwidth; // in Hz - Time m_psDuration; // in seconds - Time m_symbolDuration; // in seconds - uint16_t m_psPerSymbol; - uint16_t m_psPerFrame; - uint32_t m_symbolsPerFrame; - Ptr m_mobility; + uint8_t m_nrCarriers; ///< number of carriers + Time m_frameDuration; ///< in seconds + uint32_t m_frequency; ///< in KHz + uint32_t m_channelBandwidth; ///< in Hz + Time m_psDuration; ///< in seconds + Time m_symbolDuration; ///< in seconds + uint16_t m_psPerSymbol; ///< ps per sumbol + uint16_t m_psPerFrame; ///< ps per framce + uint32_t m_symbolsPerFrame; ///< symbols per frame + Ptr m_mobility; ///< modility model }; } // namespace ns3 diff --git a/src/wimax/model/wimax-tlv.h b/src/wimax/model/wimax-tlv.h index 7fe723b81c5..f082f79563d 100644 --- a/src/wimax/model/wimax-tlv.h +++ b/src/wimax/model/wimax-tlv.h @@ -36,8 +36,9 @@ namespace ns3 { /** * \ingroup wimax - * \brief The value field of a tlv can take different values (uint8_t, uint16, vector...). This class is a virtual interface - * that all the types of tlv values should derive + * The value field of a tlv can take different values (uint8_t, uint16, + * vector, ...). This class is a virtual interface + * from which all the types of tlv values should derive */ class TlvValue { @@ -45,9 +46,24 @@ class TlvValue virtual ~TlvValue () { } + /** + * Get serialized size in bytes + * \returns the serialized size + */ virtual uint32_t GetSerializedSize (void) const = 0; + /** + * Serialize to a buffer + * \param start the iterator + */ virtual void Serialize (Buffer::Iterator start) const = 0; + /** + * Deserialize from a buffer + * \param start the iterator + * \param valueLen the maximum length of the value + * \returns the + */ virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLen ) = 0; + /// Copy function virtual TlvValue * Copy (void) const = 0; private: }; @@ -64,6 +80,7 @@ class TlvValue class Tlv : public Header { public: + /// CommonTypes enumeration enum CommonTypes { HMAC_TUPLE = 149, @@ -74,12 +91,19 @@ class Tlv : public Header VENDOR_ID_EMCODING = 144, VENDOR_SPECIFIC_INFORMATION = 143 }; + /** + * Constructor + * + * \param type type + * \param length the length + * \param value TLV value + */ Tlv (uint8_t type, uint64_t length, const TlvValue & value); Tlv (void); ~Tlv (void); /** * Register this type. - * \return The TypeId. + * \return the TypeId. */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; @@ -87,68 +111,138 @@ class Tlv : public Header virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start); + /** + * Get size of length field + * \returns the size of length field + */ uint8_t GetSizeOfLen (void) const; + /** + * Get type value + * \returns the type + */ uint8_t GetType (void) const; + /** + * Get length value + * \returns the length + */ uint64_t GetLength (void) const; + /** + * Peek value + * \returns the TLV value + */ TlvValue* PeekValue (void); + /** + * Copy TLV + * \returns a pointer to a TLV copy + */ Tlv * Copy (void) const; + /** + * Copy TlvValue + * \returns the TLV value + */ TlvValue * CopyValue (void) const; + /// assignment operator Tlv &operator = (Tlv const& o); + /// type conversion operator Tlv (const Tlv & tlv); private: - uint8_t m_type; - uint64_t m_length; - TlvValue * m_value; + uint8_t m_type; ///< type + uint64_t m_length; ///< length + TlvValue * m_value; ///< value }; // ============================================================================== /** * \ingroup wimax + * \brief U8TlvValue class */ class U8TlvValue : public TlvValue { public: + /** + * Constructor + * + * \param value value to encode + */ U8TlvValue (uint8_t value); U8TlvValue (); ~U8TlvValue (void); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start,uint64_t valueLen); + /** + * Deserialize from a buffer + * \param start the iterator + * \returns the size of the item + */ uint32_t Deserialize (Buffer::Iterator start); + /** + * Get value + * \returns the value + */ uint8_t GetValue (void) const; + /** + * Copy + * \returns a U8 TLV value + */ U8TlvValue * Copy (void) const; private: - uint8_t m_value; + uint8_t m_value; ///< value }; // ============================================================================== /** * \ingroup wimax + * \brief U16TlvValue class */ class U16TlvValue : public TlvValue { public: + /** + * Constructor + * + * \param value value to encode + */ U16TlvValue (uint16_t value); U16TlvValue (); ~U16TlvValue (void); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start,uint64_t valueLen); + /** + * Deserialize from a buffer + * \param start the iterator + * \returns the size + */ uint32_t Deserialize (Buffer::Iterator start); + /** + * Get value + * \returns the value + */ uint16_t GetValue (void) const; + /** + * Copy + * \returns the U16 TLV value + */ virtual U16TlvValue * Copy (void) const; private: - uint16_t m_value; + uint16_t m_value; ///< value }; // ============================================================================== /** * \ingroup wimax + * \brief U32TlvValue class */ class U32TlvValue : public TlvValue { public: + /** + * Constructor + * + * \param value to encode + */ U32TlvValue (uint32_t value); U32TlvValue (); ~U32TlvValue (void); @@ -156,11 +250,24 @@ class U32TlvValue : public TlvValue virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLen); + /** + * Deserialize from a buffer + * \param start the iterator + * \returns the size + */ uint32_t Deserialize (Buffer::Iterator start); + /** + * Get value + * \returns the value + */ uint32_t GetValue (void) const; + /** + * Copy + * \returns the U32 TLV Value + */ virtual U32TlvValue * Copy (void) const; private: - uint32_t m_value; + uint32_t m_value; ///< value }; // ============================================================================== @@ -172,28 +279,47 @@ class U32TlvValue : public TlvValue class VectorTlvValue : public TlvValue { public: + /// TLV vector iterator typedef typedef std::vector::const_iterator Iterator; VectorTlvValue (void); ~VectorTlvValue (void); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength) = 0; + /** + * Begin iterator + * \returns the beginning element + */ Iterator Begin () const; + /** + * End iterator + * \returns the ending element + */ Iterator End () const; + /** + * Add a TLV + * \param val the TLV value + */ void Add (const Tlv & val); + /** + * Copy + * \returns the vector TLV value + */ virtual VectorTlvValue * Copy (void) const = 0; private: - std::vector * m_tlvList; + std::vector * m_tlvList; ///< tlv list }; // ============================================================================== /** * \ingroup wimax + * \brief SfVectorTlvValue class */ class SfVectorTlvValue : public VectorTlvValue { public: + /// Type enumeration enum Type { SFID = 1, @@ -240,6 +366,7 @@ class SfVectorTlvValue : public VectorTlvValue class CsParamVectorTlvValue : public VectorTlvValue { public: + /// Type enumeration enum Type { Classifier_DSC_Action = 1, @@ -260,6 +387,7 @@ class CsParamVectorTlvValue : public VectorTlvValue class ClassificationRuleVectorTlvValue : public VectorTlvValue { public: + /// ClassificationRuleTlvType enumeration enum ClassificationRuleTlvType { Priority = 1, @@ -280,98 +408,176 @@ class ClassificationRuleVectorTlvValue : public VectorTlvValue // ============================================================================== /** * \ingroup wimax + * \brief TosTlvValue class */ class TosTlvValue : public TlvValue { public: TosTlvValue (); - TosTlvValue (uint8_t, uint8_t, uint8_t); + /** + * Constructor + * + * \param low low value + * \param high high value + * \param mask the mask + */ + TosTlvValue (uint8_t low, uint8_t high, uint8_t mask); ~TosTlvValue (); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength); + /** + * Get low part + * \returns the low part + */ uint8_t GetLow (void) const; + /** + * Get high part + * \returns the high part + */ uint8_t GetHigh (void) const; + /** + * Get the mask + * \returns the mask + */ uint8_t GetMask (void) const; + /** + * Copy + * \returns the TOS TLV value + */ virtual TosTlvValue * Copy () const; private: - uint8_t m_low; - uint8_t m_high; - uint8_t m_mask; + uint8_t m_low; ///< low + uint8_t m_high; ///< high + uint8_t m_mask; ///< mask }; // ============================================================================== /** * \ingroup wimax + * \brief PortRangeTlvValue class */ class PortRangeTlvValue : public TlvValue { public: + /// PortRange structure struct PortRange { - uint16_t PortLow; - uint16_t PortHigh; + uint16_t PortLow; ///< low + uint16_t PortHigh; ///< high }; + /// PortRange vector iterator typedef typedef std::vector::const_iterator Iterator; PortRangeTlvValue (); ~PortRangeTlvValue (); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength); + /** + * Add a range + * \param portLow the low port of the range + * \param portHigh the high port of the range + */ void Add (uint16_t portLow, uint16_t portHigh); + /** + * Begin iterator + * \returns the beginning element + */ Iterator Begin () const; + /** + * End iterator + * \returns the ending element + */ Iterator End () const; + /** + * Copy + * \returns the port range tlv value + */ virtual PortRangeTlvValue * Copy (void) const; private: - std::vector * m_portRange; + std::vector * m_portRange; ///< port range }; // ============================================================================== /** * \ingroup wimax + * \brief ProtocolTlvValue class */ class ProtocolTlvValue : public TlvValue { public: ProtocolTlvValue (); ~ProtocolTlvValue (); + /// Iterator typedef typedef std::vector::const_iterator Iterator; virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength); - void Add (uint8_t protiocol); + /** + * Add protocol number + * \param protocol the protocol number + */ + void Add (uint8_t protocol); + /** + * Begin iterator + * \returns the beginning element + */ Iterator Begin () const; + /** + * End iterator + * \return the ending element + */ Iterator End () const; + /** + * Copy + * \returns the protocol tlv value + */ virtual ProtocolTlvValue * Copy (void) const; private: - std::vector * m_protocol; + std::vector * m_protocol; ///< protocol }; // ============================================================================== /** * \ingroup wimax + * \brief Ipv4AddressTlvValue class */ class Ipv4AddressTlvValue : public TlvValue { public: + ///ipv4Addr structure struct ipv4Addr { - Ipv4Address Address; - Ipv4Mask Mask; + Ipv4Address Address; ///< address + Ipv4Mask Mask; ///< mask }; + /// IPv4 address vector iterator typedef typedef std::vector::const_iterator Iterator; Ipv4AddressTlvValue (); ~Ipv4AddressTlvValue (); virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength); + /** + * Add IPv4 address and mask + * \param address the IPv4 address + * \param Mask the IPv4 mask + */ void Add (Ipv4Address address, Ipv4Mask Mask); + /** + * Begin iterator + * \returns the beginning element + */ Iterator Begin () const; + /** + * End iterator + * \returns the ending element + */ Iterator End () const; virtual Ipv4AddressTlvValue * Copy () const; private: - std::vector * m_ipv4Addr; + std::vector * m_ipv4Addr; ///< ipv4 addr }; } diff --git a/src/wimax/test/mac-messages-test.cc b/src/wimax/test/mac-messages-test.cc index f1d0fd89dbf..84c084901d0 100644 --- a/src/wimax/test/mac-messages-test.cc +++ b/src/wimax/test/mac-messages-test.cc @@ -23,8 +23,18 @@ #include "ns3/mac-messages.h" using namespace ns3; -/* - * Test the DSA request message. + +/** + * \ingroup wimax-test + * \defgroup wimax-test wimax module tests + */ + + +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the DSA request message. */ class DsaRequestTestCase : public TestCase { @@ -85,7 +95,12 @@ DsaRequestTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (sfRecv.GetTrafficPriority (), 1, "The sfRecv had the wrong traffic priority."); } -// ============================================================================== +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Mac Messages Test Suite + */ class Ns3WimaxMacMessagesTestSuite : public TestSuite { public: @@ -98,4 +113,4 @@ Ns3WimaxMacMessagesTestSuite::Ns3WimaxMacMessagesTestSuite () AddTestCase (new DsaRequestTestCase, TestCase::QUICK); } -static Ns3WimaxMacMessagesTestSuite ns3WimaxMacMessagesTestSuite; +static Ns3WimaxMacMessagesTestSuite ns3WimaxMacMessagesTestSuite; ///< the test suite diff --git a/src/wimax/test/phy-test.cc b/src/wimax/test/phy-test.cc index 39e8742406e..dbb43bd86be 100644 --- a/src/wimax/test/phy-test.cc +++ b/src/wimax/test/phy-test.cc @@ -37,6 +37,12 @@ NS_LOG_COMPONENT_DEFINE ("WimaxPhyTest"); * */ +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Simple OFDM Test Case + */ class Ns3WimaxSimpleOFDMTestCase : public TestCase { public: @@ -45,7 +51,12 @@ class Ns3WimaxSimpleOFDMTestCase : public TestCase private: virtual void DoRun (void); - bool DoRunOnce (double); + /** + * Run once function + * \param FrameDuration the frame duration + * \returns true if successful + */ + bool DoRunOnce (double FrameDuration); }; @@ -108,10 +119,12 @@ Ns3WimaxSimpleOFDMTestCase::DoRun (void) } } -/* - * Test the SNr tom block error rate module +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the SNr tom block error rate module */ - class Ns3WimaxSNRtoBLERTestCase : public TestCase { public: @@ -120,7 +133,12 @@ class Ns3WimaxSNRtoBLERTestCase : public TestCase private: virtual void DoRun (void); - bool DoRunOnce (uint8_t); + /** + * Run once function + * \param modulationType the modulation type + * \returns true if successful + */ + bool DoRunOnce (uint8_t modulationType); }; @@ -158,8 +176,11 @@ Ns3WimaxSNRtoBLERTestCase::DoRun (void) } } -/* - * The test suite +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief The test suite */ class Ns3WimaxPhyTestSuite : public TestSuite { @@ -174,4 +195,4 @@ Ns3WimaxPhyTestSuite::Ns3WimaxPhyTestSuite () } -static Ns3WimaxPhyTestSuite ns3WimaxPhyTestSuite; +static Ns3WimaxPhyTestSuite ns3WimaxPhyTestSuite; ///< the test suite diff --git a/src/wimax/test/qos-test.cc b/src/wimax/test/qos-test.cc index 93b03e7f97d..6fda66456db 100644 --- a/src/wimax/test/qos-test.cc +++ b/src/wimax/test/qos-test.cc @@ -33,6 +33,12 @@ using namespace ns3; +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Scheduling Test Case + */ class Ns3WimaxSchedulingTestCase : public TestCase { public: @@ -41,6 +47,11 @@ class Ns3WimaxSchedulingTestCase : public TestCase private: virtual void DoRun (void); + /** + * Run once function + * \param scheduler the wimax scheduler type + * \returns true if successful + */ bool DoRunOnce (WimaxHelper::SchedulerType scheduler); }; @@ -151,7 +162,12 @@ Ns3WimaxSchedulingTestCase::DoRun () } -// ============================================================================= +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax SF Type Test Case + */ class Ns3WimaxSFTypeTestCase : public TestCase { public: @@ -160,7 +176,12 @@ class Ns3WimaxSFTypeTestCase : public TestCase private: virtual void DoRun (void); - bool DoRunOnce (ServiceFlow::SchedulingType); + /** + * Run once function + * \param schedulingType the scheduling type + * \returns true if successful + */ + bool DoRunOnce (ServiceFlow::SchedulingType schedulingType); }; @@ -272,6 +293,12 @@ Ns3WimaxSFTypeTestCase::DoRun () } } +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax QoS Test Suite + */ class Ns3WimaxQoSTestSuite : public TestSuite { public: @@ -285,4 +312,4 @@ Ns3WimaxQoSTestSuite::Ns3WimaxQoSTestSuite () AddTestCase (new Ns3WimaxSchedulingTestCase, TestCase::QUICK); } -static Ns3WimaxQoSTestSuite ns3WimaxQoSTestSuite; +static Ns3WimaxQoSTestSuite ns3WimaxQoSTestSuite; ///< the test suite diff --git a/src/wimax/test/ss-mac-test.cc b/src/wimax/test/ss-mac-test.cc index c48954c912b..33dc8b1441f 100644 --- a/src/wimax/test/ss-mac-test.cc +++ b/src/wimax/test/ss-mac-test.cc @@ -27,8 +27,11 @@ using namespace ns3; -/* - * Test the network entry procedure. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the network entry procedure. * Create a network with a BS and 10 SS and check that all the SS perform the * network entry correctly * @@ -85,13 +88,15 @@ Ns3WimaxNetworkEntryTestCase::DoRun (void) Simulator::Destroy (); } -/* - * Test if the management connections are correctly setup. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test if the management connections are correctly setup. * Create a network with a BS and 10 SS and check that the management * connections are correctly setup for all SS * */ - class Ns3WimaxManagementConnectionsTestCase : public TestCase { public: @@ -143,6 +148,13 @@ Ns3WimaxManagementConnectionsTestCase::DoRun (void) } Simulator::Destroy (); } + +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax SS Mac Test Suite + */ class Ns3WimaxSSMacTestSuite : public TestSuite { public: @@ -156,4 +168,4 @@ Ns3WimaxSSMacTestSuite::Ns3WimaxSSMacTestSuite () AddTestCase (new Ns3WimaxManagementConnectionsTestCase, TestCase::QUICK); } -static Ns3WimaxSSMacTestSuite ns3WimaxSSMacTestSuite; +static Ns3WimaxSSMacTestSuite ns3WimaxSSMacTestSuite; ///< the test suite diff --git a/src/wimax/test/wimax-fragmentation-test.cc b/src/wimax/test/wimax-fragmentation-test.cc index 2f6e1809099..a1a53fc6964 100644 --- a/src/wimax/test/wimax-fragmentation-test.cc +++ b/src/wimax/test/wimax-fragmentation-test.cc @@ -30,8 +30,11 @@ using namespace ns3; -/* - * Test the wimax packet fragmentation. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the wimax packet fragmentation. */ class Ns3WimaxFragmentationTestCase : public TestCase { @@ -138,8 +141,13 @@ Ns3WimaxFragmentationTestCase::DoRun (void) delete connectionRx; Simulator::Destroy (); } -// ============================================================================== +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Fragmentation Test Suite + */ class Ns3WimaxFragmentationTestSuite : public TestSuite { public: @@ -152,4 +160,4 @@ Ns3WimaxFragmentationTestSuite::Ns3WimaxFragmentationTestSuite () AddTestCase (new Ns3WimaxFragmentationTestCase, TestCase::QUICK); } -static Ns3WimaxFragmentationTestSuite ns3WimaxFragmentationTestSuite; +static Ns3WimaxFragmentationTestSuite ns3WimaxFragmentationTestSuite; ///< the test suite diff --git a/src/wimax/test/wimax-service-flow-test.cc b/src/wimax/test/wimax-service-flow-test.cc index a243437c639..d89ffc8eccb 100644 --- a/src/wimax/test/wimax-service-flow-test.cc +++ b/src/wimax/test/wimax-service-flow-test.cc @@ -32,8 +32,11 @@ using namespace ns3; -/* - * Test the service flow creation. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the service flow creation. */ class Ns3WimaxSfCreationTestCase : public TestCase { @@ -145,7 +148,12 @@ Ns3WimaxSfCreationTestCase::DoRun (void) Simulator::Destroy (); } -// ============================================================================== +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Service Flow Test Suite + */ class Ns3WimaxServiceFlowTestSuite : public TestSuite { public: @@ -158,4 +166,4 @@ Ns3WimaxServiceFlowTestSuite::Ns3WimaxServiceFlowTestSuite () AddTestCase (new Ns3WimaxSfCreationTestCase, TestCase::QUICK); } -static Ns3WimaxServiceFlowTestSuite ns3WimaxServiceFlowTestSuite; +static Ns3WimaxServiceFlowTestSuite ns3WimaxServiceFlowTestSuite; ///< the test suite diff --git a/src/wimax/test/wimax-tlv-test.cc b/src/wimax/test/wimax-tlv-test.cc index 6e3301f16fd..b09d904daab 100644 --- a/src/wimax/test/wimax-tlv-test.cc +++ b/src/wimax/test/wimax-tlv-test.cc @@ -31,8 +31,11 @@ using namespace ns3; -/* - * Test the wimax tlv implementation. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the wimax tlv implementation. */ class Ns3WimaxCsParamTlvTestCase : public TestCase { @@ -124,10 +127,12 @@ Ns3WimaxCsParamTlvTestCase::DoRun (void) } } } -// ============================================================================== -/* - * Test the service flow tlv implementation. +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Test the service flow tlv implementation. */ class Ns3WimaxSfTlvTestCase : public TestCase { @@ -187,7 +192,12 @@ Ns3WimaxSfTlvTestCase::DoRun (void) NS_TEST_ASSERT_MSG_EQ (sfRecv.GetTrafficPriority (), 1, "The sfRecv had the wrong traffic priority."); } -// ============================================================================== +/** + * \ingroup wimax-test + * \ingroup tests + * + * \brief Ns3 Wimax Tlv Test Suite + */ class Ns3WimaxTlvTestSuite : public TestSuite { public: @@ -201,4 +211,4 @@ Ns3WimaxTlvTestSuite::Ns3WimaxTlvTestSuite () AddTestCase (new Ns3WimaxSfTlvTestCase, TestCase::QUICK); } -static Ns3WimaxTlvTestSuite ns3WimaxTlvTestSuite; +static Ns3WimaxTlvTestSuite ns3WimaxTlvTestSuite; ///< the test suite From 7778696d6766d91f5ff6d808dd97e44d7e14fa50 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sat, 15 Apr 2017 18:47:36 -0700 Subject: [PATCH 002/551] mobility: Doxygen updates --- src/mobility/test/geo-to-cartesian-test.cc | 46 ++++++++-- src/mobility/test/mobility-test-suite.cc | 88 ++++++++++++++++--- .../test/mobility-trace-test-suite.cc | 26 +++--- .../test/ns2-mobility-helper-test-suite.cc | 22 ++++- .../test/rand-cart-around-geo-test.cc | 52 ++++++++--- ...ate-random-waypoint-mobility-model-test.cc | 19 +++- .../test/waypoint-mobility-model-test.cc | 52 ++++++++--- 7 files changed, 246 insertions(+), 59 deletions(-) diff --git a/src/mobility/test/geo-to-cartesian-test.cc b/src/mobility/test/geo-to-cartesian-test.cc index 126c6bd4a68..06022c93d52 100644 --- a/src/mobility/test/geo-to-cartesian-test.cc +++ b/src/mobility/test/geo-to-cartesian-test.cc @@ -486,9 +486,30 @@ const double ZWGS84_MATLAB[216] = {0, 0, 0, 0, 0, 0, 6043686.27224277, -1.55198002803211e-09, -1.55198002803211e-09}; +/** + * \ingroup mobility-test + * \defgroup mobility-test mobility module tests + */ + + +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Geo To Cartesian Test Case + */ class GeoToCartesianTestCase : public TestCase { public: + /** + * Constructor + * + * \param latitude latitude + * \param longitude longitude + * \param altitude altitude + * \param sphType sphere type + * \param i index + */ GeoToCartesianTestCase (double latitude, double longitude, double altitude, @@ -498,15 +519,23 @@ class GeoToCartesianTestCase : public TestCase private: virtual void DoRun (void); + /** + * Name function + * \param latitude the latitude + * \param longitude the longitude + * \param altitude the altitude + * \param sphType the sphere type + * \returns the name string + */ static std::string Name (double latitude, double longitude, double altitude, GeographicPositions::EarthSpheroidType sphType); - double m_latitude; - double m_longitude; - double m_altitude; - GeographicPositions::EarthSpheroidType m_sphType; - int m_i; + double m_latitude; ///< latitude + double m_longitude; ///< longitude + double m_altitude; ///< altitude + GeographicPositions::EarthSpheroidType m_sphType; ///< spheroid type + int m_i; ///< index }; std::string @@ -604,7 +633,12 @@ GeoToCartesianTestCase::DoRun (void) } } - +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Geo To Cartesian Test Suite + */ class GeoToCartesianTestSuite : public TestSuite { public: diff --git a/src/mobility/test/mobility-test-suite.cc b/src/mobility/test/mobility-test-suite.cc index c843d28b9e5..2ed0263162f 100644 --- a/src/mobility/test/mobility-test-suite.cc +++ b/src/mobility/test/mobility-test-suite.cc @@ -34,8 +34,13 @@ using namespace ns3; -// Test whether course change notifications occur regardless of calls -// to Update() position (which are triggered by calls to GetPosition()) +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Test whether course change notifications occur regardless of calls + * to Update() position (which are triggered by calls to GetPosition()) + */ class WaypointLazyNotifyFalse : public TestCase { public: @@ -43,12 +48,21 @@ class WaypointLazyNotifyFalse : public TestCase virtual ~WaypointLazyNotifyFalse (); private: + /** + * Test X position function + * \param expectedXPos the expected X position + */ void TestXPosition (double expectedXPos); + /** + * Course change callback + * \param path the path + * \param model the mobility model + */ void CourseChangeCallback (std::string path, Ptr model); virtual void DoRun (void); - Ptr m_node; - Ptr m_mob; - int m_courseChanges; + Ptr m_node; ///< mode + Ptr m_mob; ///< modility model + int m_courseChanges; ///< course changes }; WaypointLazyNotifyFalse::WaypointLazyNotifyFalse () @@ -95,6 +109,12 @@ WaypointLazyNotifyFalse::DoRun (void) Simulator::Destroy (); } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Waypoint Lazy Notify True + */ class WaypointLazyNotifyTrue : public TestCase { public: @@ -102,11 +122,20 @@ class WaypointLazyNotifyTrue : public TestCase virtual ~WaypointLazyNotifyTrue (); private: + /** + * Text X position function + * \param expectedXPos the expected X position + */ void TestXPosition (double expectedXPos); + /** + * Course change callback + * \param path the path + * \param model the mobility model + */ void CourseChangeCallback (std::string path, Ptr model); virtual void DoRun (void); - Ptr m_node; - Ptr m_mob; + Ptr m_node; ///< node + Ptr m_mob; ///< modility model }; WaypointLazyNotifyTrue::WaypointLazyNotifyTrue () @@ -152,6 +181,12 @@ WaypointLazyNotifyTrue::DoRun (void) Simulator::Destroy (); } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Waypoint Initial Position Is Waypoint Test + */ class WaypointInitialPositionIsWaypoint : public TestCase { public: @@ -159,14 +194,24 @@ class WaypointInitialPositionIsWaypoint : public TestCase virtual ~WaypointInitialPositionIsWaypoint (); private: + /** + * Text X position function + * \param model the mobility model + * \param expectedXPos the expected X position + */ void TestXPosition (Ptr model, double expectedXPos); + /** + * Test number of way points + * \param model the mobility model + * \param num the number of way points + */ void TestNumWaypoints (Ptr model, uint32_t num); virtual void DoRun (void); - Ptr m_mob1; - Ptr m_mob2; - Ptr m_mob3; - Ptr m_mob4; - Ptr m_mob5; + Ptr m_mob1; ///< mobility model 1 + Ptr m_mob2; ///< mobility model 2 + Ptr m_mob3; ///< mobility model 3 + Ptr m_mob4; ///< mobility model 4 + Ptr m_mob5; ///< mobility model 5 }; WaypointInitialPositionIsWaypoint::WaypointInitialPositionIsWaypoint () @@ -276,6 +321,12 @@ WaypointInitialPositionIsWaypoint::DoRun (void) Simulator::Destroy (); } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Waypoint Mobility Model Via Helper Test + */ class WaypointMobilityModelViaHelper : public TestCase { public: @@ -283,6 +334,11 @@ class WaypointMobilityModelViaHelper : public TestCase virtual ~WaypointMobilityModelViaHelper (); private: + /** + * Text X position function + * \param mob the mobility model + * \param expectedXPos the expected X position + */ void TestXPosition (Ptr mob, double expectedXPos); virtual void DoRun (void); }; @@ -354,6 +410,12 @@ WaypointMobilityModelViaHelper::DoRun (void) Simulator::Destroy (); } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Mobility Test Suite + */ class MobilityTestSuite : public TestSuite { public: @@ -369,4 +431,4 @@ MobilityTestSuite::MobilityTestSuite () AddTestCase (new WaypointMobilityModelViaHelper, TestCase::QUICK); } -static MobilityTestSuite mobilityTestSuite; +static MobilityTestSuite mobilityTestSuite; ///< the test suite diff --git a/src/mobility/test/mobility-trace-test-suite.cc b/src/mobility/test/mobility-trace-test-suite.cc index 13addc92cf8..612fee9feab 100644 --- a/src/mobility/test/mobility-trace-test-suite.cc +++ b/src/mobility/test/mobility-trace-test-suite.cc @@ -35,12 +35,12 @@ using namespace ns3; -//=========================================================================== -// Class: MobilityTraceTestCase -// -// -// Test case. -//=========================================================================== +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Mobility Trace Test Case + */ class MobilityTraceTestCase : public TestCase { @@ -107,12 +107,12 @@ MobilityTraceTestCase::DoRun (void) } -//=========================================================================== -// Class: MobilityTraceTestSuite -// -// -// Test suite. -//=========================================================================== +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Mobility Trace Test Suite + */ class MobilityTraceTestSuite : public TestSuite { @@ -126,4 +126,4 @@ MobilityTraceTestSuite::MobilityTraceTestSuite () AddTestCase (new MobilityTraceTestCase, TestCase::QUICK); } -static MobilityTraceTestSuite mobilityTraceTestSuite; +static MobilityTraceTestSuite mobilityTraceTestSuite; ///< the test suite diff --git a/src/mobility/test/ns2-mobility-helper-test-suite.cc b/src/mobility/test/ns2-mobility-helper-test-suite.cc index e990ace44dc..3e34aeffa26 100644 --- a/src/mobility/test/ns2-mobility-helper-test-suite.cc +++ b/src/mobility/test/ns2-mobility-helper-test-suite.cc @@ -74,7 +74,10 @@ bool AreVectorsEqual (Vector const & actual, Vector const & limit, double tol) } /** - * Every test case is supposed to: + * \ingroup mobility-test + * \ingroup tests + * + * \brief Every test case is supposed to: * 1. Generate short mobility trace file * 2. Read it back using Ns2MobilityHelper * 3. Check initial node positions and speeds. @@ -91,6 +94,14 @@ class Ns2MobilityHelperTest : public TestCase Vector pos; ///< reference position Vector vel; ///< reference velocity + /** + * Constructor + * + * \param id reference ID + * \param t time + * \param p position + * \param v velocity + */ ReferencePoint (std::string const & id, Time t, Vector const & p, Vector const & v) : node (id), time (t), @@ -255,7 +266,12 @@ class Ns2MobilityHelperTest : public TestCase } }; -/// The test suite +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief The test suite + */ class Ns2MobilityHelperTestSuite : public TestSuite { public: @@ -517,4 +533,4 @@ class Ns2MobilityHelperTestSuite : public TestSuite AddTestCase (t, TestCase::QUICK); } -} g_ns2TransmobilityHelperTestSuite; +} g_ns2TransmobilityHelperTestSuite; ///< the test suite diff --git a/src/mobility/test/rand-cart-around-geo-test.cc b/src/mobility/test/rand-cart-around-geo-test.cc index 5babe54f932..a7d5df7dedc 100644 --- a/src/mobility/test/rand-cart-around-geo-test.cc +++ b/src/mobility/test/rand-cart-around-geo-test.cc @@ -46,16 +46,34 @@ NS_LOG_COMPONENT_DEFINE ("RandCartAroundGeoTest"); using namespace ns3; -// 0.1 meter tolerance for testing, which is very small compared to the maximum -// distances from origin being tested +/** + * 0.1 meter tolerance for testing, which is very small compared to the maximum + * distances from origin being tested + */ const double TOLERANCE = 0.1; -// earth's radius in meters if modeled as a perfect sphere +/// earth's radius in meters if modeled as a perfect sphere static const double EARTH_RADIUS = 6371e3; +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Rand Cart Around Geo Test Case + */ class RandCartAroundGeoTestCase : public TestCase { public: + /** + * Constructor + * + * \param originLatitude origin latitude + * \param originLongitude origin longitude + * \param maxAltitude maximum altitude + * \param numPoints number of points + * \param maxDistFromOrigin maximum distance from origin + * \param uniRand random variable + */ RandCartAroundGeoTestCase (double originLatitude, double originLongitude, double maxAltitude, @@ -66,15 +84,22 @@ class RandCartAroundGeoTestCase : public TestCase private: virtual void DoRun (void); + /** + * name function + * \param originLatitude the origin latitude + * \param originLongitude the origin longitude + * \param maxDistFromOrigin the maximum distance from the origin + * \returns the name string + */ static std::string Name (double originLatitude, double originLongitude, double maxDistFromOrigin); - double m_originLatitude; - double m_originLongitude; - double m_maxAltitude; - int m_numPoints; - double m_maxDistFromOrigin; - Ptr m_uniRand; + double m_originLatitude; ///< origin latitude + double m_originLongitude; ///< origin longitude + double m_maxAltitude; ///< maximum altitude + int m_numPoints; ///< number of points + double m_maxDistFromOrigin; ///< maximum distance from origin + Ptr m_uniRand; ///< random number }; std::string @@ -143,7 +168,12 @@ RandCartAroundGeoTestCase::DoRun (void) } } - +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Rand Cart Around Geo Test Suite + */ class RandCartAroundGeoTestSuite : public TestSuite { public: @@ -174,4 +204,4 @@ RandCartAroundGeoTestSuite::RandCartAroundGeoTestSuite () } } -static RandCartAroundGeoTestSuite g_RandCartAroundGeoTestSuite; +static RandCartAroundGeoTestSuite g_RandCartAroundGeoTestSuite; ///< the test suite diff --git a/src/mobility/test/steady-state-random-waypoint-mobility-model-test.cc b/src/mobility/test/steady-state-random-waypoint-mobility-model-test.cc index 6e5b2cd121d..073b5c31aef 100644 --- a/src/mobility/test/steady-state-random-waypoint-mobility-model-test.cc +++ b/src/mobility/test/steady-state-random-waypoint-mobility-model-test.cc @@ -28,6 +28,12 @@ using namespace ns3; +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Steady State Random Waypoint Test + */ class SteadyStateRandomWaypointTest : public TestCase { public: @@ -36,11 +42,12 @@ class SteadyStateRandomWaypointTest : public TestCase virtual ~SteadyStateRandomWaypointTest () {} private: - std::vector > mobilityStack; - double count; + std::vector > mobilityStack; ///< modility model + double count; ///< count private: virtual void DoRun (void); virtual void DoTeardown (void); + /// Distribution compare function void DistribCompare (); }; @@ -137,10 +144,16 @@ SteadyStateRandomWaypointTest::DistribCompare () NS_TEST_EXPECT_MSG_EQ_TOL (dev_v, 4.4, 0.22, "Got unexpected velocity standard deviation"); } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Steady State Random Waypoint Test Suite + */ struct SteadyStateRandomWaypointTestSuite : public TestSuite { SteadyStateRandomWaypointTestSuite () : TestSuite ("steady-state-rwp-mobility-model", UNIT) { AddTestCase (new SteadyStateRandomWaypointTest, TestCase::QUICK); } -} g_steadyStateRandomWaypointTestSuite; +} g_steadyStateRandomWaypointTestSuite; ///< the test suite diff --git a/src/mobility/test/waypoint-mobility-model-test.cc b/src/mobility/test/waypoint-mobility-model-test.cc index e2c0b4500e2..1fcbbd8c57f 100644 --- a/src/mobility/test/waypoint-mobility-model-test.cc +++ b/src/mobility/test/waypoint-mobility-model-test.cc @@ -26,9 +26,20 @@ using namespace ns3; +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Waypoint Mobility Model Notify Test + */ class WaypointMobilityModelNotifyTest : public TestCase { public: + /** + * Constructor + * + * \param lazy lazy? + */ WaypointMobilityModelNotifyTest (bool lazy) : TestCase (lazy ? "Check Waypoint Mobility Model LAZY notification accuracy" : "Check Waypoint Mobility Model NON-LAZY notification accuracy"), @@ -40,15 +51,20 @@ class WaypointMobilityModelNotifyTest : public TestCase } private: - std::vector > mobilityStack; - uint32_t mobilityCount; - uint32_t waypointCount; - std::deque waypoints; - bool lazyNotify; + std::vector > mobilityStack; ///< mobilty model + uint32_t mobilityCount; ///< mobility count + uint32_t waypointCount; ///< waypoint count + std::deque waypoints; ///< waypoints + bool lazyNotify; ///< lazy notify? private: virtual void DoRun (void); virtual void DoTeardown (void); + /// Force updates void ForceUpdates (void); + /** + * Course cange callback + * \param model the mobility model + */ void CourseChangeCallback (Ptr model); }; @@ -145,6 +161,12 @@ WaypointMobilityModelNotifyTest::CourseChangeCallback (Ptr } } +/** + * \ingroup mobility-test + * \ingroup tests + * + * \brief Waypoint Mobility Model Add Waypoint Test + */ class WaypointMobilityModelAddWaypointTest : public TestCase { public: @@ -157,13 +179,17 @@ class WaypointMobilityModelAddWaypointTest : public TestCase } private: - Ptr m_mobilityModel; - uint32_t m_waypointCount; - uint32_t m_waypointCounter; - Waypoint m_nextWaypoint; + Ptr m_mobilityModel; ///< mobility model + uint32_t m_waypointCount; ///< waypoint count + uint32_t m_waypointCounter; ///< waypoint counter + Waypoint m_nextWaypoint; ///< next waypoint private: virtual void DoRun (void); virtual void DoTeardown (void); + /** + * Course change calback + * \param model the mobility model + */ void CourseChangeCallback (Ptr model); }; @@ -219,6 +245,12 @@ WaypointMobilityModelAddWaypointTest::CourseChangeCallback (Ptr Date: Sun, 16 Apr 2017 21:52:13 -0700 Subject: [PATCH 003/551] mesh: Doxygen update --- src/mesh/model/dot11s/dot11s-mac-header.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mesh/model/dot11s/dot11s-mac-header.h b/src/mesh/model/dot11s/dot11s-mac-header.h index 39ab8b902a6..0ac9e110d0a 100644 --- a/src/mesh/model/dot11s/dot11s-mac-header.h +++ b/src/mesh/model/dot11s/dot11s-mac-header.h @@ -104,7 +104,7 @@ class MeshHeader : public Header /** * Set Address Extension Mode - * \param value value between 0 and 3 for the two-bit field + * \param num_of_addresses value between 0 and 3 for the two-bit field */ void SetAddressExt (uint8_t num_of_addresses); /** From d86778c51e980c5476fa0adb7cda6fb4adbc0527 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sun, 16 Apr 2017 21:52:59 -0700 Subject: [PATCH 004/551] internet: Doxygen update --- src/internet/model/ndisc-cache.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/internet/model/ndisc-cache.h b/src/internet/model/ndisc-cache.h index 8fef8738239..f7d4107c912 100644 --- a/src/internet/model/ndisc-cache.h +++ b/src/internet/model/ndisc-cache.h @@ -132,6 +132,7 @@ class NdiscCache : public Object * \brief Set the device and interface. * \param device the device * \param interface the IPv6 interface + * \param icmpv6 the ICMPv6 protocol */ void SetDevice (Ptr device, Ptr interface, Ptr icmpv6); From 223061f24ee16f1e970601925070bb8642e00b7d Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sun, 16 Apr 2017 22:04:39 -0700 Subject: [PATCH 005/551] mesh: Doxygen update --- src/wimax/model/ss-net-device.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/wimax/model/ss-net-device.h b/src/wimax/model/ss-net-device.h index 36858f09d08..33fd73c8d9c 100644 --- a/src/wimax/model/ss-net-device.h +++ b/src/wimax/model/ss-net-device.h @@ -223,7 +223,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice */ void SetModulationType (WimaxPhy::ModulationType modulationType); /** - * /returns the most efficient modulation and coding scheme (MCS) supported by the device + * \returns the most efficient modulation and coding scheme (MCS) supported by the device */ WimaxPhy::ModulationType GetModulationType (void) const; /** @@ -309,6 +309,7 @@ class SubscriberStationNetDevice : public WimaxNetDevice /** * \brief Get time to allocation * \param deferTime defer time + * \returns the time to allocation */ Time GetTimeToAllocation (Time deferTime); From bcddf0cc8b428e1ae6004300789f16bf37507b3e Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Mon, 17 Apr 2017 12:01:14 -0700 Subject: [PATCH 006/551] wave: Doxygen updates --- src/wave/examples/vanet-routing-compare.cc | 173 ++++++++------- src/wave/examples/wave-simple-device.cc | 34 ++- src/wave/helper/wave-bsm-helper.h | 12 +- src/wave/helper/wave-bsm-stats.h | 30 ++- src/wave/helper/wave-helper.cc | 34 +++ src/wave/helper/wave-helper.h | 8 +- src/wave/helper/wave-mac-helper.h | 9 + src/wave/helper/wifi-80211p-helper.h | 2 +- src/wave/model/bsm-application.h | 62 +++--- src/wave/model/channel-coordinator.h | 28 ++- src/wave/model/channel-manager.h | 25 ++- src/wave/model/channel-scheduler.cc | 4 + src/wave/model/channel-scheduler.h | 51 +++-- src/wave/model/default-channel-scheduler.cc | 11 +- src/wave/model/default-channel-scheduler.h | 43 +++- src/wave/model/higher-tx-tag.h | 14 +- src/wave/model/ocb-wifi-mac.cc | 1 + src/wave/model/ocb-wifi-mac.h | 8 +- src/wave/model/vendor-specific-action.cc | 31 +++ src/wave/model/vendor-specific-action.h | 44 +++- src/wave/model/vsa-manager.cc | 2 + src/wave/model/vsa-manager.h | 58 +++-- src/wave/model/wave-mac-low.h | 8 +- src/wave/model/wave-net-device.h | 98 ++++++--- src/wave/test/mac-extension-test-suite.cc | 229 ++++++++++++++++---- src/wave/test/ocb-test-suite.cc | 81 ++++++- 26 files changed, 804 insertions(+), 296 deletions(-) diff --git a/src/wave/examples/vanet-routing-compare.cc b/src/wave/examples/vanet-routing-compare.cc index 4c0e4b62728..15ea646c94e 100644 --- a/src/wave/examples/vanet-routing-compare.cc +++ b/src/wave/examples/vanet-routing-compare.cc @@ -202,7 +202,6 @@ class RoutingStats /** * \brief Returns the cumulative number of bytes transmitted - * \param socket the receiving socket * \return none */ uint32_t GetCumulativeTxBytes (); @@ -247,14 +246,14 @@ class RoutingStats void SetTxPkts (uint32_t txPkts); private: - uint32_t m_RxBytes; - uint32_t m_cumulativeRxBytes; - uint32_t m_RxPkts; - uint32_t m_cumulativeRxPkts; - uint32_t m_TxBytes; - uint32_t m_cumulativeTxBytes; - uint32_t m_TxPkts; - uint32_t m_cumulativeTxPkts; + uint32_t m_RxBytes; ///< reeive bytes + uint32_t m_cumulativeRxBytes; ///< cumulative receive bytes + uint32_t m_RxPkts; ///< receive packets + uint32_t m_cumulativeRxPkts; ///< cumulative receive packets + uint32_t m_TxBytes; ///< transmit bytes + uint32_t m_cumulativeTxBytes; ///< cumulative transmit bytes + uint32_t m_TxPkts; ///< transmit packets + uint32_t m_cumulativeTxPkts; ///< cumulative transmit packets }; RoutingStats::RoutingStats () @@ -471,7 +470,7 @@ class RoutingHelper : public Object /** * \brief Sets up a routing packet for tranmission * \param addr destination address - * \parm node source node + * \param node source node * \return Socket to be used for sending/receiving a routed data packet */ Ptr SetupRoutingPacketReceive (Ipv4Address addr, Ptr node); @@ -483,14 +482,14 @@ class RoutingHelper : public Object */ void ReceiveRoutingPacket (Ptr socket); - double m_TotalSimTime; // seconds - uint32_t m_protocol; // routing protocol; 0=NONE, 1=OLSR, 2=AODV, 3=DSDV, 4=DSR - uint32_t m_port; - uint32_t m_nSinks; // number of sink nodes (< all nodes) - int m_routingTables; // dump routing table (at t=5 sec). 0=No, 1=Yes - RoutingStats routingStats; - std::string m_protocolName; - int m_log; + double m_TotalSimTime; ///< seconds + uint32_t m_protocol; ///< routing protocol; 0=NONE, 1=OLSR, 2=AODV, 3=DSDV, 4=DSR + uint32_t m_port; ///< port + uint32_t m_nSinks; ///< number of sink nodes (< all nodes) + int m_routingTables; ///< dump routing table (at t=5 sec). 0=No, 1=Yes + RoutingStats routingStats; ///< routing statistics + std::string m_protocolName; ///< protocol name + int m_log; ///< log }; NS_OBJECT_ENSURE_REGISTERED (RoutingHelper); @@ -777,8 +776,8 @@ class WifiPhyStats : public Object void PhyRxDrop (std::string context, Ptr packet); private: - uint32_t m_phyTxPkts; - uint32_t m_phyTxBytes; + uint32_t m_phyTxPkts; ///< phy transmit packets + uint32_t m_phyTxBytes; ///< phy transmit bytes }; NS_OBJECT_ENSURE_REGISTERED (WifiPhyStats); @@ -1159,6 +1158,8 @@ class VanetRoutingExperiment : public WifiApp /** * \brief Run the simulation + * \param argc command line argument count + * \param argv command line parameters * \return none */ void CommandSetup (int argc, char **argv); @@ -1240,70 +1241,76 @@ class VanetRoutingExperiment : public WifiApp */ void SetGlobalsFromConfig (); + /** + * Course change function + * \param os the output stream + * \param context trace source context (unused) + * \param mobility the mobility model + */ static void - CourseChange (std::ostream *os, std::string foo, Ptr mobility); - - uint32_t m_port; - std::string m_CSVfileName; - std::string m_CSVfileName2; - uint32_t m_nSinks; - std::string m_protocolName; - double m_txp; - bool m_traceMobility; - uint32_t m_protocol; - - uint32_t m_lossModel; - uint32_t m_fading; - std::string m_lossModelName; - - std::string m_phyMode; - uint32_t m_80211mode; - - std::string m_traceFile; - std::string m_logFile; - uint32_t m_mobility; - uint32_t m_nNodes; - double m_TotalSimTime; - std::string m_rate; - std::string m_phyModeB; - std::string m_trName; - int m_nodeSpeed; //in m/s - int m_nodePause; //in s - uint32_t m_wavePacketSize; // bytes - double m_waveInterval; // seconds - int m_verbose; - std::ofstream m_os; - NetDeviceContainer m_adhocTxDevices; - Ipv4InterfaceContainer m_adhocTxInterfaces; - uint32_t m_scenario; - double m_gpsAccuracyNs; - double m_txMaxDelayMs; - int m_routingTables; - int m_asciiTrace; - int m_pcap; - std::string m_loadConfigFilename; - std::string m_saveConfigFilename; - - WaveBsmHelper m_waveBsmHelper; - Ptr m_routingHelper; - Ptr m_wifiPhyStats; - int m_log; - // used to get consistent random numbers across scenarios + CourseChange (std::ostream *os, std::string context, Ptr mobility); + + uint32_t m_port; ///< port + std::string m_CSVfileName; ///< CSV file name + std::string m_CSVfileName2; ///< CSV file name + uint32_t m_nSinks; ///< number of sinks + std::string m_protocolName; ///< protocol name + double m_txp; ///< distance + bool m_traceMobility; ///< trace mobility + uint32_t m_protocol; ///< protocol + + uint32_t m_lossModel; ///< loss model + uint32_t m_fading; ///< fading + std::string m_lossModelName; ///< loss model name + + std::string m_phyMode; ///< phy mode + uint32_t m_80211mode; ///< 80211 mode + + std::string m_traceFile; ///< trace file + std::string m_logFile; ///< log file + uint32_t m_mobility; ///< mobility + uint32_t m_nNodes; ///< number of nodes + double m_TotalSimTime; ///< total sim time + std::string m_rate; ///< rate + std::string m_phyModeB; ///< phy mode + std::string m_trName; ///< trace file name + int m_nodeSpeed; ///< in m/s + int m_nodePause; ///< in s + uint32_t m_wavePacketSize; ///< bytes + double m_waveInterval; ///< seconds + int m_verbose; ///< verbose + std::ofstream m_os; ///< output stream + NetDeviceContainer m_adhocTxDevices; ///< adhoc transmit devices + Ipv4InterfaceContainer m_adhocTxInterfaces; ///< adhoc transmit interfaces + uint32_t m_scenario; ///< scenario + double m_gpsAccuracyNs; ///< GPS accuracy + double m_txMaxDelayMs; ///< transmit maximum delay + int m_routingTables; ///< routing tables + int m_asciiTrace; ///< ascii trace + int m_pcap; ///< PCAP + std::string m_loadConfigFilename; ///< load config file name + std::string m_saveConfigFilename; ///< save configi file name + + WaveBsmHelper m_waveBsmHelper; ///< helper + Ptr m_routingHelper; ///< routing helper + Ptr m_wifiPhyStats; ///< wifi phy statistics + int m_log; ///< log + /// used to get consistent random numbers across scenarios int64_t m_streamIndex; - NodeContainer m_adhocTxNodes; - double m_txSafetyRange1; - double m_txSafetyRange2; - double m_txSafetyRange3; - double m_txSafetyRange4; - double m_txSafetyRange5; - double m_txSafetyRange6; - double m_txSafetyRange7; - double m_txSafetyRange8; - double m_txSafetyRange9; - double m_txSafetyRange10; - std::vector m_txSafetyRanges; - std::string m_exp; - int m_cumulativeBsmCaptureStart; + NodeContainer m_adhocTxNodes; ///< adhoc transmit nodes + double m_txSafetyRange1; ///< range 1 + double m_txSafetyRange2; ///< range 2 + double m_txSafetyRange3; ///< range 3 + double m_txSafetyRange4; ///< range 4 + double m_txSafetyRange5; ///< range 5 + double m_txSafetyRange6; ///< range 6 + double m_txSafetyRange7; ///< range 7 + double m_txSafetyRange8; ///< range 8 + double m_txSafetyRange9; ///< range 9 + double m_txSafetyRange10; ///< range 10 + std::vector m_txSafetyRanges; ///< list of ranges + std::string m_exp; ///< exp + int m_cumulativeBsmCaptureStart; ///< capture start }; VanetRoutingExperiment::VanetRoutingExperiment () @@ -1724,7 +1731,7 @@ VanetRoutingExperiment::Run () // Prints actual position and velocity when a course change event occurs void VanetRoutingExperiment:: -CourseChange (std::ostream *os, std::string foo, Ptr mobility) +CourseChange (std::ostream *os, std::string context, Ptr mobility) { Vector pos = mobility->GetPosition (); // Get position Vector vel = mobility->GetVelocity (); // Get velocity diff --git a/src/wave/examples/wave-simple-device.cc b/src/wave/examples/wave-simple-device.cc index 6ad83185741..cf41e4ec382 100644 --- a/src/wave/examples/wave-simple-device.cc +++ b/src/wave/examples/wave-simple-device.cc @@ -40,21 +40,49 @@ using namespace ns3; class WaveNetDeviceExample { public: + /// Send WSMP example function void SendWsmpExample (void); + /// Send IP example function void SendIpExample (void); + /// Send WSA example void SendWsaExample (void); private: + /** + * Send one WSMP packet function + * \param channel the channel to use + * \param seq the sequence + */ void SendOneWsmpPacket (uint32_t channel, uint32_t seq); + /** + * Send IP packet function + * \param seq the sequence + * \param ipv6 true if IPV6 + */ void SendIpPacket (uint32_t seq, bool ipv6); + /** + * Receive function + * \param dev the device + * \param pkt the packet + * \param mode the mode + * \param sender the sender address + * \returns true if successful + */ bool Receive (Ptr dev, Ptr pkt, uint16_t mode, const Address &sender); - bool ReceiveVsa (Ptr,const Address &, uint32_t, uint32_t); + /** + * Receive VSA functon + * \param pkt the packet + * \param address the address + * \returns true if successful + */ + bool ReceiveVsa (Ptr pkt,const Address & address, uint32_t, uint32_t); + /// Create WAVE nodes function void CreateWaveNodes (void); - NodeContainer nodes; - NetDeviceContainer devices; + NodeContainer nodes; ///< the nodes + NetDeviceContainer devices; ///< the devices }; void WaveNetDeviceExample::CreateWaveNodes (void) diff --git a/src/wave/helper/wave-bsm-helper.h b/src/wave/helper/wave-bsm-helper.h index 1ffd87ed438..acb8a6c9e93 100644 --- a/src/wave/helper/wave-bsm-helper.h +++ b/src/wave/helper/wave-bsm-helper.h @@ -85,11 +85,13 @@ class WaveBsmHelper * \param wavePacketSize the size, in bytes, of a WAVE BSM * \param waveInterval the time, in seconds, between each WAVE BSM transmission, * typically 10 Hz (0.1 second) - * \param gpsAccuracy the timing synchronization accuracy of GPS time, in seconds. + * \param gpsAccuracyNs the timing synchronization accuracy of GPS time, in nanoseconds. * GPS time-sync is ~40-100 ns. Universally synchronized time among all vehicles * will result in all vehicles transmitting safety messages simultaneously, leading * to excessive wireless collisions. - * \param range the expected transmission range, in m. + * \param ranges the expected transmission range, in m. + * \param chAccessMode channel access mode (0=continuous; 1=switching) + * \param txMaxDelay max delay prior to transmit * \return none */ void Install (Ipv4InterfaceContainer & i, @@ -136,10 +138,10 @@ class WaveBsmHelper Ptr InstallPriv (Ptr node) const; ObjectFactory m_factory; //!< Object factory. - WaveBsmStats m_waveBsmStats; - // tx safety range squared, for optimization + WaveBsmStats m_waveBsmStats; ///< wave BSM stats + /// tx safety range squared, for optimization std::vector m_txSafetyRangesSq; - static std::vector nodesMoving; + static std::vector nodesMoving; ///< nodes moving }; } // namespace ns3 diff --git a/src/wave/helper/wave-bsm-stats.h b/src/wave/helper/wave-bsm-stats.h index 00361b123ed..f1def85486f 100644 --- a/src/wave/helper/wave-bsm-stats.h +++ b/src/wave/helper/wave-bsm-stats.h @@ -106,7 +106,8 @@ class WaveBsmStats : public Object * are expected to be received within the coverage area, even * though they may not be physically received (due to collisions * or receiver power thresholds). - * \return none + * \param index index for statistics + * \return none */ void IncExpectedRxPktCount (int index); @@ -123,6 +124,7 @@ class WaveBsmStats : public Object * (i.e. WAVE Basic Safety Messages) are not ACK'd. For packet * delivery ratio (PDR), we need to count only those received packets * that are actually received within the (circular) coverage area. + * \param index index for statistics * \return none */ void IncRxPktInRangeCount (int index); @@ -135,19 +137,21 @@ class WaveBsmStats : public Object /** * \brief Returns the count of expected packets received within range(index) + * \param index index for statistics * \return the count of expected packets received within range(index) */ int GetExpectedRxPktCount (int index); /** * \brief Increments the count of actual packets recevied within range(index) + * \param index index for statistics * \return the count of actual packets received within range(index) */ int GetRxPktInRangeCount (int index); /** * \brief Sets the count of packets expected to received - * \param range index + * \param index index for statistics * \param count the count of packets * \return none */ @@ -155,7 +159,7 @@ class WaveBsmStats : public Object /** * \brief Sets the count of packets within range that are received - * \param range index + * \param index index for statistics * \param count the count of packets * \return none */ @@ -164,6 +168,7 @@ class WaveBsmStats : public Object /** * \brief Resets the count of total packets * expected and/or within range(index) that are received + * \param index index for statistics * \return none */ void ResetTotalRxPktCounts (int index); @@ -201,6 +206,7 @@ class WaveBsmStats : public Object * \brief Returns the BSM Packet Delivery Ratio (PDR) * which is the percent of expected packets within range(index) that * are actually received + * \param index index for statistics * \return the packet delivery ratio (PDR) of BSMs. */ double GetBsmPdr (int index); @@ -209,12 +215,14 @@ class WaveBsmStats : public Object * \brief Returns the cumulative BSM Packet Delivery Ratio (PDR) * which is the percent of cumulative expected packets within range(index) * that are actually received + * \param index index for statistics * \return the packet delivery ratio (PDR) of BSMs. */ double GetCumulativeBsmPdr (int index); /** * \brief Enables/disables logging + * \param log * \return none */ void SetLogging (int log); @@ -226,14 +234,14 @@ class WaveBsmStats : public Object int GetLogging (); private: - int m_wavePktSendCount; - int m_waveByteSendCount; - int m_wavePktReceiveCount; - std::vector m_wavePktInCoverageReceiveCounts; - std::vector m_wavePktExpectedReceiveCounts; - std::vector m_waveTotalPktInCoverageReceiveCounts; - std::vector m_waveTotalPktExpectedReceiveCounts; - int m_log; + int m_wavePktSendCount; ///< packet sent count + int m_waveByteSendCount; ///< byte sent count + int m_wavePktReceiveCount; ///< packet receive count + std::vector m_wavePktInCoverageReceiveCounts; ///< packet in ceoverage receive counts + std::vector m_wavePktExpectedReceiveCounts; ///< packet expected receive counts + std::vector m_waveTotalPktInCoverageReceiveCounts; ///< total packet in coverage receive counts + std::vector m_waveTotalPktExpectedReceiveCounts; ///< total packet expected receive counts + int m_log; ///< log }; } // namespace ns3 diff --git a/src/wave/helper/wave-helper.cc b/src/wave/helper/wave-helper.cc index a6f34a519ce..76faeec5447 100644 --- a/src/wave/helper/wave-helper.cc +++ b/src/wave/helper/wave-helper.cc @@ -36,6 +36,15 @@ NS_LOG_COMPONENT_DEFINE ("WaveHelper"); namespace ns3 { +/** + * ASCII Phy transmit sink with context + * \param stream the output stream + * \param context the context + * \param p the packet + * \param mode the mode + * \param preamble the preamble + * \param txLevel transmit level + */ static void AsciiPhyTransmitSinkWithContext ( Ptr stream, @@ -49,6 +58,14 @@ AsciiPhyTransmitSinkWithContext ( *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl; } +/** + * ASCII Phy transmit sink without context + * \param stream the output stream + * \param p the packet + * \param mode the mode + * \param preamble the preamble + * \param txLevel transmit level + */ static void AsciiPhyTransmitSinkWithoutContext ( Ptr stream, @@ -61,6 +78,15 @@ AsciiPhyTransmitSinkWithoutContext ( *stream->GetStream () << "t " << Simulator::Now ().GetSeconds () << " " << *p << std::endl; } +/** + * ASCII Phy receive sink with context + * \param stream the output stream + * \param context the context + * \param p the packet + * \param snr the SNR + * \param mode the mode + * \param preamble the preamble + */ static void AsciiPhyReceiveSinkWithContext ( Ptr stream, @@ -74,6 +100,14 @@ AsciiPhyReceiveSinkWithContext ( *stream->GetStream () << "r " << Simulator::Now ().GetSeconds () << " " << context << " " << *p << std::endl; } +/** + * ASCII Phy receive sink without context + * \param stream the output stream + * \param p the packet + * \param snr the SNR + * \param mode the mode + * \param preamble the preamble + */ static void AsciiPhyReceiveSinkWithoutContext ( Ptr stream, diff --git a/src/wave/helper/wave-helper.h b/src/wave/helper/wave-helper.h index bbcb758ffb1..70190ee2f5f 100644 --- a/src/wave/helper/wave-helper.h +++ b/src/wave/helper/wave-helper.h @@ -242,10 +242,10 @@ class WaveHelper int64_t AssignStreams (NetDeviceContainer c, int64_t stream); protected: - ObjectFactory m_stationManager; - ObjectFactory m_channelScheduler; - std::vector m_macsForChannelNumber; - uint32_t m_physNumber; + ObjectFactory m_stationManager; ///< station manager + ObjectFactory m_channelScheduler; ///< channel scheduler + std::vector m_macsForChannelNumber; ///< MACs for channel number + uint32_t m_physNumber; ///< Phy number }; } #endif /* WAVE_HELPER_H */ diff --git a/src/wave/helper/wave-mac-helper.h b/src/wave/helper/wave-mac-helper.h index 8927ca45227..5cf9c9b17ec 100644 --- a/src/wave/helper/wave-mac-helper.h +++ b/src/wave/helper/wave-mac-helper.h @@ -27,6 +27,10 @@ namespace ns3 { +/** + * \ingroup wave + * \brief Nqos Wave Mac Helper class + */ class NqosWaveMacHelper : public WifiMacHelper { public: @@ -43,6 +47,7 @@ class NqosWaveMacHelper : public WifiMacHelper /** * Create a mac helper in a default working state. * i.e., this is an ocb mac by default. + * \returns NqosWaveMacHelper */ static NqosWaveMacHelper Default (void); /** @@ -90,6 +95,10 @@ class NqosWaveMacHelper : public WifiMacHelper std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue ()); }; +/** + * \ingroup wave + * \brief Qos Wave Mac Helper class + */ class QosWaveMacHelper : public WifiMacHelper { public: diff --git a/src/wave/helper/wifi-80211p-helper.h b/src/wave/helper/wifi-80211p-helper.h index d30b55cc745..20d227e53e3 100644 --- a/src/wave/helper/wifi-80211p-helper.h +++ b/src/wave/helper/wifi-80211p-helper.h @@ -62,7 +62,7 @@ class Wifi80211pHelper : public WifiHelper /** * \param phy the PHY helper to create PHY objects - * \param mac the MAC helper to create MAC objects + * \param macHelper the MAC helper to create MAC objects * \param c the set of nodes on which a wifi device must be created * \returns a device container which contains all the devices created by this method. */ diff --git a/src/wave/model/bsm-application.h b/src/wave/model/bsm-application.h index f57f5aebf1f..fe28bd986e2 100644 --- a/src/wave/model/bsm-application.h +++ b/src/wave/model/bsm-application.h @@ -40,6 +40,10 @@ namespace ns3 { class BsmApplication : public Application { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); /** @@ -57,13 +61,15 @@ class BsmApplication : public Application * \param wavePacketSize the size, in bytes, of a WAVE BSM * \param waveInterval the time, in seconds, between each WAVE BSM transmission, * typically 10 Hz (0.1 second) - * \param gpsAccuracy the timing synchronization accuracy of GPS time, in seconds. + * \param gpsAccuracyNs the timing synchronization accuracy of GPS time, in nanoseconds. * GPS time-sync is ~40-100 ns. Universally synchronized time among all vehicles * will result in all vehicles transmitting safety messages simultaneously, leading * to excessive wireless collisions. - * \param range the expected transmission range, in m ^ 2. - * \param collection class for WAVE BSM statistics - * \param indicators of whether or not node(s) are moving + * \param rangesSq the expected transmission range, in m ^ 2. + * \param waveBsmStats class for WAVE BSM statistics + * \param nodesMoving of whether or not node(s) are moving + * \param mode + * \param txDelay * \return none */ void Setup (Ipv4InterfaceContainer & i, @@ -84,7 +90,7 @@ class BsmApplication : public Application * have been assigned. The Install() method should have previously been * called by the user. * - * \param stream first stream index to use + * \param streamIndex first stream index to use * \return the number of stream indices assigned by this helper */ int64_t AssignStreams (int64_t streamIndex); @@ -99,8 +105,8 @@ class BsmApplication : public Application private: // inherited from Application base class. - virtual void StartApplication (void); // Called at time specified by Start - virtual void StopApplication (void); // Called at time specified by Stop + virtual void StartApplication (void); ///< Called at time specified by Start + virtual void StopApplication (void); ///< Called at time specified by Stop /** * \brief Creates and transmits a WAVE BSM packet @@ -109,6 +115,7 @@ class BsmApplication : public Application * \param pktCount the number of remaining WAVE BSM packets to be transmitted * \param pktInterval the interval, in seconds, until the next packet * should be transmitted + * \param sendingNodeId * \return none */ void GenerateWaveTraffic (Ptr socket, uint32_t pktSize, @@ -145,29 +152,30 @@ class BsmApplication : public Application */ Ptr GetNetDevice (int id); - Ptr m_waveBsmStats; - // tx safety range squared, for optimization + Ptr m_waveBsmStats; ///< BSM stats + /// tx safety range squared, for optimization std::vector m_txSafetyRangesSq; - Time m_TotalSimTime; - uint32_t m_wavePacketSize; // bytes - uint32_t m_numWavePackets; - Time m_waveInterval; - double m_gpsAccuracyNs; - Ipv4InterfaceContainer * m_adhocTxInterfaces; - std::vector * m_nodesMoving; - Ptr m_unirv; - int m_nodeId; - // WAVE channel access mode. 0=continuous PHY; 1=channel-switching + Time m_TotalSimTime; ///< total sim time + uint32_t m_wavePacketSize; ///< bytes + uint32_t m_numWavePackets; ///< number of wave packets + Time m_waveInterval; ///< wave interval + double m_gpsAccuracyNs; ///< GPS accuracy + Ipv4InterfaceContainer * m_adhocTxInterfaces; ///< transmit interfaces + std::vector * m_nodesMoving; ///< nodes moving + Ptr m_unirv; ///< random variable + int m_nodeId; ///< node ID + /// WAVE channel access mode. 0=continuous PHY; 1=channel-switching int m_chAccessMode; - // When transmitting at a default rate of 10 Hz, - // the subsystem shall transmit every 100 ms +/- - // a random value between 0 and 5 ms. [MPR-BSMTX-TXTIM-002] - // Source: CAMP Vehicle Safety Communications 4 Consortium - // On-board Minimum Performance Requirements - // for V2V Safety Systems Version 1.0, December 17, 2014 - // max transmit delay (default 10ms) + /** + * When transmitting at a default rate of 10 Hz, + * the subsystem shall transmit every 100 ms +/- + * a random value between 0 and 5 ms. [MPR-BSMTX-TXTIM-002] + * Source: CAMP Vehicle Safety Communications 4 Consortium + * On-board Minimum Performance Requirements + * for V2V Safety Systems Version 1.0, December 17, 2014 + * max transmit delay (default 10ms) */ Time m_txMaxDelay; - Time m_prevTxDelay; + Time m_prevTxDelay; ///< prevous transmit delay }; } // namespace ns3 diff --git a/src/wave/model/channel-coordinator.h b/src/wave/model/channel-coordinator.h index d56d5b5fa50..749ebecda8a 100644 --- a/src/wave/model/channel-coordinator.h +++ b/src/wave/model/channel-coordinator.h @@ -70,6 +70,10 @@ class ChannelCoordinationListener : public SimpleRefCount > Listeners; + /// Listeners iterator typedef typedef std::vector >::iterator ListenersI; - Listeners m_listeners; + Listeners m_listeners; ///< listeners - uint32_t m_guardCount; - EventId m_coordination; + uint32_t m_guardCount; ///< guard count + EventId m_coordination; ///< coordination event }; } diff --git a/src/wave/model/channel-manager.h b/src/wave/model/channel-manager.h index a573e7bf6fc..8bccccb4fce 100644 --- a/src/wave/model/channel-manager.h +++ b/src/wave/model/channel-manager.h @@ -60,6 +60,10 @@ namespace ns3 { class ChannelManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); ChannelManager (); virtual ~ChannelManager (); @@ -127,18 +131,23 @@ class ChannelManager : public Object uint32_t GetManagementPowerLevel (uint32_t channelNumber); private: - // 1609.4-2010 Annex H + /// 1609.4-2010 Annex H static const uint32_t DEFAULT_OPERATING_CLASS = 17; + /// WaveChannel structure struct WaveChannel { - uint32_t channelNumber; - uint32_t operatingClass; - bool adaptable; - WifiMode dataRate; - WifiPreamble preamble; - uint32_t txPowerLevel; + uint32_t channelNumber; ///< channel number + uint32_t operatingClass; ///< operating class + bool adaptable; ///< adaptable? + WifiMode dataRate; ///< data rate + WifiPreamble preamble; ///< preamble + uint32_t txPowerLevel; ///< transmit power level + /** + * initializor + * \param channel the channel number + */ WaveChannel (uint32_t channel) : channelNumber (channel), operatingClass (DEFAULT_OPERATING_CLASS), @@ -149,7 +158,7 @@ class ChannelManager : public Object { } }; - std::map m_channels; + std::map m_channels; ///< list of channels }; } diff --git a/src/wave/model/channel-scheduler.cc b/src/wave/model/channel-scheduler.cc index 65058749351..1438d767d13 100644 --- a/src/wave/model/channel-scheduler.cc +++ b/src/wave/model/channel-scheduler.cc @@ -25,6 +25,10 @@ NS_LOG_COMPONENT_DEFINE ("ChannelScheduler"); NS_OBJECT_ENSURE_REGISTERED (ChannelScheduler); + /** + * \brief Get the type ID. + * \return the object TypeId + */ TypeId ChannelScheduler::GetTypeId (void) { diff --git a/src/wave/model/channel-scheduler.h b/src/wave/model/channel-scheduler.h index 6e0112c6540..6e761453ba5 100644 --- a/src/wave/model/channel-scheduler.h +++ b/src/wave/model/channel-scheduler.h @@ -23,13 +23,16 @@ namespace ns3 { class WaveNetDevice; +/// EdcaParameter structure struct EdcaParameter { - uint32_t cwmin; - uint32_t cwmax; - uint32_t aifsn; + uint32_t cwmin; ///< minimum + uint32_t cwmax; ///< maximum + uint32_t aifsn; ///< AIFSN }; +/// EDCA parameters typedef typedef std::map EdcaParameters; +/// EDCA parameters iterator typedef typedef std::map::const_iterator EdcaParametersI; #define EXTENDED_ALTERNATING 0x00 @@ -48,11 +51,12 @@ typedef std::map::const_iterator EdcaParametersI; */ struct SchInfo { - uint32_t channelNumber; + uint32_t channelNumber; ///< channel number //OperationalRateSet operationalRateSet; // not supported - bool immediateAccess; - uint8_t extendedAccess; - EdcaParameters edcaParameters; + bool immediateAccess; ///< immediate access + uint8_t extendedAccess; ///< extended access + EdcaParameters edcaParameters; ///< EDCA parameters + /// Initializer SchInfo () : channelNumber (SCH1), immediateAccess (false), @@ -60,6 +64,12 @@ struct SchInfo { } + /** + * Initializer + * \param channel the channel number + * \param immediate true if immediate access + * \param channelAccess + */ SchInfo (uint32_t channel, bool immediate, uint32_t channelAccess) : channelNumber (channel), immediateAccess (immediate), @@ -67,6 +77,13 @@ struct SchInfo { } + /** + * Initializer + * \param channel the channel number + * \param immediate true if immediate access + * \param channelAccess + * \param edca the EDCA parameters + */ SchInfo (uint32_t channel, bool immediate, uint32_t channelAccess, EdcaParameters edca) : channelNumber (channel), immediateAccess (immediate), @@ -77,6 +94,7 @@ struct SchInfo } }; +/// ChannelAccess enumeration enum ChannelAccess { ContinuousAccess, // continuous access for SCHs @@ -98,6 +116,10 @@ enum ChannelAccess class ChannelScheduler : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); ChannelScheduler (); virtual ~ChannelScheduler (); @@ -108,11 +130,11 @@ class ChannelScheduler : public Object virtual void SetWaveNetDevice (Ptr device); /** * \return whether CCH channel access is assigned. -. */ + */ bool IsCchAccessAssigned (void) const; /** * \return whether SCH channel access is assigned. -. */ + */ bool IsSchAccessAssigned (void) const; /** * \param channelNumber the specified channel number @@ -141,11 +163,11 @@ class ChannelScheduler : public Object /** * \param channelNumber the specified channel number * \return the type of current assigned channel access for the specific channel. -. */ + */ virtual enum ChannelAccess GetAssignedAccessType (uint32_t channelNumber) const = 0; /** - * \param sch_info the request information for assigning SCH access. + * \param schInfo the request information for assigning SCH access. * \return whether the channel access is assigned successfully. * * This method is called to assign channel access for sending packets. @@ -154,6 +176,7 @@ class ChannelScheduler : public Object /** * \param channelNumber indicating which channel should release * the assigned channel access resource. + * \return true if successful. */ bool StopSch (uint32_t channelNumber); @@ -184,17 +207,19 @@ class ChannelScheduler : public Object * This method will assign extended access for SCHs. */ virtual bool AssignExtendedAccess (uint32_t channelNumber, uint32_t extends, bool immediate) = 0; - /* + /** * This method will assign default CCH access for CCH. + * \return whether the channel access is assigned successfully */ virtual bool AssignDefaultCchAccess (void) = 0; /** * \param channelNumber indicating for which channel should release * the assigned channel access resource. + * \return whether the channel access is released successfully */ virtual bool ReleaseAccess (uint32_t channelNumber) = 0; - Ptr m_device; + Ptr m_device; ///< the device }; } diff --git a/src/wave/model/default-channel-scheduler.cc b/src/wave/model/default-channel-scheduler.cc index 832a6b6fef4..25bdfc0c3f8 100644 --- a/src/wave/model/default-channel-scheduler.cc +++ b/src/wave/model/default-channel-scheduler.cc @@ -26,9 +26,18 @@ NS_LOG_COMPONENT_DEFINE ("DefaultChannelScheduler"); NS_OBJECT_ENSURE_REGISTERED (DefaultChannelScheduler); +/** + * \ingroup wave + * \brief CoordinationListener class + */ class CoordinationListener : public ChannelCoordinationListener { public: + /** + * Constructor + * + * \param scheduler channel scheduler + */ CoordinationListener (DefaultChannelScheduler * scheduler) : m_scheduler (scheduler) { @@ -49,7 +58,7 @@ class CoordinationListener : public ChannelCoordinationListener m_scheduler->NotifyGuardSlotStart (duration, cchi); } private: - DefaultChannelScheduler * m_scheduler; + DefaultChannelScheduler * m_scheduler; ///< the scheduler }; TypeId diff --git a/src/wave/model/default-channel-scheduler.h b/src/wave/model/default-channel-scheduler.h index 4d9dbd04be7..5aa460a2bdc 100644 --- a/src/wave/model/default-channel-scheduler.h +++ b/src/wave/model/default-channel-scheduler.h @@ -32,6 +32,10 @@ class WaveNetDevice; class DefaultChannelScheduler : public ChannelScheduler { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); DefaultChannelScheduler (); virtual ~DefaultChannelScheduler (); @@ -43,11 +47,24 @@ class DefaultChannelScheduler : public ChannelScheduler /** * \param channelNumber the specified channel number * \return the type of current assigned channel access for the specific channel. -. */ + */ virtual enum ChannelAccess GetAssignedAccessType (uint32_t channelNumber) const; + /** + * Notify CCH slot start + * \param duration the CCH slot duration + */ void NotifyCchSlotStart (Time duration); + /** + * Notify SCH slot start + * \param duration the SCH slot duration + */ void NotifySchSlotStart (Time duration); + /** + * Notify guard slot start + * \param duration the CCH slot duration + * \param cchi if true, switch to next channel + */ void NotifyGuardSlotStart (Time duration, bool cchi); private: virtual void DoInitialize (void); @@ -78,11 +95,13 @@ class DefaultChannelScheduler : public ChannelScheduler virtual bool AssignExtendedAccess (uint32_t channelNumber, uint32_t extends, bool immediate); /** * This method will assign default CCH access for CCH. + * \return whether the channel access is assigned successfully */ virtual bool AssignDefaultCchAccess (void); /** * \param channelNumber indicating for which channel should release * the assigned channel access resource. + * \return whether the channel access is released successfully */ virtual bool ReleaseAccess (uint32_t channelNumber); /** @@ -91,9 +110,9 @@ class DefaultChannelScheduler : public ChannelScheduler */ void SwitchToNextChannel (uint32_t curChannelNumber, uint32_t nextChannelNumber); - Ptr m_manager; - Ptr m_coordinator; - Ptr m_phy; + Ptr m_manager; ///< channel manager + Ptr m_coordinator; ///< channel coordinator + Ptr m_phy; ///< Phy /** * when m_channelAccess is ContinuousAccess, m_channelNumber @@ -104,16 +123,16 @@ class DefaultChannelScheduler : public ChannelScheduler * is extended access, extends is the number of extends access. * when m_channelAccess is DefaultCchAccess, m_channelNumber is CCH. */ - uint32_t m_channelNumber; - uint32_t m_extend; - EventId m_extendEvent; - enum ChannelAccess m_channelAccess; + uint32_t m_channelNumber; ///< channel number + uint32_t m_extend; ///< extend + EventId m_extendEvent; ///< extend event + enum ChannelAccess m_channelAccess; ///< channel access - EventId m_waitEvent; - uint32_t m_waitChannelNumber; - uint32_t m_waitExtend; + EventId m_waitEvent; ///< wait event + uint32_t m_waitChannelNumber; ///< wait channel number + uint32_t m_waitExtend; ///< wait extend - Ptr m_coordinationListener; + Ptr m_coordinationListener; ///< coordination listener }; } diff --git a/src/wave/model/higher-tx-tag.h b/src/wave/model/higher-tx-tag.h index c4987baa2e9..2992b0d1757 100644 --- a/src/wave/model/higher-tx-tag.h +++ b/src/wave/model/higher-tx-tag.h @@ -45,10 +45,20 @@ class TypeId; class HigherLayerTxVectorTag : public Tag { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; HigherLayerTxVectorTag (void); + /** + * Constructor + * + * \param txVector wifi transmit vector + * \param adaptable is adaptable? + */ HigherLayerTxVectorTag (WifiTxVector txVector, bool adaptable); /** * \returns the tx vector for transmission @@ -65,8 +75,8 @@ class HigherLayerTxVectorTag : public Tag virtual void Print (std::ostream &os) const; private: - WifiTxVector m_txVector; - bool m_adaptable; + WifiTxVector m_txVector; ///< transmit vector + bool m_adaptable; ///< adaptable }; } // namespace ns3 diff --git a/src/wave/model/ocb-wifi-mac.cc b/src/wave/model/ocb-wifi-mac.cc index dc624beddf2..9c0b549d1d0 100644 --- a/src/wave/model/ocb-wifi-mac.cc +++ b/src/wave/model/ocb-wifi-mac.cc @@ -37,6 +37,7 @@ NS_LOG_COMPONENT_DEFINE ("OcbWifiMac"); NS_OBJECT_ENSURE_REGISTERED (OcbWifiMac); +/// Wildcard BSSID const static Mac48Address WILDCARD_BSSID = Mac48Address::GetBroadcast (); TypeId diff --git a/src/wave/model/ocb-wifi-mac.h b/src/wave/model/ocb-wifi-mac.h index 36238d13d7e..af4920ae197 100644 --- a/src/wave/model/ocb-wifi-mac.h +++ b/src/wave/model/ocb-wifi-mac.h @@ -48,6 +48,10 @@ class WaveNetDevice; class OcbWifiMac : public RegularWifiMac { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); OcbWifiMac (void); virtual ~OcbWifiMac (void); @@ -94,8 +98,6 @@ class OcbWifiMac : public RegularWifiMac */ virtual void SetBssid (Mac48Address bssid); /** - * \param bssid the BSSID of the network that this device belongs to. - * * This method shall not be used in WAVE environment and * here it will overloaded to log warn message */ @@ -175,7 +177,7 @@ class OcbWifiMac : public RegularWifiMac private: virtual void Receive (Ptr packet, const WifiMacHeader *hdr); - VendorSpecificContentManager m_vscManager; + VendorSpecificContentManager m_vscManager; ///< VSC manager }; } diff --git a/src/wave/model/vendor-specific-action.cc b/src/wave/model/vendor-specific-action.cc index 66e957c1976..afb8dc423b4 100644 --- a/src/wave/model/vendor-specific-action.cc +++ b/src/wave/model/vendor-specific-action.cc @@ -167,6 +167,12 @@ OrganizationIdentifier::Deserialize (Buffer::Iterator start) return 0; } +/** + * equality operator + * \param a left side object + * \param b right side object + * \returns true if equal + */ bool operator == (const OrganizationIdentifier& a, const OrganizationIdentifier& b) { if (a.m_type != b.m_type) @@ -188,16 +194,34 @@ bool operator == (const OrganizationIdentifier& a, const OrganizationIdentifier& return false; } +/** + * inequality operator + * \param a left side object + * \param b right side object + * \returns true if not equal + */ bool operator != (const OrganizationIdentifier& a, const OrganizationIdentifier& b) { return !(a == b); } +/** + * less than operator + * \param a left side object + * \param b right side object + * \returns true if a < b + */ bool operator < (const OrganizationIdentifier& a, const OrganizationIdentifier& b) { return memcmp (a.m_oi, b.m_oi, std::min (a.m_type, b.m_type)) < 0; } +/** + * output operator + * \param os output stream + * \param oi organization identifier + * \returns output stream + */ std::ostream& operator << (std::ostream& os, const OrganizationIdentifier& oi) { for (int i = 0; i < oi.m_type; i++) @@ -208,6 +232,12 @@ std::ostream& operator << (std::ostream& os, const OrganizationIdentifier& oi) return os; } +/** + * input operator + * \param is input stream + * \param oi organization identifier + * \returns input stream + */ std::istream& operator >> (std::istream& is, const OrganizationIdentifier& oi) { return is; @@ -348,6 +378,7 @@ VendorSpecificContentManager::IsVscCallbackRegistered (OrganizationIdentifier &o return true; } +///VSC callback function static VscCallback null_callback = MakeNullCallback, const OrganizationIdentifier &,Ptr,const Address &> (); VscCallback diff --git a/src/wave/model/vendor-specific-action.h b/src/wave/model/vendor-specific-action.h index 87fe627f2fa..9b38594acfe 100644 --- a/src/wave/model/vendor-specific-action.h +++ b/src/wave/model/vendor-specific-action.h @@ -52,10 +52,18 @@ class OrganizationIdentifier { public: OrganizationIdentifier (void); + /** + * Constructor + * + * \param str identifier name + * \param length identifier length + */ OrganizationIdentifier (const uint8_t *str, uint32_t length); + /// assignment operator OrganizationIdentifier& operator= (const OrganizationIdentifier& oi); virtual ~OrganizationIdentifier (void); + /// OrganizationIdentifierType enumeration enum OrganizationIdentifierType { OUI24 = 3, // 3 bytes @@ -81,8 +89,21 @@ class OrganizationIdentifier enum OrganizationIdentifierType GetType (void) const; // below methods will be called by VendorSpecificActionHeader + /** + * Get serialized size + * \returns the serialized size + */ uint32_t GetSerializedSize (void) const; + /** + * Serialize to buffer + * \param start the iterator + */ void Serialize (Buffer::Iterator start) const; + /** + * Deserialize from buffer + * \param start the iterator + * \returns the deserialize size + */ uint32_t Deserialize (Buffer::Iterator start); private: @@ -92,8 +113,8 @@ class OrganizationIdentifier friend std::ostream& operator << (std::ostream& os, const OrganizationIdentifier& oi); friend std::istream& operator >> (std::istream& is, const OrganizationIdentifier& oi); - enum OrganizationIdentifierType m_type; - uint8_t m_oi[5]; + enum OrganizationIdentifierType m_type; ///< OI type + uint8_t m_oi[5]; ///< organization identifier }; ATTRIBUTE_HELPER_HEADER (OrganizationIdentifier); @@ -148,6 +169,10 @@ class VendorSpecificActionHeader : public Header */ uint8_t GetCategory (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual void Print (std::ostream &os) const; @@ -156,8 +181,8 @@ class VendorSpecificActionHeader : public Header virtual uint32_t Deserialize (Buffer::Iterator start); private: - OrganizationIdentifier m_oi; - uint8_t m_category; + OrganizationIdentifier m_oi; ///< OI + uint8_t m_category; ///< category }; /** @@ -170,6 +195,9 @@ class VendorSpecificActionHeader : public Header */ typedef Callback, const OrganizationIdentifier &, Ptr,const Address &> VscCallback; +/** + * VendorSpecificContentManager class + */ class VendorSpecificContentManager { public: @@ -189,22 +217,26 @@ class VendorSpecificContentManager /** * \param oi the specific OrganizationIdentifier when receive management information * by VendorSpecificAction management frame. + * \return true if registered */ bool IsVscCallbackRegistered (OrganizationIdentifier &oi); /** * \param oi the specific OrganizationIdentifier when receive management information * by VendorSpecificAction management frame. + * \return VscCallback */ VscCallback FindVscCallback (OrganizationIdentifier &oi); private: + /// VSC callback typedef typedef std::map VscCallbacks; + /// VSC callback iterator typedef typedef std::map::iterator VscCallbacksI; - VscCallbacks m_callbacks; + VscCallbacks m_callbacks; ///< VSC callbacks }; -static std::vector OrganizationIdentifiers; +static std::vector OrganizationIdentifiers; ///< the OIs } #endif /* Vendor_Specific_Action_H */ diff --git a/src/wave/model/vsa-manager.cc b/src/wave/model/vsa-manager.cc index 33ee9443b7f..c64f94a1023 100644 --- a/src/wave/model/vsa-manager.cc +++ b/src/wave/model/vsa-manager.cc @@ -29,7 +29,9 @@ NS_LOG_COMPONENT_DEFINE ("VsaManager"); NS_OBJECT_ENSURE_REGISTERED (VsaManager); +/// OI bytes for use in organization identifier const static uint8_t oi_bytes_1609[5] = {0x00, 0x50, 0xC2, 0x4A, 0x40}; +/// OI for IEEE standard 1609 const static OrganizationIdentifier oi_1609 = OrganizationIdentifier (oi_bytes_1609, 5); TypeId diff --git a/src/wave/model/vsa-manager.h b/src/wave/model/vsa-manager.h index 4ebc1d0ed21..a2c99692505 100644 --- a/src/wave/model/vsa-manager.h +++ b/src/wave/model/vsa-manager.h @@ -45,7 +45,6 @@ enum VsaTransmitInterval * is an IEEE 1609 entity. Values are specified in IEEE P1609.0. * Valid range: 0-15 * \param vsc pointer to Information that will be sent as vendor specific content. - * \param vscLength the length of vendor specific content * \param channelNumber The channel on which the transmissions are to occur. * While section 7.2 of the standard specifies that channel identification * comprises Country String, Operating Class, and Channel Number, the channel @@ -53,19 +52,29 @@ enum VsaTransmitInterval * \param repeatRate The number of Vendor Specific Action frames to * be transmitted per 5 s. A value of 0 indicates a single message is to be sent. * If Destination MAC Address is an individual address, Repeat Rate is ignored. - * \param channelInterval The channel interval in which the transmissions + * \param sendInterval The channel interval in which the transmissions * are to occur. */ struct VsaInfo { - Mac48Address peer; - OrganizationIdentifier oi; - uint8_t managementId; - Ptr vsc; - uint32_t channelNumber; - uint8_t repeatRate; - enum VsaTransmitInterval sendInterval; + Mac48Address peer; ///< peer + OrganizationIdentifier oi; ///< OI + uint8_t managementId; ///< management ID + Ptr vsc; ///< VSC + uint32_t channelNumber; ///< channel number + uint8_t repeatRate; ///< repeat rate + enum VsaTransmitInterval sendInterval; ///< send interval + /** + * Initializer + * \param peer the peer MAC address + * \param identifier the organization identifier + * \param manageId the manage ID + * \param vscPacket the VSC packet + * \param channel the channel + * \param repeat the repeat value + * \param interval the transmit interval + */ VsaInfo (Mac48Address peer, OrganizationIdentifier identifier, uint8_t manageId, Ptr vscPacket, uint32_t channel, uint8_t repeat, enum VsaTransmitInterval interval) : peer (peer), @@ -104,6 +113,10 @@ struct VsaInfo class VsaManager : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); VsaManager (void); virtual ~VsaManager (void); @@ -113,6 +126,7 @@ class VsaManager : public Object */ void SetWaveNetDevice (Ptr device); + /// set wave vsa callback function void SetWaveVsaCallback (Callback,const Address &, uint32_t, uint32_t> vsaCallback); /** @@ -128,7 +142,7 @@ class VsaManager : public Object */ void RemoveByChannel (uint32_t channelNumber); /** - * \param channelNumber cancel VSA transmission specified by organization identifier + * \param oi cancel VSA transmission specified by organization identifier */ void RemoveByOrganizationIdentifier (const OrganizationIdentifier &oi); private: @@ -140,21 +154,23 @@ class VsaManager : public Object * \param oi the Organization Identifier of received VSA frame * \param vsc the vendor specific content of received VSA frame * \param src the source address of received VSA frame + * \return true if successful */ bool ReceiveVsc (Ptr mac, const OrganizationIdentifier &oi, Ptr vsc, const Address &src); - // A number of VSA frames will be transmitted repeatedly during the period of 5s. + /// A number of VSA frames will be transmitted repeatedly during the period of 5s. const static uint32_t VSA_REPEAT_PERIOD = 5; + /// VsaWork structure struct VsaWork { - Mac48Address peer; - OrganizationIdentifier oi; - Ptr vsc; - uint32_t channelNumber; - enum VsaTransmitInterval sentInterval; - Time repeatPeriod; - EventId repeat; + Mac48Address peer; ///< peer + OrganizationIdentifier oi; ///< OI + Ptr vsc; ///< VSC + uint32_t channelNumber; ///< channel number + enum VsaTransmitInterval sentInterval; ///< VSA transmit interval + Time repeatPeriod; ///< repeat period + EventId repeat; ///< repeat ID }; /** @@ -172,9 +188,9 @@ class VsaManager : public Object */ void DoSendVsa (enum VsaTransmitInterval interval, uint32_t channel, Ptr vsc, OrganizationIdentifier oi, Mac48Address peer); - Callback,const Address &, uint32_t, uint32_t> m_vsaReceived; - std::vector m_vsas; - Ptr m_device; + Callback,const Address &, uint32_t, uint32_t> m_vsaReceived; ///< VSA received callback + std::vector m_vsas; ///< VSAs + Ptr m_device; ///< the device }; } diff --git a/src/wave/model/wave-mac-low.h b/src/wave/model/wave-mac-low.h index 60ebb2d950a..6532fc9ad13 100644 --- a/src/wave/model/wave-mac-low.h +++ b/src/wave/model/wave-mac-low.h @@ -45,6 +45,10 @@ class WaveNetDevice; class WaveMacLow : public MacLow { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WaveMacLow (); virtual ~WaveMacLow (); @@ -79,8 +83,8 @@ class WaveMacLow : public MacLow */ virtual WifiTxVector GetDataTxVector (Ptr packet, const WifiMacHeader *hdr) const; - Ptr m_scheduler; - Ptr m_coordinator; + Ptr m_scheduler; ///< the channel scheduler + Ptr m_coordinator; ///< the channel coordinator }; } // namespace ns3 diff --git a/src/wave/model/wave-net-device.h b/src/wave/model/wave-net-device.h index 0796ff07a5d..80a2b29b333 100644 --- a/src/wave/model/wave-net-device.h +++ b/src/wave/model/wave-net-device.h @@ -55,12 +55,13 @@ class OcbWifiMac; */ struct TxInfo { - uint32_t channelNumber; - uint32_t priority; - WifiMode dataRate; - WifiPreamble preamble; - uint32_t txPowerLevel; + uint32_t channelNumber; ///< channel number + uint32_t priority; ///< priority + WifiMode dataRate; ///< data rate + WifiPreamble preamble; ///< preamble + uint32_t txPowerLevel; ///< transmit power level // Time expiryTime; // unsupported + /// Initializer TxInfo () : channelNumber (CCH), priority (7), @@ -68,6 +69,14 @@ struct TxInfo { } + /** + * Initializer + * \param channel the channel + * \param prio the priority + * \param rate the wifi mode + * \param preamble the preamble + * \param powerLevel the power level + */ TxInfo (uint32_t channel, uint32_t prio = 7, WifiMode rate = WifiMode (), WifiPreamble preamble = WIFI_PREAMBLE_NONE, uint32_t powerLevel = 8) : channelNumber (channel), priority (prio), @@ -93,11 +102,12 @@ struct TxInfo */ struct TxProfile { - uint32_t channelNumber; - bool adaptable; - uint32_t txPowerLevel; - WifiMode dataRate; - WifiPreamble preamble; + uint32_t channelNumber; ///< channel number + bool adaptable; ///< adaptable + uint32_t txPowerLevel; ///< transmit power level + WifiMode dataRate; ///< data rate + WifiPreamble preamble; ///< preamble + /// Initializer TxProfile (void) : channelNumber (SCH1), adaptable (false), @@ -106,6 +116,12 @@ struct TxProfile { dataRate = WifiMode ("OfdmRate6MbpsBW10MHz"); } + /** + * Initializer + * \param channel the channel number + * \param adapt true to adapt + * \param powerLevel the power level + */ TxProfile (uint32_t channel, bool adapt = true, uint32_t powerLevel = 4) : channelNumber (channel), adaptable (adapt), @@ -133,6 +149,10 @@ struct TxProfile class WaveNetDevice : public NetDevice { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); WaveNetDevice (void); virtual ~WaveNetDevice (void); @@ -199,7 +219,7 @@ class WaveNetDevice : public NetDevice Ptr GetVsaManager (void) const; /** - * \param sch_info the parameters about how to start SCH service + * \param schInfo the parameters about how to start SCH service * \return whether channel access is assigned successfully */ bool StartSch (const SchInfo & schInfo); @@ -210,7 +230,7 @@ class WaveNetDevice : public NetDevice bool StopSch (uint32_t channelNumber); /** - * \param vsa_info the parameters about how to send VSA frame + * \param vsaInfo the parameters about how to send VSA frame * \return whether the request for VSA transmission is completed */ bool StartVsa (const VsaInfo & vsaInfo); @@ -284,16 +304,16 @@ class WaveNetDevice : public NetDevice /** * \param packet packet sent from above down to Network Device - * \param dest mac address of the destination (already resolved) - * \param protocolNumber identifies the type of payload contained in - * this packet. Used to call the right L3Protocol when the packet - * is received. - * \return whether the Send operation succeeded - * - * Normally this method is called by 1609.3 standard to - * send IP-based packets, however high layers can also send packets - * in other types except IP-based packets in CCH. - */ + * \param dest mac address of the destination (already resolved) + * \param protocolNumber identifies the type of payload contained in + * this packet. Used to call the right L3Protocol when the packet + * is received. + * \return whether the Send operation succeeded + * + * Normally this method is called by 1609.3 standard to + * send IP-based packets, however high layers can also send packets + * in other types except IP-based packets in CCH. + */ virtual bool Send (Ptr packet, const Address& dest, uint16_t protocolNumber); // inherited from NetDevice base class. @@ -322,10 +342,12 @@ class WaveNetDevice : public NetDevice virtual bool SupportsSendFrom (void) const; private: - // This value conforms to the 802.11 specification + /// This value conforms to the 802.11 specification static const uint16_t MAX_MSDU_SIZE = 2304; + /// IP v4 Protocol number static const uint16_t IPv4_PROT_NUMBER = 0x0800; + /// IP v6 Protocol number static const uint16_t IPv6_PROT_NUMBER = 0x86DD; virtual void DoDispose (void); @@ -345,18 +367,22 @@ class WaveNetDevice : public NetDevice */ void ForwardUp (Ptr packet, Mac48Address from, Mac48Address to); + /// MacEntities typedef typedef std::map > MacEntities; + /// MacEntities iterator typedef typedef std::map >::const_iterator MacEntitiesI; - MacEntities m_macEntities; - typedef std::vector > PhyEntities; + MacEntities m_macEntities; ///< MAC entities + /// PhyEntities typedef + typedef std::vector > PhyEntities; + /// PhyEntities iterator typedef typedef std::vector >::const_iterator PhyEntitiesI; - PhyEntities m_phyEntities; + PhyEntities m_phyEntities; ///< Phy entities - Ptr m_channelManager; - Ptr m_channelScheduler; - Ptr m_channelCoordinator; - Ptr m_vsaManager; - TxProfile *m_txProfile; + Ptr m_channelManager; ///< the channel manager + Ptr m_channelScheduler; ///< the channel scheduler + Ptr m_channelCoordinator; ///< the channel coordinator + Ptr m_vsaManager; ///< the VSA manager + TxProfile *m_txProfile; ///< transmit profile /** * \todo The Address arguments should be passed * by const reference, since they are large. @@ -364,11 +390,11 @@ class WaveNetDevice : public NetDevice TracedCallback m_addressChange; // copy from WifiNetDevice - Ptr m_node; - NetDevice::ReceiveCallback m_forwardUp; - NetDevice::PromiscReceiveCallback m_promiscRx; - uint32_t m_ifIndex; - mutable uint16_t m_mtu; + Ptr m_node; ///< the node + NetDevice::ReceiveCallback m_forwardUp; ///< forward up receive callback + NetDevice::PromiscReceiveCallback m_promiscRx; ///< promiscious receive callback + uint32_t m_ifIndex; ///< IF index + mutable uint16_t m_mtu; ///< MTU }; } // namespace ns3 diff --git a/src/wave/test/mac-extension-test-suite.cc b/src/wave/test/mac-extension-test-suite.cc index f849a14a790..09ef1c1fe24 100644 --- a/src/wave/test/mac-extension-test-suite.cc +++ b/src/wave/test/mac-extension-test-suite.cc @@ -29,12 +29,23 @@ using namespace ns3; -// This test case tests the channel coordination. -// In particular, it checks the following: -// - channel interval calculation including CCH Interval, SCH Interval, -// Guard Interval and Sync Interval -// - current interval state for current time and future time -// - channel coordination events notified at the correct time. +/** + * \ingroup wave-test + * \defgroup wave-test wave module tests + */ + + +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief This test case tests the channel coordination. + * In particular, it checks the following: + * - channel interval calculation including CCH Interval, SCH Interval, + * Guard Interval and Sync Interval + * - current interval state for current time and future time + * - channel coordination events notified at the correct time. + */ class ChannelCoordinationTestCase : public TestCase { public: @@ -42,20 +53,49 @@ class ChannelCoordinationTestCase : public TestCase virtual ~ChannelCoordinationTestCase (void); // below three methods are used in CoordinationTestListener + /** + * Notify CCS start now function + * \param duration the duration + */ void NotifyCchStartNow (Time duration); + /** + * Notify SCH start now function + * \param duration the duration + */ void NotifySchStartNow (Time duration); + /** + * Notify guard start now function + * \param duration the duration + * \param inCchInterval the CCH interval + */ void NotifyGuardStartNow (Time duration, bool inCchInterval); private: + /** + * Test interval after function + * \param cchi the CCHI + * \param schi the SCHI + * \param guardi the guard + */ void TestIntervalAfter (bool cchi, bool schi, bool guardi); virtual void DoRun (void); - Ptr m_coordinator; + Ptr m_coordinator; ///< coordinator }; -// CoordinationTestListener is used to test channel coordination events +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief CoordinationTestListener is used to test channel coordination events + */ class CoordinationTestListener : public ChannelCoordinationListener { public: + /** + * Constructor + * + * \param coordinatorTest channel coordination test case + */ CoordinationTestListener (ChannelCoordinationTestCase *coordinatorTest) : m_coordinatorTest (coordinatorTest) { @@ -75,7 +115,7 @@ class CoordinationTestListener : public ChannelCoordinationListener { m_coordinatorTest->NotifyGuardStartNow (duration, cchi); } - ChannelCoordinationTestCase *m_coordinatorTest; + ChannelCoordinationTestCase *m_coordinatorTest; ///< coordinator test }; ChannelCoordinationTestCase::ChannelCoordinationTestCase (void) @@ -216,9 +256,20 @@ ChannelCoordinationTestCase::DoRun () Simulator::Destroy (); } +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief Test Case Helper + */ class TestCaseHelper { public: + /** + * Create WAVE device function + * \param nodesNumber the number of nodes + * \returns the collection of nodes + */ static NetDeviceContainer CreatWaveDevice (uint32_t nodesNumber = 2); }; @@ -264,22 +315,46 @@ class ChannelRoutingTestCase : public TestCase ChannelRoutingTestCase (void); virtual ~ChannelRoutingTestCase (void); - // send IP-based packets - // shouldSuccess is used to check whether packet sent should be successful. + /** + * Send IP-based packets + * + * \param shouldSucceed is used to check whether packet sent should be successful. + * \param ipv6 is IPv6? + */ void SendIp (bool shouldSucceed, bool ipv6); - // send WSMP or other packets - // shouldSuccess is used to check whether packet sent should be successful. + /** + * Send WSMP or other packets + * \param shouldSucceed is used to check whether packet sent should be successful. + * \param txInfo transmit info + */ void SendWsmp (bool shouldSucceed, const TxInfo &txInfo); - // send VSA management frames - // shouldSuccess is used to check whether packet sent should be successful. + /** + * Send VSA management frames + * \param shouldSucceed is used to check whether packet sent should be successful. + * \param vsaInfo VSA info + */ void SendWsa (bool shouldSucceed, const VsaInfo &vsaInfo); private: virtual void DoRun (void); + /** + * Receive function + * \param dev the device + * \param pkt the packet + * \param mode the mode + * \param sender the sender address + * \returns true if successful + */ bool Receive (Ptr dev, Ptr pkt, uint16_t mode, const Address &sender); - bool ReceiveVsa (Ptr,const Address &, uint32_t, uint32_t); - - Ptr m_sender; + /** + * Receive VSA functon + * \param pkt the packet + * \param address the address + * \returns true if successful + */ + bool ReceiveVsa (Ptr pkt,const Address & address, uint32_t, uint32_t); + + Ptr m_sender; ///< sender }; ChannelRoutingTestCase::ChannelRoutingTestCase (void) @@ -448,33 +523,78 @@ ChannelRoutingTestCase::DoRun () } } -// This test case tests channel access assignments which is done by -// StartSch and StopSch method of WaveNetDevice. -// channel access assignments include ContinuousAccess, ExtendedAccess, -// and AlternatingAccess. -// The results of this test case depend on the implementation of ChannelScheduler -// In this case, the results depend on class "DefaultChannelScheduler". +/** + * This test case tests channel access assignments which is done by + * StartSch and StopSch method of WaveNetDevice. + * channel access assignments include ContinuousAccess, ExtendedAccess, + * and AlternatingAccess. + * The results of this test case depend on the implementation of ChannelScheduler + * In this case, the results depend on class "DefaultChannelScheduler". + */ class ChannelAccessTestCase : public TestCase { public: ChannelAccessTestCase (void); virtual ~ChannelAccessTestCase (void); private: - void TestContinuous (SchInfo &info, bool shouldSuccceed); + /** + * Test continuous function + * \param info the schedule info + * \param shouldSucceed true if it should succeed + */ + void TestContinuous (SchInfo &info, bool shouldSucceed); + /** + * Test continuous after function + * \param channelNumber the channel number + * \param isAccessAssigned true if access assigned + */ void TestContinuousAfter (uint32_t channelNumber, bool isAccessAssigned); - void TestExtended (SchInfo &info, bool shouldSuccceed); + /** + * Test extended function + * \param info the schedule info + * \param shouldSucceed true if it should succeed + */ + void TestExtended (SchInfo &info, bool shouldSucceed); + /** + * Test extended after function + * \param channelNumber the channel number + * \param isAccessAssigned true if access assigned + */ void TestExtendedAfter (uint32_t channelNumber, bool isAccessAssigned); - void TestAlternating (SchInfo &info, bool shouldSuccceed); + /** + * Test aternating function + * \param info the schedule info + * \param shouldSucceed true if it should succeed + */ + void TestAlternating (SchInfo &info, bool shouldSucceed); + /** + * Test alternating after function + * \param channelNumber the channel number + * \param isAccessAssigned true if access assigned + */ void TestAlternatingAfter (uint32_t channelNumber, bool isAccessAssigned); + /** + * Send X function + * \param channel the channel number + * \param receiverId + */ void SendX (uint32_t channel, uint32_t receiverId); + /** + * Receive function + * \param dev the device + * \param pkt the packet + * \param mode the mode + * \param sender the sender address + * \returns true if successful + */ bool Receive (Ptr dev, Ptr pkt, uint16_t mode, const Address &sender); virtual void DoRun (void); - NetDeviceContainer m_devices; - Ptr m_sender; - uint32_t m_received; + NetDeviceContainer m_devices; ///< the devices + Ptr m_sender; ///< sender + uint32_t m_received; ///< received }; ChannelAccessTestCase::ChannelAccessTestCase (void) @@ -486,10 +606,10 @@ ChannelAccessTestCase::~ChannelAccessTestCase (void) } void -ChannelAccessTestCase::TestContinuous (SchInfo &info, bool shouldSuccceed) +ChannelAccessTestCase::TestContinuous (SchInfo &info, bool shouldSucceed) { bool result = m_sender->StartSch (info); - NS_TEST_EXPECT_MSG_EQ (result, shouldSuccceed, "TestContinuous fail at " << Now ().GetSeconds ()); + NS_TEST_EXPECT_MSG_EQ (result, shouldSucceed, "TestContinuous fail at " << Now ().GetSeconds ()); } void ChannelAccessTestCase::TestContinuousAfter (uint32_t channelNumber, bool isAccessAssigned) @@ -498,10 +618,10 @@ ChannelAccessTestCase::TestContinuousAfter (uint32_t channelNumber, bool isAcces NS_TEST_EXPECT_MSG_EQ (result, isAccessAssigned, "TestContinuousAfter fail at " << Now ().GetSeconds ()); } void -ChannelAccessTestCase::TestExtended (SchInfo &info, bool shouldSuccceed) +ChannelAccessTestCase::TestExtended (SchInfo &info, bool shouldSucceed) { bool result = m_sender->StartSch (info); - NS_TEST_EXPECT_MSG_EQ (result, shouldSuccceed, "TestExtended fail at " << Now ().GetSeconds ()); + NS_TEST_EXPECT_MSG_EQ (result, shouldSucceed, "TestExtended fail at " << Now ().GetSeconds ()); } void ChannelAccessTestCase::TestExtendedAfter (uint32_t channelNumber, bool isAccessAssigned) @@ -511,10 +631,10 @@ ChannelAccessTestCase::TestExtendedAfter (uint32_t channelNumber, bool isAccessA } void -ChannelAccessTestCase::TestAlternating (SchInfo &info, bool shouldSuccceed) +ChannelAccessTestCase::TestAlternating (SchInfo &info, bool shouldSucceed) { bool result = m_sender->StartSch (info); - NS_TEST_EXPECT_MSG_EQ (result, shouldSuccceed, "TestAlternating fail at " << Now ().GetSeconds ()); + NS_TEST_EXPECT_MSG_EQ (result, shouldSucceed, "TestAlternating fail at " << Now ().GetSeconds ()); } void ChannelAccessTestCase::TestAlternatingAfter (uint32_t channelNumber, bool isAccessAssigned) @@ -892,8 +1012,13 @@ ChannelAccessTestCase::DoRun () } } -// The Annex C of IEEE 1609.4 : "Avoiding transmission at scheduled guard intervals" -// This feature is implemented in WaveMacLow::StartTransmission method +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief The Annex C of IEEE 1609.4 : "Avoiding transmission at scheduled guard intervals" + * This feature is implemented in WaveMacLow::StartTransmission method + */ class AnnexC_TestCase : public TestCase { public: @@ -902,12 +1027,26 @@ class AnnexC_TestCase : public TestCase private: virtual void DoRun (void); + /** + * Send packet function + * \param packetSize the packet size + * \param txInfo the transmit info + * \param sequence the sequence + */ void SendPacket (uint32_t packetSize, const TxInfo & txInfo, uint32_t sequence); + /** + * Receive function + * \param dev the device + * \param pkt the packet + * \param mode the mode + * \param sender the sender address + * \returns true if successful + */ bool Receive (Ptr dev, Ptr pkt, uint16_t mode, const Address &sender); - NetDeviceContainer m_devices; - Ptr m_sender; - Ptr m_receiver; + NetDeviceContainer m_devices; ///< devices + Ptr m_sender; ///< sender + Ptr m_receiver; ///< receiver }; AnnexC_TestCase::AnnexC_TestCase (void) @@ -1042,6 +1181,12 @@ AnnexC_TestCase::DoRun (void) Simulator::Destroy (); } +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief Wave Mac Test Suite + */ class WaveMacTestSuite : public TestSuite { public: @@ -1059,4 +1204,4 @@ WaveMacTestSuite::WaveMacTestSuite () } // Do not forget to allocate an instance of this TestSuite -static WaveMacTestSuite waveMacTestSuite; +static WaveMacTestSuite waveMacTestSuite; ///< the test suite diff --git a/src/wave/test/ocb-test-suite.cc b/src/wave/test/ocb-test-suite.cc index 47a6f6664a8..17d183d1cba 100644 --- a/src/wave/test/ocb-test-suite.cc +++ b/src/wave/test/ocb-test-suite.cc @@ -72,6 +72,12 @@ AssignWifiRandomStreams (Ptr mac, int64_t stream) } } +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief Ocb Wifi Mac Test Case + */ class OcbWifiMacTestCase : public TestCase { public: @@ -80,30 +86,81 @@ class OcbWifiMacTestCase : public TestCase private: virtual void DoRun (void); - void MacAssoc (std::string context,Mac48Address bssid); + /** + * MAC associate function + * \param context the context + * \param bssid the BSSID + */ + void MacAssoc (std::string context, Mac48Address bssid); + /** + * Phy receive ok trace function + * \param context the context + * \param packet the packet + * \param snr the SNR + * \param mode the mode + * \param preamble the preamble + */ void PhyRxOkTrace (std::string context, Ptr packet, double snr, WifiMode mode, enum WifiPreamble preamble); + /** + * Phy transmit trace function + * \param context the context + * \param packet the packet + * \param mode the mode + * \param preamble the preamble + * \param txPower the transmit power + */ void PhyTxTrace (std::string context, Ptr packet, WifiMode mode, WifiPreamble preamble, uint8_t txPower); + /** + * Get current position function + * \param i the current position index + * \returns the current position vector + */ Vector GetCurrentPosition (uint32_t i); + /** + * Advance position function + * \param node the node + */ void AdvancePosition (Ptr node); + /// Pre random configuration function void PreRandomConfiguration (void); + /** + * Configure AP STA mode function + * \param static_node the static node + * \param mobile_node the mobile node + */ void ConfigureApStaMode (Ptr static_node, Ptr mobile_node); + /** + * Configure adhoc mode function + * \param static_node the static node + * \param mobile_node the mobile node + */ void ConfigureAdhocMode (Ptr static_node, Ptr mobile_node); + /** + * Configure OCB mode function + * \param static_node the static node + * \param mobile_node the mobile node + */ void ConfigureOcbMode (Ptr static_node, Ptr mobile_node); + /** + * Post device configuration function + * \param static_node the static node + * \param mobile_node the mobile node + */ void PostDeviceConfiguration (Ptr static_node, Ptr mobile_node); - Time phytx_time; - Vector phytx_pos; + Time phytx_time; ///< Phy transmit time + Vector phytx_pos; ///< Phy transmit position - Time macassoc_time; - Vector macassoc_pos; + Time macassoc_time; ///< MAC associate time + Vector macassoc_pos; ///< MAC associate position - Time phyrx_time; - Vector phyrx_pos; + Time phyrx_time; ///< Phy receive time + Vector phyrx_pos; ///< Phy receive position // nodes.Get (0) is static node // nodes.Get (1) is mobile node - NodeContainer nodes; + NodeContainer nodes; ///< the nodes }; OcbWifiMacTestCase::OcbWifiMacTestCase (void) @@ -384,6 +441,12 @@ OcbWifiMacTestCase::PreRandomConfiguration () // the WiFi random variables is set in PostDeviceConfiguration method. } +/** + * \ingroup wave-test + * \ingroup tests + * + * \brief Ocb Test Suite + */ class OcbTestSuite : public TestSuite { public: @@ -398,5 +461,5 @@ OcbTestSuite::OcbTestSuite () } // Do not forget to allocate an instance of this TestSuite -static OcbTestSuite ocbTestSuite; +static OcbTestSuite ocbTestSuite; ///< the test suite From 4316f2cd52533c9ef50df94f558879def5920f9c Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 18 Apr 2017 16:59:14 +0300 Subject: [PATCH 007/551] wifi: Use Time::IsZero in InterferenceHelper::CalculateChunkSuccessRate --- src/wifi/model/interference-helper.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wifi/model/interference-helper.cc b/src/wifi/model/interference-helper.cc index f48914cb85e..db383fd36f6 100644 --- a/src/wifi/model/interference-helper.cc +++ b/src/wifi/model/interference-helper.cc @@ -261,7 +261,7 @@ InterferenceHelper::CalculateNoiseInterferenceW (Ptr double InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector) const { - if (duration == NanoSeconds (0)) + if (duration.IsZero ()) { return 1.0; } From 3e5663ca91c1b6ce440619a5f327a319378dc627 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 20:42:37 +0200 Subject: [PATCH 008/551] wifi: use Time methods --- src/wifi/model/edca-txop-n.cc | 26 +++++++++++++------------- src/wifi/model/mac-low.cc | 18 +++++++++--------- src/wifi/model/wifi-phy.cc | 2 +- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index c63b40ca014..6c7dd1c6c6d 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -545,7 +545,7 @@ EdcaTxopN::GotAck (void) m_dcf->ResetCw (); if (!HasTxop ()) { - if (m_currentHdr.IsQosData () && GetTxopLimit () > NanoSeconds (0)) + if (m_currentHdr.IsQosData () && GetTxopLimit ().IsStrictlyPositive ()) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } @@ -560,7 +560,7 @@ EdcaTxopN::GotAck (void) NS_LOG_DEBUG ("got ack. tx not done, size=" << m_currentPacket->GetSize ()); if (!HasTxop ()) { - if (m_currentHdr.IsQosData () && GetTxopLimit () > NanoSeconds (0)) + if (m_currentHdr.IsQosData () && GetTxopLimit ().IsStrictlyPositive ()) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); m_cwTrace = m_dcf->GetCw (); @@ -838,7 +838,7 @@ EdcaTxopN::StartNextPacket (void) { NS_LOG_FUNCTION (this); Time txopLimit = GetTxopLimit (); - NS_ASSERT (txopLimit == NanoSeconds (0) || Simulator::Now () - m_startTxop <= txopLimit); + NS_ASSERT (txopLimit.IsZero () || Simulator::Now () - m_startTxop <= txopLimit); WifiMacHeader hdr = m_currentHdr; Ptr peekedPacket = m_baManager->GetNextPacket (hdr); if (peekedPacket == 0) @@ -859,7 +859,7 @@ EdcaTxopN::StartNextPacket (void) } else if (peekedPacket == 0) { - if (txopLimit > NanoSeconds (0)) + if (txopLimit.IsStrictlyPositive ()) { NS_ASSERT (Simulator::Now () - m_startTxop <= txopLimit); m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); @@ -900,7 +900,7 @@ EdcaTxopN::StartNextPacket (void) CompleteTx (); } } - else if (txopLimit > NanoSeconds (0)) + else if (txopLimit.IsStrictlyPositive ()) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } @@ -911,9 +911,9 @@ EdcaTxopN::GetTxopRemaining (void) const { Time remainingTxop = GetTxopLimit (); remainingTxop -= (Simulator::Now () - m_startTxop); - if (remainingTxop < MicroSeconds (0)) + if (remainingTxop.IsStrictlyNegative ()) { - remainingTxop = MicroSeconds (0); + remainingTxop = Seconds (0); } NS_LOG_FUNCTION (this << remainingTxop); return remainingTxop; @@ -924,7 +924,7 @@ EdcaTxopN::HasTxop (void) const { NS_LOG_FUNCTION (this); WifiMacHeader hdr; - if (!m_currentHdr.IsQosData () || GetTxopLimit () == NanoSeconds (0)) + if (!m_currentHdr.IsQosData () || GetTxopLimit ().IsZero ()) { return false; } @@ -963,7 +963,7 @@ EdcaTxopN::EndTxNoAck (void) { NS_LOG_FUNCTION (this); NS_LOG_DEBUG ("a transmission that did not require an ACK just finished"); - if (m_currentHdr.IsQosData () && m_currentHdr.IsQosBlockAck () && GetTxopLimit () > NanoSeconds (0)) + if (m_currentHdr.IsQosData () && m_currentHdr.IsQosBlockAck () && GetTxopLimit ().IsStrictlyPositive ()) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } @@ -992,7 +992,7 @@ EdcaTxopN::NeedFragmentation (void) const return false; } bool needTxopFragmentation = false; - if (GetTxopLimit () > NanoSeconds (0) && m_currentHdr.IsData ()) + if (GetTxopLimit ().IsStrictlyPositive () && m_currentHdr.IsData ()) { needTxopFragmentation = (GetLow ()->CalculateOverallTxTime (m_currentPacket, &m_currentHdr, m_currentParams) > GetTxopLimit ()); } @@ -1002,7 +1002,7 @@ EdcaTxopN::NeedFragmentation (void) const bool EdcaTxopN::IsTxopFragmentation () const { - if (GetTxopLimit () == NanoSeconds (0)) + if (GetTxopLimit ().IsZero ()) { return false; } @@ -1018,7 +1018,7 @@ uint32_t EdcaTxopN::GetTxopFragmentSize () const { Time txopDuration = GetTxopLimit (); - if (txopDuration == NanoSeconds (0)) + if (txopDuration.IsZero ()) { return 0; } @@ -1295,7 +1295,7 @@ EdcaTxopN::GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address rec m_dcf->ResetCw (); if (!HasTxop ()) { - if (m_currentHdr.IsQosData () && GetTxopLimit () > NanoSeconds (0)) + if (m_currentHdr.IsQosData () && GetTxopLimit ().IsStrictlyPositive ()) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index e43ed595176..0bb590da419 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -152,12 +152,12 @@ MacLowTransmissionParameters::MustSendRts (void) const bool MacLowTransmissionParameters::HasDurationId (void) const { - return (m_overrideDurationId != Seconds (0)); + return (!m_overrideDurationId.IsZero ()); } Time MacLowTransmissionParameters::GetDurationId (void) const { - NS_ASSERT (m_overrideDurationId != Seconds (0)); + NS_ASSERT (!m_overrideDurationId.IsZero ()); return m_overrideDurationId; } bool @@ -921,7 +921,7 @@ MacLow::ReceiveOk (Ptr packet, double rxSnr, WifiTxVector txVector, bool { m_currentDca->GotAck (); } - if (m_txParams.HasNextPacket () && (!m_currentHdr.IsQosData () || m_currentDca->GetTxopLimit () == NanoSeconds (0) || m_currentDca->HasTxop ())) + if (m_txParams.HasNextPacket () && (!m_currentHdr.IsQosData () || m_currentDca->GetTxopLimit ().IsZero () || m_currentDca->HasTxop ())) { if (m_stationManager->GetRifsPermitted ()) { @@ -1544,7 +1544,7 @@ MacLow::ForwardDown (Ptr packet, const WifiMacHeader* hdr, WifiTxV edcaIt->second->GetMpduAggregator ()->AddHeaderAndPad (newPacket, last, singleMpdu); - if (delay == Seconds (0)) + if (delay.IsZero ()) { NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU"); if (!singleMpdu) @@ -1571,7 +1571,7 @@ MacLow::ForwardDown (Ptr packet, const WifiMacHeader* hdr, WifiTxV } newPacket->AddPacketTag (ampdutag); - if (delay == Seconds (0)) + if (delay.IsZero ()) { m_phy->SendPacket (newPacket, txVector, mpdutype); } @@ -1999,7 +1999,7 @@ MacLow::SendCtsAfterRts (Mac48Address source, Time duration, WifiTxVector rtsTxV cts.SetAddr1 (source); duration -= GetCtsDuration (source, rtsTxVector); duration -= GetSifs (); - NS_ASSERT (duration >= MicroSeconds (0)); + NS_ASSERT (duration.IsPositive ()); cts.SetDuration (duration); Ptr packet = Create (); @@ -2084,7 +2084,7 @@ MacLow::SendDataAfterCts (Mac48Address source, Time duration) duration -= GetSifs (); duration = std::max (duration, newDuration); - NS_ASSERT (duration >= MicroSeconds (0)); + NS_ASSERT (duration.IsPositive ()); m_currentHdr.SetDuration (duration); Ptr packet = m_currentPacket->Copy (); if (m_ampdu) @@ -2147,7 +2147,7 @@ MacLow::SendAckAfterData (Mac48Address source, Time duration, WifiMode dataTxMod // minus the time to transmit the ACK frame and its SIFS interval duration -= GetAckDuration (ackTxVector); duration -= GetSifs (); - NS_ASSERT_MSG (duration >= MicroSeconds (0), "Please provide test case to maintainers if this assert is hit."); + NS_ASSERT_MSG (duration.IsPositive (), "Please provide test case to maintainers if this assert is hit."); ack.SetDuration (duration); Ptr packet = Create (); @@ -2442,7 +2442,7 @@ MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Addre StartDataTxTimers (blockAckReqTxVector); } - NS_ASSERT (duration >= NanoSeconds (0)); + NS_ASSERT (duration.IsPositive ()); hdr.SetDuration (duration); //here should be present a control about immediate or delayed block ack //for now we assume immediate diff --git a/src/wifi/model/wifi-phy.cc b/src/wifi/model/wifi-phy.cc index 40377c89e1f..b24751da66f 100644 --- a/src/wifi/model/wifi-phy.cc +++ b/src/wifi/model/wifi-phy.cc @@ -2321,7 +2321,7 @@ WifiPhy::SendPacket (Ptr packet, WifiTxVector txVector, MpduType m } Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, GetFrequency (), mpdutype, 1); - NS_ASSERT (txDuration > NanoSeconds (0)); + NS_ASSERT (txDuration.IsStrictlyPositive ()); if (m_state->IsStateRx ()) { From c17c46f14b47a05c4caa1e420df7ca129037e8fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 20:45:55 +0200 Subject: [PATCH 009/551] wifi, spectrum: Add 802.11ax support for wifi spectrum --- .../model/wifi-spectrum-value-helper.cc | 216 ++++++++++++------ .../model/wifi-spectrum-value-helper.h | 11 + src/wifi/model/spectrum-wifi-phy.cc | 9 + 3 files changed, 172 insertions(+), 64 deletions(-) diff --git a/src/spectrum/model/wifi-spectrum-value-helper.cc b/src/spectrum/model/wifi-spectrum-value-helper.cc index 27ebbecb38f..ada3eb70978 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.cc +++ b/src/spectrum/model/wifi-spectrum-value-helper.cc @@ -103,6 +103,112 @@ WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t ch return ret; } +// Power allocated to 71 center subbands out of 135 total subbands in the band +Ptr +WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW) +{ + NS_LOG_FUNCTION (centerFrequency << txPowerW); + uint32_t channelWidth = 22; // DSSS channels are 22 MHz wide + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); + Values::iterator vit = c->ValuesBegin (); + Bands::const_iterator bit = c->ConstBandsBegin (); + double txPowerPerBand; + // Evenly spread power across 22 MHz (71 bands) + NS_ASSERT (c->GetSpectrumModel ()->GetNumBands () == 135); + txPowerPerBand = txPowerW / 71; + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if (i >= 32 && i <= 102) + { + *vit = txPowerPerBand / (bit->fh - bit->fl); + } + } + return c; +} + +Ptr +WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) +{ + NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW); + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); + Values::iterator vit = c->ValuesBegin (); + Bands::const_iterator bit = c->ConstBandsBegin (); + double txPowerPerBand; + switch (channelWidth) + { + case 20: + // 52 subcarriers (48 data + 4 pilot) + // skip 38 subbands, then place power in 26 subbands, then + // skip the center subband, then place power in 26 subbands, then skip + // the final 38 subbands. + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 129, "Unexpected number of bands"); + txPowerPerBand = txPowerW / 52; + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if ((i >= 38 && i <= 63) || (i >= 65 && i <= 90)) + { + *vit = txPowerPerBand / (bit->fh - bit->fl); + } + else + { + *vit = 0; + } + } + NS_LOG_DEBUG ("Added signal power to subbands 38-63 and 65-90"); + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + break; + case 10: + // 28 subcarriers (24 data + 4 pilot) + // skip 34 subbands, then place power in 14 subbands, then + // skip the center subband, then place power in 14 subbands, then skip + // the final 34 subbands. + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 97, "Unexpected number of bands"); + txPowerPerBand = txPowerW / 28; + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if ((i >= 34 && i <= 47) || (i >= 49 && i <= 62)) + { + *vit = txPowerPerBand / (bit->fh - bit->fl); + } + else + { + *vit = 0; + } + } + NS_LOG_DEBUG ("Added signal power to subbands 34-47 and 49-62"); + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + break; + case 5: + // 16 subcarriers (12 data + 4 pilot) + // skip 34 subbands, then place power in 14 subbands, then + // skip the center subband, then place power in 14 subbands, then skip + // the final 34 subbands. + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 81, "Unexpected number of bands"); + txPowerPerBand = txPowerW / 16; + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if ((i >= 32 && i <= 39) || (i >= 41 && i <= 48)) + { + *vit = txPowerPerBand / (bit->fh - bit->fl); + } + else + { + *vit = 0; + } + } + NS_LOG_DEBUG ("Added signal power to subbands 32-39 and 41-48"); + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + break; + default: + NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); + break; + } + return c; +} + Ptr WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) { @@ -122,7 +228,7 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq txPowerPerBand = txPowerW / 56; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >=36 && i <=63) || (i >=65 && i <=92)) + if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } @@ -138,7 +244,8 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq txPowerPerBand = txPowerW / 112; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >=36 && i <=63) || (i >=65 && i <=92) || (i >=100 && i<=127) || (i >=129 && i<= 156)) + if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92) || + (i >= 100 && i<= 127) || (i >= 129 && i <= 156)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } @@ -167,7 +274,7 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); break; case 160: - // 448 subcarriers (416 data + 32 pilot) VHT + // 448 subcarriers (416 data + 32 pilot) // possible alternative: 484 subcarriers (468 data + 16 pilot) NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 577, "Unexpected number of bands"); txPowerPerBand = txPowerW / 448; @@ -197,78 +304,82 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq } Ptr -WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) +WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) { NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW); - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 78125)); Values::iterator vit = c->ValuesBegin (); Bands::const_iterator bit = c->ConstBandsBegin (); double txPowerPerBand; switch (channelWidth) { case 20: - // 52 subcarriers (48 data + 4 pilot) - // skip 38 subbands, then place power in 26 subbands, then - // skip the center subband, then place power in 26 subbands, then skip - // the final 38 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 129, "Unexpected number of bands"); - txPowerPerBand = txPowerW / 52; + // 242 subcarriers (234 data + 8 pilot) + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 513, "Unexpected number of bands"); + // skip 133 subbands, then place power in 121 subbands, then + // skip 3 DC, then place power in 121 subbands, then skip + // the final 133 subbands. + txPowerPerBand = txPowerW / 242; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >=38 && i <=63) || (i >=65 && i <=90)) + if ((i >= 134 && i <= 254) || (i >= 258 && i <= 378)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } - else - { - *vit = 0; - } } - NS_LOG_DEBUG ("Added signal power to subbands 38-63 and 65-90"); + NS_LOG_DEBUG ("Added signal power to subbands 134-254 and 258-378"); NS_LOG_DEBUG ("Integrated power " << Integral (*c)); NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); break; - case 10: - // 28 subcarriers (24 data + 4 pilot) - // skip 34 subbands, then place power in 14 subbands, then - // skip the center subband, then place power in 14 subbands, then skip - // the final 34 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 97, "Unexpected number of bands"); - txPowerPerBand = txPowerW / 28; + case 40: + // 484 subcarriers (468 data + 16 pilot) + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 769, "Unexpected number of bands"); + // skip 139 subbands, then place power in 242 subbands, then + // skip 5 DC, then place power in 242 subbands, then skip + // the final 139 subbands. + txPowerPerBand = txPowerW / 484; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >=34 && i <=47) || (i >=49 && i <=62)) + if ((i >= 140 && i <= 381) || (i >= 387 && i <= 628)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } - else - { - *vit = 0; - } } - NS_LOG_DEBUG ("Added signal power to subbands 34-47 and 49-62"); + NS_LOG_DEBUG ("Added signal power to subbands 140-381 and 387-628"); NS_LOG_DEBUG ("Integrated power " << Integral (*c)); NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); break; - case 5: - // 16 subcarriers (12 data + 4 pilot) - // skip 34 subbands, then place power in 14 subbands, then - // skip the center subband, then place power in 14 subbands, then skip - // the final 34 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 81, "Unexpected number of bands"); - txPowerPerBand = txPowerW / 16; + case 80: + // 996 subcarriers (980 data + 16 pilot) + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 1281, "Unexpected number of bands"); + // skip 139 subbands, then place power in 498 subbands, then + // skip 5 DC, then place power in 498 subbands, then skip + // the final 139 subbands. + txPowerPerBand = txPowerW / 996; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >=32 && i <=39) || (i >=41 && i <=48)) + if ((i >= 140 && i <= 637) || (i >= 643 && i <= 1140)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } - else + } + NS_LOG_DEBUG ("Added signal power to subbands 140-637 and 643-1140"); + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + break; + case 160: + // 2 x 996 subcarriers (2 x 80 MHZ bands) + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 2305, "Unexpected number of bands"); + txPowerPerBand = txPowerW / (2 * 996); + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if ((i >= 140 && i <= 637) || (i >= 643 && i <= 1140) || + (i >= 1164 && i <= 1661) || (i >= 1667 && i <= 2164)) { - *vit = 0; + *vit = txPowerPerBand / (bit->fh - bit->fl); } } - NS_LOG_DEBUG ("Added signal power to subbands 32-39 and 41-48"); + NS_LOG_DEBUG ("Added signal power to subbands 140-637, 643-1140, 1164-1661 and 1667-2164"); NS_LOG_DEBUG ("Integrated power " << Integral (*c)); NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); break; @@ -279,29 +390,6 @@ WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFreque return c; } -// Power allocated to 71 center subbands out of 135 total subbands in the band -Ptr -WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW) -{ - NS_LOG_FUNCTION (centerFrequency << txPowerW); - uint32_t channelWidth = 22; // DSSS channels are 22 MHz wide - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); - Values::iterator vit = c->ValuesBegin (); - Bands::const_iterator bit = c->ConstBandsBegin (); - double txPowerPerBand; - // Evenly spread power across 22 MHz (71 bands) - NS_ASSERT (c->GetSpectrumModel ()->GetNumBands () == 135); - txPowerPerBand = txPowerW / 71; - for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) - { - if (i >=32 && i <=102) - { - *vit = txPowerPerBand / (bit->fh - bit->fl); - } - } - return c; -} - Ptr WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure) { diff --git a/src/spectrum/model/wifi-spectrum-value-helper.h b/src/spectrum/model/wifi-spectrum-value-helper.h index 9fe0028f0a1..df5fcdc655b 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.h +++ b/src/spectrum/model/wifi-spectrum-value-helper.h @@ -54,6 +54,17 @@ class WifiSpectrumValueHelper */ static Ptr GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth); + /** + * Create a transmit power spectral density corresponding to OFDM + * High Efficiency (HE) (802.11ax). Channel width may vary between + * 20, 40, 80, and 160 MHz. + * + * \param centerFrequency center frequency (MHz) + * \param channelWidth channel width (MHz) + * \param txPowerW transmit power (W) to allocate + */ + static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW); + /** * Create a transmit power spectral density corresponding to OFDM * High Throughput (HT) (802.11n/ac). Channel width may vary between diff --git a/src/wifi/model/spectrum-wifi-phy.cc b/src/wifi/model/spectrum-wifi-phy.cc index 8442d34f6f6..a3c79894c9a 100644 --- a/src/wifi/model/spectrum-wifi-phy.cc +++ b/src/wifi/model/spectrum-wifi-phy.cc @@ -249,6 +249,10 @@ SpectrumWifiPhy::GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t ch case WIFI_PHY_STANDARD_80211ac: v = WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW); break; + case WIFI_PHY_STANDARD_80211ax_2_4GHZ: + case WIFI_PHY_STANDARD_80211ax_5GHZ: + v = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW); + break; default: NS_FATAL_ERROR ("Standard unknown: " << GetStandard ()); break; @@ -292,6 +296,11 @@ SpectrumWifiPhy::GetBandBandwidth (void) const // Use OFDM subcarrier width of 312.5 KHz as band granularity bandBandwidth = 312500; break; + case WIFI_PHY_STANDARD_80211ax_2_4GHZ: + case WIFI_PHY_STANDARD_80211ax_5GHZ: + // Use OFDM subcarrier width of 78.125 KHz as band granularity + bandBandwidth = 78125; + break; default: NS_FATAL_ERROR ("Standard unknown: " << GetStandard ()); break; From 5a34f6d29346a925bf6ef68bbeebbe842a996f42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 20:46:08 +0200 Subject: [PATCH 010/551] wifi, spectrum: Replace hardcoded guard band width in wifi spectrum --- .../model/wifi-spectrum-value-helper.cc | 410 +++++++++++------- .../model/wifi-spectrum-value-helper.h | 46 +- src/wifi/model/spectrum-wifi-phy.cc | 39 +- src/wifi/model/spectrum-wifi-phy.h | 5 + src/wifi/test/spectrum-wifi-phy-test.cc | 3 +- 5 files changed, 331 insertions(+), 172 deletions(-) diff --git a/src/spectrum/model/wifi-spectrum-value-helper.cc b/src/spectrum/model/wifi-spectrum-value-helper.cc index ada3eb70978..04e9f3455ad 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.cc +++ b/src/spectrum/model/wifi-spectrum-value-helper.cc @@ -54,9 +54,9 @@ operator < (const WifiSpectrumModelId& a, const WifiSpectrumModelId& b) static std::map > g_wifiSpectrumModelMap; Ptr -WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth) +WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << bandBandwidth); + NS_LOG_FUNCTION (centerFrequency << channelWidth << bandBandwidth << guardBandwidth); Ptr ret; WifiSpectrumModelId key (centerFrequency, channelWidth); std::map >::iterator it = g_wifiSpectrumModelMap.find (key); @@ -68,10 +68,9 @@ WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t ch { Bands bands; double centerFrequencyHz = centerFrequency * 1e6; - // Overall bandwidth will be channelWidth plus 10 MHz guards on each side - double bandwidth = (channelWidth + 20) * 1e6; + double bandwidth = (channelWidth + (2 * guardBandwidth)) * 1e6; // For OFDM, the center subcarrier is null (at center frequency) - uint32_t numBands = static_cast (bandwidth / bandBandwidth + 0.5); + uint32_t numBands = static_cast ((bandwidth / bandBandwidth) + 0.5); NS_ASSERT (numBands > 0); if (numBands % 2 == 0) { @@ -105,20 +104,22 @@ WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t ch // Power allocated to 71 center subbands out of 135 total subbands in the band Ptr -WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW) +WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << txPowerW); + NS_LOG_FUNCTION (centerFrequency << txPowerW << guardBandwidth); uint32_t channelWidth = 22; // DSSS channels are 22 MHz wide - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); + double bandBandwidth = 312500; + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); Bands::const_iterator bit = c->ConstBandsBegin (); - double txPowerPerBand; - // Evenly spread power across 22 MHz (71 bands) - NS_ASSERT (c->GetSpectrumModel ()->GetNumBands () == 135); - txPowerPerBand = txPowerW / 71; + uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); + uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); + NS_ASSERT (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1)); + // Evenly spread power across 22 MHz + double txPowerPerBand = txPowerW / nAllocatedBands; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if (i >= 32 && i <= 102) + if ((i >= (nGuardBands / 2)) && (i <= ((nGuardBands / 2) + nAllocatedBands - 1))) { *vit = txPowerPerBand / (bit->fh - bit->fl); } @@ -127,273 +128,388 @@ WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFreque } Ptr -WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) +WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW); - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); - Values::iterator vit = c->ValuesBegin (); - Bands::const_iterator bit = c->ConstBandsBegin (); - double txPowerPerBand; + NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + double bandBandwidth = 312500; + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); + uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); + uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); + double txPowerPerBand = 0; + uint32_t start1 = 0; + uint32_t stop1 = 0; + uint32_t start2 = 0; + uint32_t stop2 = 0; switch (channelWidth) { case 20: // 52 subcarriers (48 data + 4 pilot) - // skip 38 subbands, then place power in 26 subbands, then + // skip guard band and 6 subbands, then place power in 26 subbands, then // skip the center subband, then place power in 26 subbands, then skip - // the final 38 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 129, "Unexpected number of bands"); + // the final 6 subbands and the guard band. txPowerPerBand = txPowerW / 52; - for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) - { - if ((i >= 38 && i <= 63) || (i >= 65 && i <= 90)) - { - *vit = txPowerPerBand / (bit->fh - bit->fl); - } - else - { - *vit = 0; - } - } - NS_LOG_DEBUG ("Added signal power to subbands 38-63 and 65-90"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + start1 = (nGuardBands / 2) + 6; + stop1 = start1 + 26 - 1; + start2 = stop1 + 2; + stop2 = start2 + 26 - 1; break; case 10: // 28 subcarriers (24 data + 4 pilot) - // skip 34 subbands, then place power in 14 subbands, then + // skip guard band and 2 subbands, then place power in 14 subbands, then // skip the center subband, then place power in 14 subbands, then skip - // the final 34 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 97, "Unexpected number of bands"); + // the final 2 subbands and the guard band. txPowerPerBand = txPowerW / 28; - for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) - { - if ((i >= 34 && i <= 47) || (i >= 49 && i <= 62)) - { - *vit = txPowerPerBand / (bit->fh - bit->fl); - } - else - { - *vit = 0; - } - } - NS_LOG_DEBUG ("Added signal power to subbands 34-47 and 49-62"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + start1 = (nGuardBands / 2) + 2; + stop1 = start1 + 14 - 1; + start2 = stop1 + 2; + stop2 = start2 + 14 - 1; break; case 5: // 16 subcarriers (12 data + 4 pilot) - // skip 34 subbands, then place power in 14 subbands, then - // skip the center subband, then place power in 14 subbands, then skip - // the final 34 subbands. - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 81, "Unexpected number of bands"); + // skip guard band and 2 subbands, then place power in 8 subbands, then + // skip the center subband, then place power in 8 subbands, then skip + // the final 2 subbands and the guard. txPowerPerBand = txPowerW / 16; - for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) - { - if ((i >= 32 && i <= 39) || (i >= 41 && i <= 48)) - { - *vit = txPowerPerBand / (bit->fh - bit->fl); - } - else - { - *vit = 0; - } - } - NS_LOG_DEBUG ("Added signal power to subbands 32-39 and 41-48"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + start1 = (nGuardBands / 2) + 2; + stop1 = start1 + 8 - 1; + start2 = stop1 + 2; + stop2 = start2 + 8 - 1; break; default: NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); break; } + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + Values::iterator vit = c->ValuesBegin (); + Bands::const_iterator bit = c->ConstBandsBegin (); + for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) + { + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2)) + { + *vit = txPowerPerBand / (bit->fh - bit->fl); + } + else + { + *vit = 0; + } + } + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << " and " << start2 << "-" << stop2); + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); return c; } Ptr -WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) +WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW); - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 312500)); + NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + double bandBandwidth = 312500; + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); Bands::const_iterator bit = c->ConstBandsBegin (); + uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); + uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); double txPowerPerBand; + // skip the guard band and 4 subbands, then place power in 28 subbands, then + // skip the center subband, then place power in 28 subbands, then skip + // the final 4 subbands and the guard band. + // Repeat for each 20 MHz band. + uint32_t start1 = (nGuardBands / 2) + 4; + uint32_t stop1 = start1 + 28 - 1; + uint32_t start2 = stop1 + 2; + uint32_t stop2 = start2 + 28 - 1; + uint32_t start3 = stop2 + (2 * 4); + uint32_t stop3 = start3 + 28 - 1; + uint32_t start4 = stop3 + 2; + uint32_t stop4 = start4 + 28 - 1; + uint32_t start5 = stop4 + (2 * 4); + uint32_t stop5 = start5 + 28 - 1; + uint32_t start6 = stop5 + 2; + uint32_t stop6 = start6 + 28 - 1; + uint32_t start7 = stop6 + (2 * 4); + uint32_t stop7 = start7 + 28 - 1; + uint32_t start8 = stop7 + 2; + uint32_t stop8 = start8 + 28 - 1; + uint32_t start9 = stop8 + (2 * 4); + uint32_t stop9 = start9 + 28 - 1; + uint32_t start10 = stop9 + 2; + uint32_t stop10 = start10 + 28 - 1; + uint32_t start11 = stop10 + (2 * 4); + uint32_t stop11 = start11 + 28 - 1; + uint32_t start12 = stop11 + 2; + uint32_t stop12 = start12 + 28 - 1; + uint32_t start13 = stop12 + (2 * 4); + uint32_t stop13 = start13 + 28 - 1; + uint32_t start14 = stop13 + 2; + uint32_t stop14 = start14 + 28 - 1; + uint32_t start15 = stop14 + (2 * 4); + uint32_t stop15 = start15 + 28 - 1; + uint32_t start16 = stop15 + 2; + uint32_t stop16 = start16 + 28 - 1; switch (channelWidth) { case 20: - // 56 subcarriers (52 data + 4 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 129, "Unexpected number of bands"); - // skip 32 subbands, then place power in 28 of the next 32 subbands, then - // skip the center subband, then place power in 28 of the next 32 - // subbands, then skip the final 32 subbands. + // 56 subcarriers (52 data + 4 pilot) txPowerPerBand = txPowerW / 56; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + start1 = (nGuardBands / 2) + 4; + stop1 = start1 + 28 - 1; + start2 = stop1 + 2; + stop2 = start2 + 28 - 1; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 36-63 and 65-92"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + " and " << start2 << "-" << stop2); break; case 40: // 112 subcarriers (104 data + 8 pilot) // possible alternative: 114 subcarriers (108 data + 6 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 193, "Unexpected number of bands"); txPowerPerBand = txPowerW / 112; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92) || - (i >= 100 && i<= 127) || (i >= 129 && i <= 156)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2) || + (i >= start3 && i <= stop3) || (i >= start4 && i <= stop4)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 36-63, 65-92, 100-127, and 129-156"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + ", " << start2 << "-" << stop2 << + ", " << start3 << "-" << stop3 << + ", " << start4 << "-" << stop4); break; case 80: // 224 subcarriers (208 data + 16 pilot) // possible alternative: 242 subcarriers (234 data + 8 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 321, "Unexpected number of bands"); txPowerPerBand = txPowerW / 224; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92) || - (i >= 100 && i <= 127) || (i >= 129 && i <= 156) || - (i >= 164 && i <= 191) || (i >= 193 && i <= 220) || - (i >= 228 && i <= 255) || (i >= 257 && i <= 284)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2) || + (i >= start3 && i <= stop3) || (i >= start4 && i <= stop4) || + (i >= start5 && i <= stop5) || (i >= start6 && i <= stop6) || + (i >= start7 && i <= stop7) || (i >= start8 && i <= stop8)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 36-63, 65-92, 100-127, 129-156, 164-191, 193-220, 228-255, 257-284"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + ", " << start2 << "-" << stop2 << + ", " << start3 << "-" << stop3 << + ", " << start4 << "-" << stop4 << + ", " << start5 << "-" << stop5 << + ", " << start6 << "-" << stop6 << + ", " << start7 << "-" << stop7 << + ", " << start8 << "-" << stop8); break; case 160: // 448 subcarriers (416 data + 32 pilot) // possible alternative: 484 subcarriers (468 data + 16 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 577, "Unexpected number of bands"); txPowerPerBand = txPowerW / 448; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 36 && i <= 63) || (i >= 65 && i <= 92) || - (i >= 100 && i <= 127) || (i >= 129 && i <= 156) || - (i >= 164 && i <= 191) || (i >= 193 && i <= 220) || - (i >= 228 && i <= 255) || (i >= 257 && i <= 284) || - (i >= 292 && i <= 319) || (i >= 321 && i <= 348) || - (i >= 356 && i <= 383) || (i >= 385 && i <= 412) || - (i >= 420 && i <= 447) || (i >= 449 && i <= 476) || - (i >= 484 && i <= 511) || (i >= 513 && i <= 540)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2) || + (i >= start3 && i <= stop3) || (i >= start4 && i <= stop4) || + (i >= start5 && i <= stop5) || (i >= start6 && i <= stop6) || + (i >= start7 && i <= stop7) || (i >= start8 && i <= stop8) || + (i >= start9 && i <= stop9) || (i >= start10 && i <= stop10) || + (i >= start11 && i <= stop11) || (i >= start12 && i <= stop12) || + (i >= start13 && i <= stop13) || (i >= start14 && i <= stop14) || + (i >= start15 && i <= stop15) || (i >= start16 && i <= stop16)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 36-63, 65-92, 100-127, 129-156, 164-191, 193-220, 228-255, 257-284, 292-319, 321-348, 356-383, 385-412, 420-447, 449-476, 484-511, and 513-540"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + ", " << start2 << "-" << stop2 << + ", " << start3 << "-" << stop3 << + ", " << start4 << "-" << stop4 << + ", " << start5 << "-" << stop5 << + ", " << start6 << "-" << stop6 << + ", " << start7 << "-" << stop7 << + ", " << start8 << "-" << stop8 << + ", " << start9 << "-" << stop9 << + ", " << start10 << "-" << stop10 << + ", " << start11 << "-" << stop11 << + ", " << start12 << "-" << stop12 << + ", " << start13 << "-" << stop13 << + ", " << start14 << "-" << stop14 << + ", " << start15 << "-" << stop15 << + ", " << start16 << "-" << stop16); break; default: NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); break; } + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); return c; } Ptr -WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) +WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW); - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, 78125)); + NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + double bandBandwidth = 78125; + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); Bands::const_iterator bit = c->ConstBandsBegin (); + uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); + uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); double txPowerPerBand; + uint32_t start1; + uint32_t stop1; + uint32_t start2; + uint32_t stop2; + uint32_t start3; + uint32_t stop3; + uint32_t start4; + uint32_t stop4; switch (channelWidth) { case 20: // 242 subcarriers (234 data + 8 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 513, "Unexpected number of bands"); - // skip 133 subbands, then place power in 121 subbands, then - // skip 3 DC, then place power in 121 subbands, then skip - // the final 133 subbands. txPowerPerBand = txPowerW / 242; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + // skip the guard band and 11 subbands, then place power in 121 subbands, then + // skip 3 DC, then place power in 121 subbands, then skip + // the final 11 subbands and the guard band. + start1 = (nGuardBands / 2) + 12; + stop1 = start1 + 121 - 1; + start2 = stop1 + 4; + stop2 = start2 + 121 - 1; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 134 && i <= 254) || (i >= 258 && i <= 378)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 134-254 and 258-378"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + " and " << start2 << "-" << stop2); break; case 40: // 484 subcarriers (468 data + 16 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 769, "Unexpected number of bands"); - // skip 139 subbands, then place power in 242 subbands, then - // skip 5 DC, then place power in 242 subbands, then skip - // the final 139 subbands. txPowerPerBand = txPowerW / 484; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + // skip the guard band and 11 subbands, then place power in 242 subbands, then + // skip 5 DC, then place power in 242 subbands, then skip + // the final 11 subbands and the guard band. + start1 = (nGuardBands / 2) + 12; + stop1 = start1 + 242 - 1; + start2 = stop1 + 6; + stop2 = start2 + 242 - 1; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 140 && i <= 381) || (i >= 387 && i <= 628)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 140-381 and 387-628"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + " and " << start2 << "-" << stop2); break; case 80: // 996 subcarriers (980 data + 16 pilot) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 1281, "Unexpected number of bands"); - // skip 139 subbands, then place power in 498 subbands, then - // skip 5 DC, then place power in 498 subbands, then skip - // the final 139 subbands. txPowerPerBand = txPowerW / 996; + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + // skip the guard band and 11 subbands, then place power in 498 subbands, then + // skip 5 DC, then place power in 498 subbands, then skip + // the final 11 subbands and the guard band. + start1 = (nGuardBands / 2) + 12; + stop1 = start1 + 498 - 1; + start2 = stop1 + 6; + stop2 = start2 + 498 - 1; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 140 && i <= 637) || (i >= 643 && i <= 1140)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 140-637 and 643-1140"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + " and " << start2 << "-" << stop2); break; case 160: // 2 x 996 subcarriers (2 x 80 MHZ bands) - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == 2305, "Unexpected number of bands"); txPowerPerBand = txPowerW / (2 * 996); + NS_LOG_DEBUG ("Power per band " << txPowerPerBand); + start1 = (nGuardBands / 2) + 12; + stop1 = start1 + 498 - 1; + start2 = stop1 + 6; + stop2 = start2 + 498 - 1; + start3 = stop2 + (2 * 12); + stop3 = start3 + 498 - 1; + start4 = stop3 + 6; + stop4 = start4 + 498 - 1; for (size_t i = 0; i < c->GetSpectrumModel ()->GetNumBands (); i++, vit++, bit++) { - if ((i >= 140 && i <= 637) || (i >= 643 && i <= 1140) || - (i >= 1164 && i <= 1661) || (i >= 1667 && i <= 2164)) + if ((i >= start1 && i <= stop1) || (i >= start2 && i <= stop2) || + (i >= start3 && i <= stop3) || (i >= start4 && i <= stop4)) { *vit = txPowerPerBand / (bit->fh - bit->fl); } + else + { + *vit = 0; + } } - NS_LOG_DEBUG ("Added signal power to subbands 140-637, 643-1140, 1164-1661 and 1667-2164"); - NS_LOG_DEBUG ("Integrated power " << Integral (*c)); - NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); + NS_LOG_DEBUG ("Added signal power to subbands " << start1 << "-" << stop1 << + ", " << start2 << "-" << stop2 << + ", " << start3 << "-" << stop3 << + ", " << start4 << "-" << stop4); break; default: NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); break; } + NS_LOG_DEBUG ("Integrated power " << Integral (*c)); + NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); return c; } Ptr -WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure) +WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure, uint32_t guardBandwidth) { - Ptr model = GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth); + Ptr model = GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth); return CreateNoisePowerSpectralDensity (noiseFigure, model); } @@ -416,10 +532,10 @@ WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (double noiseFigureDb, } Ptr -WifiSpectrumValueHelper::CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandGranularity) +WifiSpectrumValueHelper::CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandGranularity, uint32_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << bandGranularity); - Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandGranularity)); + NS_LOG_FUNCTION (centerFrequency << channelWidth << bandGranularity << guardBandwidth); + Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandGranularity, guardBandwidth)); size_t numBands = c->GetSpectrumModel ()->GetNumBands (); Bands::const_iterator bit = c->ConstBandsBegin (); Values::iterator vit = c->ValuesBegin (); diff --git a/src/spectrum/model/wifi-spectrum-value-helper.h b/src/spectrum/model/wifi-spectrum-value-helper.h index df5fcdc655b..099beb4e8f6 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.h +++ b/src/spectrum/model/wifi-spectrum-value-helper.h @@ -49,53 +49,59 @@ class WifiSpectrumValueHelper * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param bandBandwidth width of each band (Hz) + * \param guardBandwidth width of the guard band (MHz) + * * \return the static SpectrumModel instance corresponding to the * given carrier frequency and channel width configuration. */ - static Ptr GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth); + static Ptr GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth); /** - * Create a transmit power spectral density corresponding to OFDM - * High Efficiency (HE) (802.11ax). Channel width may vary between - * 20, 40, 80, and 160 MHz. + * Create a transmit power spectral density corresponding to DSSS + * + * The center frequency typically corresponds to 802.11b channel + * center frequencies but is not restricted to those frequencies. * * \param centerFrequency center frequency (MHz) - * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate + * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW); + static Ptr CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint32_t guardBandwidth); /** * Create a transmit power spectral density corresponding to OFDM - * High Throughput (HT) (802.11n/ac). Channel width may vary between - * 20, 40, 80, and 160 MHz. + * (802.11a/g). Channel width may vary between 20, 10, and 5 MHz. * * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate + * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW); + static Ptr CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); /** * Create a transmit power spectral density corresponding to OFDM - * (802.11a/g). Channel width may vary between 20, 10, and 5 MHz. + * High Throughput (HT) (802.11n/ac). Channel width may vary between + * 20, 40, 80, and 160 MHz. * * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate + * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW); + static Ptr CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); /** - * Create a transmit power spectral density corresponding to DSSS - * - * The center frequency typically corresponds to 802.11b channel - * center frequencies but is not restricted to those frequencies. + * Create a transmit power spectral density corresponding to OFDM + * High Efficiency (HE) (802.11ax). Channel width may vary between + * 20, 40, 80, and 160 MHz. * * \param centerFrequency center frequency (MHz) + * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate + * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW); + static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); /** * @@ -103,9 +109,11 @@ class WifiSpectrumValueHelper * \param channelWidth channel width (MHz) * \param bandBandwidth width of each band (Hz) * \param noiseFigure the noise figure in dB w.r.t. a reference temperature of 290K + * \param guardBandwidth width of the guard band (MHz) + * * \return a pointer to a newly allocated SpectrumValue representing the noise Power Spectral Density in W/Hz for each Band */ - static Ptr CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure); + static Ptr CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure, uint32_t guardBandwidth); /** * \param centerFrequency center frequency (MHz) @@ -118,10 +126,12 @@ class WifiSpectrumValueHelper * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param bandBandwidth width of each band (Hz) + * \param guardBandwidth width of the guard band (MHz) + * * \return a pointer to a SpectrumValue representing the RF filter applied * to an received power spectral density */ - static Ptr CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth); + static Ptr CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth); }; /** diff --git a/src/wifi/model/spectrum-wifi-phy.cc b/src/wifi/model/spectrum-wifi-phy.cc index a3c79894c9a..cf2426368e1 100644 --- a/src/wifi/model/spectrum-wifi-phy.cc +++ b/src/wifi/model/spectrum-wifi-phy.cc @@ -107,7 +107,7 @@ SpectrumWifiPhy::GetRxSpectrumModel () const else { NS_LOG_DEBUG ("Creating spectrum model from frequency/width pair of (" << GetFrequency () << ", " << (uint16_t)GetChannelWidth () << ")"); - m_rxSpectrumModel = WifiSpectrumValueHelper::GetSpectrumModel (GetFrequency (), GetChannelWidth (), GetBandBandwidth ()); + m_rxSpectrumModel = WifiSpectrumValueHelper::GetSpectrumModel (GetFrequency (), GetChannelWidth (), GetBandBandwidth (), GetGuardBandwidth ()); } } return m_rxSpectrumModel; @@ -168,7 +168,7 @@ SpectrumWifiPhy::StartRx (Ptr rxParams) // Integrate over our receive bandwidth (i.e., all that the receive // spectral mask representing our filtering allows) to find the // total energy apparent to the "demodulator". - Ptr filter = WifiSpectrumValueHelper::CreateRfFilter (GetFrequency (), GetChannelWidth (), GetBandBandwidth ()); + Ptr filter = WifiSpectrumValueHelper::CreateRfFilter (GetFrequency (), GetChannelWidth (), GetBandBandwidth (), GetGuardBandwidth ()); SpectrumValue filteredSignal = (*filter) * (*receivedSignalPsd); // Add receiver antenna gain NS_LOG_DEBUG ("Signal power received (watts) before antenna gain: " << Integral (filteredSignal)); @@ -239,19 +239,19 @@ SpectrumWifiPhy::GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t ch case WIFI_PHY_STANDARD_holland: case WIFI_PHY_STANDARD_80211_10MHZ: case WIFI_PHY_STANDARD_80211_5MHZ: - v = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW); + v = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; case WIFI_PHY_STANDARD_80211b: - v = WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (centerFrequency, txPowerW); + v = WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (centerFrequency, txPowerW, GetGuardBandwidth ()); break; case WIFI_PHY_STANDARD_80211n_2_4GHZ: case WIFI_PHY_STANDARD_80211n_5GHZ: case WIFI_PHY_STANDARD_80211ac: - v = WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW); + v = WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; case WIFI_PHY_STANDARD_80211ax_2_4GHZ: case WIFI_PHY_STANDARD_80211ax_5GHZ: - v = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW); + v = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; default: NS_FATAL_ERROR ("Standard unknown: " << GetStandard ()); @@ -308,4 +308,31 @@ SpectrumWifiPhy::GetBandBandwidth (void) const return bandBandwidth; } +uint32_t +SpectrumWifiPhy::GetGuardBandwidth (void) const +{ + double guardBandwidth = 0; + switch (GetStandard ()) + { + case WIFI_PHY_STANDARD_80211a: + case WIFI_PHY_STANDARD_80211g: + case WIFI_PHY_STANDARD_holland: + case WIFI_PHY_STANDARD_80211_10MHZ: + case WIFI_PHY_STANDARD_80211_5MHZ: + case WIFI_PHY_STANDARD_80211b: + case WIFI_PHY_STANDARD_80211n_2_4GHZ: + case WIFI_PHY_STANDARD_80211n_5GHZ: + case WIFI_PHY_STANDARD_80211ac: + case WIFI_PHY_STANDARD_80211ax_2_4GHZ: + case WIFI_PHY_STANDARD_80211ax_5GHZ: + // Use 10 MHZ + guardBandwidth = 10; + break; + default: + NS_FATAL_ERROR ("Standard unknown: " << GetStandard ()); + break; + } + return guardBandwidth; +} + } //namespace ns3 diff --git a/src/wifi/model/spectrum-wifi-phy.h b/src/wifi/model/spectrum-wifi-phy.h index b7087902958..4e614a4f0cd 100644 --- a/src/wifi/model/spectrum-wifi-phy.h +++ b/src/wifi/model/spectrum-wifi-phy.h @@ -143,6 +143,11 @@ class SpectrumWifiPhy : public WifiPhy */ double GetBandBandwidth (void) const; + /** + * \return the width of the guard band (MHz) + */ + uint32_t GetGuardBandwidth (void) const; + /** * Callback invoked when the Phy model starts to process a signal * diff --git a/src/wifi/test/spectrum-wifi-phy-test.cc b/src/wifi/test/spectrum-wifi-phy-test.cc index 0f51777962f..8151dbf0e57 100644 --- a/src/wifi/test/spectrum-wifi-phy-test.cc +++ b/src/wifi/test/spectrum-wifi-phy-test.cc @@ -31,6 +31,7 @@ using namespace ns3; static const uint16_t CHANNEL_NUMBER = 36; static const uint32_t FREQUENCY = 5180; // MHz static const uint32_t CHANNEL_WIDTH = 20; // MHz +static const uint32_t GUARD_WIDTH = 10; // MHz /** * \ingroup wifi-test @@ -114,7 +115,7 @@ SpectrumWifiPhyBasicTest::MakeSignal (double txPowerWatts) pkt->AddTrailer (trailer); WifiPhyTag tag (txVector, mpdutype); pkt->AddPacketTag (tag); - Ptr txPowerSpectrum = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts); + Ptr txPowerSpectrum = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts, GUARD_WIDTH); Ptr txParams = Create (); txParams->psd = txPowerSpectrum; txParams->txPhy = 0; From 1aa06a90eb6365f477a29a40c1d9a434013b6cc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 20:47:27 +0200 Subject: [PATCH 011/551] spectrum: use 8 bits unsigned integer for channel widths --- .../model/wifi-spectrum-value-helper.cc | 40 +++++++++---------- .../model/wifi-spectrum-value-helper.h | 18 ++++----- src/wifi/test/spectrum-wifi-phy-test.cc | 6 +-- 3 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/spectrum/model/wifi-spectrum-value-helper.cc b/src/spectrum/model/wifi-spectrum-value-helper.cc index 04e9f3455ad..1ea96ebd089 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.cc +++ b/src/spectrum/model/wifi-spectrum-value-helper.cc @@ -33,16 +33,16 @@ NS_LOG_COMPONENT_DEFINE ("WifiSpectrumValueHelper"); struct WifiSpectrumModelId { - WifiSpectrumModelId (uint32_t f, uint32_t w); + WifiSpectrumModelId (uint32_t f, uint8_t w); uint32_t m_centerFrequency; - uint32_t m_channelWidth; + uint8_t m_channelWidth; }; -WifiSpectrumModelId::WifiSpectrumModelId (uint32_t f, uint32_t w) +WifiSpectrumModelId::WifiSpectrumModelId (uint32_t f, uint8_t w) : m_centerFrequency (f), m_channelWidth (w) { - NS_LOG_FUNCTION (this << f << w); + NS_LOG_FUNCTION (this << f << (uint16_t)w); } bool @@ -54,9 +54,9 @@ operator < (const WifiSpectrumModelId& a, const WifiSpectrumModelId& b) static std::map > g_wifiSpectrumModelMap; Ptr -WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth) +WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << bandBandwidth << guardBandwidth); + NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << bandBandwidth << (uint16_t)guardBandwidth); Ptr ret; WifiSpectrumModelId key (centerFrequency, channelWidth); std::map >::iterator it = g_wifiSpectrumModelMap.find (key); @@ -104,10 +104,10 @@ WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint32_t ch // Power allocated to 71 center subbands out of 135 total subbands in the band Ptr -WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << txPowerW << guardBandwidth); - uint32_t channelWidth = 22; // DSSS channels are 22 MHz wide + NS_LOG_FUNCTION (centerFrequency << txPowerW << (uint16_t)guardBandwidth); + uint8_t channelWidth = 22; // DSSS channels are 22 MHz wide double bandBandwidth = 312500; Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); @@ -128,9 +128,9 @@ WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (uint32_t centerFreque } Ptr -WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << txPowerW << (uint16_t)guardBandwidth); double bandBandwidth = 312500; Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); @@ -201,9 +201,9 @@ WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFreque } Ptr -WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << txPowerW << (uint16_t)guardBandwidth); double bandBandwidth = 312500; Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); @@ -372,9 +372,9 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq } Ptr -WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << txPowerW << guardBandwidth); + NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << txPowerW << (uint16_t)guardBandwidth); double bandBandwidth = 78125; Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); Values::iterator vit = c->ValuesBegin (); @@ -507,7 +507,7 @@ WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFreq } Ptr -WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, double noiseFigure, uint8_t guardBandwidth) { Ptr model = GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth); return CreateNoisePowerSpectralDensity (noiseFigure, model); @@ -532,9 +532,9 @@ WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity (double noiseFigureDb, } Ptr -WifiSpectrumValueHelper::CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandGranularity, uint32_t guardBandwidth) +WifiSpectrumValueHelper::CreateRfFilter (uint32_t centerFrequency, uint8_t channelWidth, double bandGranularity, uint8_t guardBandwidth) { - NS_LOG_FUNCTION (centerFrequency << channelWidth << bandGranularity << guardBandwidth); + NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << bandGranularity << (uint16_t)guardBandwidth); Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandGranularity, guardBandwidth)); size_t numBands = c->GetSpectrumModel ()->GetNumBands (); Bands::const_iterator bit = c->ConstBandsBegin (); @@ -602,7 +602,7 @@ WifiSpectrumValue5MhzFactory::CreateConstant (double v) Ptr -WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity (double txPower, uint32_t channel) +WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity (double txPower, uint8_t channel) { Ptr txPsd = Create (g_WifiSpectrumModel5Mhz); @@ -636,7 +636,7 @@ WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity (double txPower, uint Ptr -WifiSpectrumValue5MhzFactory::CreateRfFilter (uint32_t channel) +WifiSpectrumValue5MhzFactory::CreateRfFilter (uint8_t channel) { Ptr rf = Create (g_WifiSpectrumModel5Mhz); diff --git a/src/spectrum/model/wifi-spectrum-value-helper.h b/src/spectrum/model/wifi-spectrum-value-helper.h index 099beb4e8f6..41ca4777ecb 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.h +++ b/src/spectrum/model/wifi-spectrum-value-helper.h @@ -54,7 +54,7 @@ class WifiSpectrumValueHelper * \return the static SpectrumModel instance corresponding to the * given carrier frequency and channel width configuration. */ - static Ptr GetSpectrumModel (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth); + static Ptr GetSpectrumModel (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth); /** * Create a transmit power spectral density corresponding to DSSS @@ -66,7 +66,7 @@ class WifiSpectrumValueHelper * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint32_t guardBandwidth); + static Ptr CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint8_t guardBandwidth); /** * Create a transmit power spectral density corresponding to OFDM @@ -77,7 +77,7 @@ class WifiSpectrumValueHelper * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); + static Ptr CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); /** * Create a transmit power spectral density corresponding to OFDM @@ -89,7 +89,7 @@ class WifiSpectrumValueHelper * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); + static Ptr CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); /** * Create a transmit power spectral density corresponding to OFDM @@ -101,7 +101,7 @@ class WifiSpectrumValueHelper * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) */ - static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double txPowerW, uint32_t guardBandwidth); + static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); /** * @@ -113,7 +113,7 @@ class WifiSpectrumValueHelper * * \return a pointer to a newly allocated SpectrumValue representing the noise Power Spectral Density in W/Hz for each Band */ - static Ptr CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure, uint32_t guardBandwidth); + static Ptr CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, double noiseFigure, uint8_t guardBandwidth); /** * \param centerFrequency center frequency (MHz) @@ -131,7 +131,7 @@ class WifiSpectrumValueHelper * \return a pointer to a SpectrumValue representing the RF filter applied * to an received power spectral density */ - static Ptr CreateRfFilter (uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, uint32_t guardBandwidth); + static Ptr CreateRfFilter (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth); }; /** @@ -175,7 +175,7 @@ class WifiSpectrumValue5MhzFactory * * @return a Ptr to a newly created SpectrumValue */ - virtual Ptr CreateTxPowerSpectralDensity (double txPower, uint32_t channel); + virtual Ptr CreateTxPowerSpectralDensity (double txPower, uint8_t channel); /** * Creates a SpectrumValue instance which * represents the frequency response of the RF filter which is used @@ -185,7 +185,7 @@ class WifiSpectrumValue5MhzFactory * * @return a Ptr to a newly created SpectrumValue */ - virtual Ptr CreateRfFilter (uint32_t channel); + virtual Ptr CreateRfFilter (uint8_t channel); }; } // namespace ns3 diff --git a/src/wifi/test/spectrum-wifi-phy-test.cc b/src/wifi/test/spectrum-wifi-phy-test.cc index 8151dbf0e57..619f55ae692 100644 --- a/src/wifi/test/spectrum-wifi-phy-test.cc +++ b/src/wifi/test/spectrum-wifi-phy-test.cc @@ -28,10 +28,10 @@ using namespace ns3; -static const uint16_t CHANNEL_NUMBER = 36; +static const uint8_t CHANNEL_NUMBER = 36; static const uint32_t FREQUENCY = 5180; // MHz -static const uint32_t CHANNEL_WIDTH = 20; // MHz -static const uint32_t GUARD_WIDTH = 10; // MHz +static const uint8_t CHANNEL_WIDTH = 20; // MHz +static const uint8_t GUARD_WIDTH = 10; // MHz /** * \ingroup wifi-test From 1e9758b406313432a36ab0ff7fab968dffbcf10f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 20:50:10 +0200 Subject: [PATCH 012/551] wifi, spectrum: (fixes #2722) Create spectral density based on WifiModulationClass iso the current standard --- RELEASE_NOTES | 1 + .../model/wifi-spectrum-value-helper.cc | 13 +++------- src/wifi/model/spectrum-wifi-phy.cc | 26 ++++++++----------- src/wifi/model/spectrum-wifi-phy.h | 3 ++- 4 files changed, 18 insertions(+), 25 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index a3d1eae0691..39cd67fab50 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -101,6 +101,7 @@ Bugs fixed - Bug 2665 - Ipv4RawSocket can not send packets to broadcast or multicast - Bug 2671 - ArpCache::Entry::SetMacAddress is misspelled - Bug 2717 - Fix mask generation for Ipv4RoutingTableEntry::CreateDefaultRoute +- Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity Known issues ------------ diff --git a/src/spectrum/model/wifi-spectrum-value-helper.cc b/src/spectrum/model/wifi-spectrum-value-helper.cc index 1ea96ebd089..836236735a9 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.cc +++ b/src/spectrum/model/wifi-spectrum-value-helper.cc @@ -135,7 +135,7 @@ WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFreque Ptr c = Create (GetSpectrumModel (centerFrequency, channelWidth, bandBandwidth, guardBandwidth)); uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands " << c->GetSpectrumModel ()->GetNumBands ()); double txPowerPerBand = 0; uint32_t start1 = 0; uint32_t stop1 = 0; @@ -144,6 +144,7 @@ WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFreque switch (channelWidth) { case 20: + default: // 52 subcarriers (48 data + 4 pilot) // skip guard band and 6 subbands, then place power in 26 subbands, then // skip the center subband, then place power in 26 subbands, then skip @@ -176,9 +177,6 @@ WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (uint32_t centerFreque start2 = stop1 + 2; stop2 = start2 + 8 - 1; break; - default: - NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); - break; } NS_LOG_DEBUG ("Power per band " << txPowerPerBand); Values::iterator vit = c->ValuesBegin (); @@ -210,7 +208,7 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq Bands::const_iterator bit = c->ConstBandsBegin (); uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands " << c->GetSpectrumModel ()->GetNumBands ()); double txPowerPerBand; // skip the guard band and 4 subbands, then place power in 28 subbands, then // skip the center subband, then place power in 28 subbands, then skip @@ -362,9 +360,6 @@ WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFreq ", " << start15 << "-" << stop15 << ", " << start16 << "-" << stop16); break; - default: - NS_FATAL_ERROR ("ChannelWidth " << channelWidth << " unsupported"); - break; } NS_LOG_DEBUG ("Integrated power " << Integral (*c)); NS_ASSERT_MSG (std::abs (txPowerW - Integral (*c)) < 1e-6, "Power allocation failed"); @@ -381,7 +376,7 @@ WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFreq Bands::const_iterator bit = c->ConstBandsBegin (); uint32_t nGuardBands = static_cast(((2 * guardBandwidth * 1e6) / bandBandwidth) + 0.5); uint32_t nAllocatedBands = static_cast(((channelWidth * 1e6) / bandBandwidth) + 0.5); - NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands"); + NS_ASSERT_MSG (c->GetSpectrumModel ()->GetNumBands () == (nAllocatedBands + nGuardBands + 1), "Unexpected number of bands " << c->GetSpectrumModel ()->GetNumBands ()); double txPowerPerBand; uint32_t start1; uint32_t stop1; diff --git a/src/wifi/model/spectrum-wifi-phy.cc b/src/wifi/model/spectrum-wifi-phy.cc index cf2426368e1..f9023bb7ff2 100644 --- a/src/wifi/model/spectrum-wifi-phy.cc +++ b/src/wifi/model/spectrum-wifi-phy.cc @@ -228,33 +228,29 @@ SpectrumWifiPhy::CreateWifiSpectrumPhyInterface (Ptr device) } Ptr -SpectrumWifiPhy::GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t channelWidth, double txPowerW) const +SpectrumWifiPhy::GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t channelWidth, double txPowerW, WifiModulationClass modulationClass) const { NS_LOG_FUNCTION (centerFrequency << (uint16_t)channelWidth << txPowerW); Ptr v; - switch (GetStandard ()) + switch (modulationClass) { - case WIFI_PHY_STANDARD_80211a: - case WIFI_PHY_STANDARD_80211g: - case WIFI_PHY_STANDARD_holland: - case WIFI_PHY_STANDARD_80211_10MHZ: - case WIFI_PHY_STANDARD_80211_5MHZ: + case WIFI_MOD_CLASS_OFDM: + case WIFI_MOD_CLASS_ERP_OFDM: v = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; - case WIFI_PHY_STANDARD_80211b: + case WIFI_MOD_CLASS_DSSS: + case WIFI_MOD_CLASS_HR_DSSS: v = WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity (centerFrequency, txPowerW, GetGuardBandwidth ()); break; - case WIFI_PHY_STANDARD_80211n_2_4GHZ: - case WIFI_PHY_STANDARD_80211n_5GHZ: - case WIFI_PHY_STANDARD_80211ac: + case WIFI_MOD_CLASS_HT: + case WIFI_MOD_CLASS_VHT: v = WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; - case WIFI_PHY_STANDARD_80211ax_2_4GHZ: - case WIFI_PHY_STANDARD_80211ax_5GHZ: + case WIFI_MOD_CLASS_HE: v = WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity (centerFrequency, channelWidth, txPowerW, GetGuardBandwidth ()); break; default: - NS_FATAL_ERROR ("Standard unknown: " << GetStandard ()); + NS_FATAL_ERROR ("modulation class unknown: " << modulationClass); break; } return v; @@ -265,7 +261,7 @@ SpectrumWifiPhy::StartTx (Ptr packet, WifiTxVector txVector, Time txDura { NS_LOG_DEBUG ("Start transmission: signal power before antenna gain=" << GetPowerDbm (txVector.GetTxPowerLevel ()) << "dBm"); double txPowerWatts = DbmToW (GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain ()); - Ptr txPowerSpectrum = GetTxPowerSpectralDensity (GetFrequency (), GetChannelWidth (), txPowerWatts); + Ptr txPowerSpectrum = GetTxPowerSpectralDensity (GetFrequency (), GetChannelWidth (), txPowerWatts, txVector.GetMode ().GetModulationClass ()); Ptr txParams = Create (); txParams->duration = txDuration; txParams->psd = txPowerSpectrum; diff --git a/src/wifi/model/spectrum-wifi-phy.h b/src/wifi/model/spectrum-wifi-phy.h index 4e614a4f0cd..fc5cda7e130 100644 --- a/src/wifi/model/spectrum-wifi-phy.h +++ b/src/wifi/model/spectrum-wifi-phy.h @@ -172,12 +172,13 @@ class SpectrumWifiPhy : public WifiPhy * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) of the channel * \param txPowerW power in W to spread across the bands + * \param modulationClass the modulation class * \return Ptr to SpectrumValue * * This is a helper function to create the right Tx PSD corresponding * to the standard in use. */ - Ptr GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t channelWidth, double txPowerW) const; + Ptr GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t channelWidth, double txPowerW, WifiModulationClass modulationClass) const; Ptr m_channel; //!< SpectrumChannel that this SpectrumWifiPhy is connected to std::vector m_operationalChannelList; //!< List of possible channels From 4cd14fd8d276806b6ba73625568a2e28af31fb4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 18 Apr 2017 21:34:53 +0200 Subject: [PATCH 013/551] spectrum: Rescan bindings --- src/spectrum/bindings/modulegen__gcc_ILP32.py | 37 +++++++++++-------- src/spectrum/bindings/modulegen__gcc_LP64.py | 37 +++++++++++-------- 2 files changed, 42 insertions(+), 32 deletions(-) diff --git a/src/spectrum/bindings/modulegen__gcc_ILP32.py b/src/spectrum/bindings/modulegen__gcc_ILP32.py index addd3d1703e..965b26acc7c 100644 --- a/src/spectrum/bindings/modulegen__gcc_ILP32.py +++ b/src/spectrum/bindings/modulegen__gcc_ILP32.py @@ -3213,15 +3213,15 @@ def register_Ns3WifiSpectrumValue5MhzFactory_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [param('double', 'psd')], is_virtual=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateRfFilter(uint32_t channel) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateRfFilter(uint8_t channel) [member function] cls.add_method('CreateRfFilter', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'channel')], + [param('uint8_t', 'channel')], is_virtual=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity(double txPower, uint32_t channel) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity(double txPower, uint8_t channel) [member function] cls.add_method('CreateTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('double', 'txPower'), param('uint32_t', 'channel')], + [param('double', 'txPower'), param('uint8_t', 'channel')], is_virtual=True) return @@ -3230,40 +3230,45 @@ def register_Ns3WifiSpectrumValueHelper_methods(root_module, cls): cls.add_constructor([]) ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::WifiSpectrumValueHelper::WifiSpectrumValueHelper(ns3::WifiSpectrumValueHelper const & arg0) [copy constructor] cls.add_constructor([param('ns3::WifiSpectrumValueHelper const &', 'arg0')]) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity(uint32_t centerFrequency, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity(uint32_t centerFrequency, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateDsssTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] + cls.add_method('CreateHeOfdmTxPowerSpectralDensity', + 'ns3::Ptr< ns3::SpectrumValue >', + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], + is_static=True) + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateHtOfdmTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, double noiseFigure, uint8_t guardBandwidth) [member function] cls.add_method('CreateNoisePowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth'), param('double', 'noiseFigure')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('double', 'noiseFigure'), param('uint8_t', 'guardBandwidth')], is_static=True) ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(double noiseFigure, ns3::Ptr spectrumModel) [member function] cls.add_method('CreateNoisePowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('double', 'noiseFigure'), param('ns3::Ptr< ns3::SpectrumModel >', 'spectrumModel')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateOfdmTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateRfFilter(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateRfFilter(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) [member function] cls.add_method('CreateRfFilter', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::GetSpectrumModel(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::GetSpectrumModel(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) [member function] cls.add_method('GetSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('uint8_t', 'guardBandwidth')], is_static=True) return diff --git a/src/spectrum/bindings/modulegen__gcc_LP64.py b/src/spectrum/bindings/modulegen__gcc_LP64.py index addd3d1703e..965b26acc7c 100644 --- a/src/spectrum/bindings/modulegen__gcc_LP64.py +++ b/src/spectrum/bindings/modulegen__gcc_LP64.py @@ -3213,15 +3213,15 @@ def register_Ns3WifiSpectrumValue5MhzFactory_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [param('double', 'psd')], is_virtual=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateRfFilter(uint32_t channel) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateRfFilter(uint8_t channel) [member function] cls.add_method('CreateRfFilter', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'channel')], + [param('uint8_t', 'channel')], is_virtual=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity(double txPower, uint32_t channel) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::Ptr ns3::WifiSpectrumValue5MhzFactory::CreateTxPowerSpectralDensity(double txPower, uint8_t channel) [member function] cls.add_method('CreateTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('double', 'txPower'), param('uint32_t', 'channel')], + [param('double', 'txPower'), param('uint8_t', 'channel')], is_virtual=True) return @@ -3230,40 +3230,45 @@ def register_Ns3WifiSpectrumValueHelper_methods(root_module, cls): cls.add_constructor([]) ## wifi-spectrum-value-helper.h (module 'spectrum'): ns3::WifiSpectrumValueHelper::WifiSpectrumValueHelper(ns3::WifiSpectrumValueHelper const & arg0) [copy constructor] cls.add_constructor([param('ns3::WifiSpectrumValueHelper const &', 'arg0')]) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity(uint32_t centerFrequency, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateDsssTxPowerSpectralDensity(uint32_t centerFrequency, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateDsssTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHeOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] + cls.add_method('CreateHeOfdmTxPowerSpectralDensity', + 'ns3::Ptr< ns3::SpectrumValue >', + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], + is_static=True) + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateHtOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateHtOfdmTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth, double noiseFigure) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, double noiseFigure, uint8_t guardBandwidth) [member function] cls.add_method('CreateNoisePowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth'), param('double', 'noiseFigure')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('double', 'noiseFigure'), param('uint8_t', 'guardBandwidth')], is_static=True) ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateNoisePowerSpectralDensity(double noiseFigure, ns3::Ptr spectrumModel) [member function] cls.add_method('CreateNoisePowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('double', 'noiseFigure'), param('ns3::Ptr< ns3::SpectrumModel >', 'spectrumModel')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint32_t channelWidth, double txPowerW) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity(uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth) [member function] cls.add_method('CreateOfdmTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'txPowerW')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'txPowerW'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateRfFilter(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::CreateRfFilter(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) [member function] cls.add_method('CreateRfFilter', 'ns3::Ptr< ns3::SpectrumValue >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('uint8_t', 'guardBandwidth')], is_static=True) - ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::GetSpectrumModel(uint32_t centerFrequency, uint32_t channelWidth, double bandBandwidth) [member function] + ## wifi-spectrum-value-helper.h (module 'spectrum'): static ns3::Ptr ns3::WifiSpectrumValueHelper::GetSpectrumModel(uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) [member function] cls.add_method('GetSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel >', - [param('uint32_t', 'centerFrequency'), param('uint32_t', 'channelWidth'), param('double', 'bandBandwidth')], + [param('uint32_t', 'centerFrequency'), param('uint8_t', 'channelWidth'), param('double', 'bandBandwidth'), param('uint8_t', 'guardBandwidth')], is_static=True) return From a76d0207fc90a26c6a210e8b8166d95c6b50087c Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 21 Apr 2017 16:56:50 +0300 Subject: [PATCH 014/551] wifi: Make YansWifiChannel::Receive static --- src/wifi/model/yans-wifi-channel.cc | 6 +++--- src/wifi/model/yans-wifi-channel.h | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/wifi/model/yans-wifi-channel.cc b/src/wifi/model/yans-wifi-channel.cc index b56bd003641..26f98001305 100644 --- a/src/wifi/model/yans-wifi-channel.cc +++ b/src/wifi/model/yans-wifi-channel.cc @@ -108,16 +108,16 @@ YansWifiChannel::Send (Ptr sender, Ptr packet, double } Simulator::ScheduleWithContext (dstNode, - delay, &YansWifiChannel::Receive, this, + delay, &YansWifiChannel::Receive, (*i), copy, rxPowerDbm, duration); } } } void -YansWifiChannel::Receive (Ptr phy, Ptr packet, double rxPowerDbm, Time duration) const +YansWifiChannel::Receive (Ptr phy, Ptr packet, double rxPowerDbm, Time duration) { - NS_LOG_FUNCTION (this << phy << packet << rxPowerDbm << duration.GetSeconds ()); + NS_LOG_FUNCTION (phy << packet << rxPowerDbm << duration.GetSeconds ()); phy->StartReceivePreambleAndHeader (packet, DbmToW (rxPowerDbm + phy->GetRxGain ()), duration); } diff --git a/src/wifi/model/yans-wifi-channel.h b/src/wifi/model/yans-wifi-channel.h index d0e42fe9690..2e402b3b4b3 100644 --- a/src/wifi/model/yans-wifi-channel.h +++ b/src/wifi/model/yans-wifi-channel.h @@ -112,7 +112,7 @@ class YansWifiChannel : public Channel * \param txPowerDbm the tx power associated to the packet being sent (dBm) * \param duration the transmission duration associated with the packet being sent */ - void Receive (Ptr receiver, Ptr packet, double txPowerDbm, Time duration) const; + static void Receive (Ptr receiver, Ptr packet, double txPowerDbm, Time duration); PhyList m_phyList; //!< List of YansWifiPhys connected to this YansWifiChannel Ptr m_loss; //!< Propagation loss model From fe7e8fb07a54710383cfd98ce3c58afbb1717038 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Fri, 21 Apr 2017 21:10:48 -0700 Subject: [PATCH 015/551] spectrum: correct Doxygen warnings --- .../model/wifi-spectrum-value-helper.cc | 20 +++++++++++++++---- .../model/wifi-spectrum-value-helper.h | 14 ++++++++++--- 2 files changed, 27 insertions(+), 7 deletions(-) diff --git a/src/spectrum/model/wifi-spectrum-value-helper.cc b/src/spectrum/model/wifi-spectrum-value-helper.cc index 836236735a9..a8686558ceb 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.cc +++ b/src/spectrum/model/wifi-spectrum-value-helper.cc @@ -31,11 +31,17 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("WifiSpectrumValueHelper"); +///< Wifi Spectrum Model structure struct WifiSpectrumModelId { + /** + * Constructor + * \param f the frequency in Mhz + * \param w the channel width in Mhz + */ WifiSpectrumModelId (uint32_t f, uint8_t w); - uint32_t m_centerFrequency; - uint8_t m_channelWidth; + uint32_t m_centerFrequency; ///< center frequency + uint8_t m_channelWidth; ///< channel width }; WifiSpectrumModelId::WifiSpectrumModelId (uint32_t f, uint8_t w) @@ -45,13 +51,19 @@ WifiSpectrumModelId::WifiSpectrumModelId (uint32_t f, uint8_t w) NS_LOG_FUNCTION (this << f << (uint16_t)w); } +/** + * Less than operator + * \param a the first wifi spectrum to compare + * \param b the second wifi spectrum to compare + * \returns true if the first spectrum is less than the second spectrum + */ bool operator < (const WifiSpectrumModelId& a, const WifiSpectrumModelId& b) { return ( (a.m_centerFrequency < b.m_centerFrequency) || ( (a.m_centerFrequency == b.m_centerFrequency) && (a.m_channelWidth < b.m_channelWidth))); } -static std::map > g_wifiSpectrumModelMap; +static std::map > g_wifiSpectrumModelMap; ///< static initializer for the class Ptr WifiSpectrumValueHelper::GetSpectrumModel (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, uint8_t guardBandwidth) @@ -554,7 +566,7 @@ WifiSpectrumValueHelper::CreateRfFilter (uint32_t centerFrequency, uint8_t chann return c; } -static Ptr g_WifiSpectrumModel5Mhz; +static Ptr g_WifiSpectrumModel5Mhz; ///< static initializer for the class WifiSpectrumValueHelper::~WifiSpectrumValueHelper () { diff --git a/src/spectrum/model/wifi-spectrum-value-helper.h b/src/spectrum/model/wifi-spectrum-value-helper.h index 41ca4777ecb..334dc8558ae 100644 --- a/src/spectrum/model/wifi-spectrum-value-helper.h +++ b/src/spectrum/model/wifi-spectrum-value-helper.h @@ -65,6 +65,7 @@ class WifiSpectrumValueHelper * \param centerFrequency center frequency (MHz) * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) + * \returns a pointer to a newly allocated SpectrumValue representing the DSSS Transmit Power Spectral Density in W/Hz */ static Ptr CreateDsssTxPowerSpectralDensity (uint32_t centerFrequency, double txPowerW, uint8_t guardBandwidth); @@ -76,6 +77,7 @@ class WifiSpectrumValueHelper * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) + * \return a pointer to a newly allocated SpectrumValue representing the OFDM Transmit Power Spectral Density in W/Hz for each Band */ static Ptr CreateOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); @@ -88,6 +90,7 @@ class WifiSpectrumValueHelper * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) + * \return a pointer to a newly allocated SpectrumValue representing the HT OFDM Transmit Power Spectral Density in W/Hz for each Band */ static Ptr CreateHtOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); @@ -100,29 +103,34 @@ class WifiSpectrumValueHelper * \param channelWidth channel width (MHz) * \param txPowerW transmit power (W) to allocate * \param guardBandwidth width of the guard band (MHz) + * \return a pointer to a newly allocated SpectrumValue representing the HE OFDM Transmit Power Spectral Density in W/Hz for each Band */ static Ptr CreateHeOfdmTxPowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double txPowerW, uint8_t guardBandwidth); /** + * Create a power spectral density corresponding to the noise * * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param bandBandwidth width of each band (Hz) * \param noiseFigure the noise figure in dB w.r.t. a reference temperature of 290K * \param guardBandwidth width of the guard band (MHz) - * * \return a pointer to a newly allocated SpectrumValue representing the noise Power Spectral Density in W/Hz for each Band */ static Ptr CreateNoisePowerSpectralDensity (uint32_t centerFrequency, uint8_t channelWidth, double bandBandwidth, double noiseFigure, uint8_t guardBandwidth); /** - * \param centerFrequency center frequency (MHz) - * \param channelWidth channel width (MHz) + * Create a thermal noise power spectral density + * + * \param noiseFigure the noise figure + * \param spectrumModel the spectrum model * \return a pointer to a newly allocated SpectrumValue representing the noise Power Spectral Density in W/Hz corresponding to thermal noise, for each Band */ static Ptr CreateNoisePowerSpectralDensity (double noiseFigure, Ptr spectrumModel); /** + * Create a spectral density corresponding to the RF filter + * * \param centerFrequency center frequency (MHz) * \param channelWidth channel width (MHz) * \param bandBandwidth width of each band (Hz) From a2238de0e40802d8a8e0c3ec32072c172eb479ca Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Sat, 22 Apr 2017 19:22:20 +0300 Subject: [PATCH 016/551] network: Fix comment in packet-socket-apps example --- src/network/examples/packet-socket-apps.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/network/examples/packet-socket-apps.cc b/src/network/examples/packet-socket-apps.cc index e6159af7ecd..4644b885360 100644 --- a/src/network/examples/packet-socket-apps.cc +++ b/src/network/examples/packet-socket-apps.cc @@ -27,7 +27,7 @@ // // - Packets flows from n0 to n1 // -// This example shows how to use the SimpleServer and SimpleClient +// This example shows how to use the PacketSocketServer and PacketSocketClient // to send non-IP packets over a SimpleNetDevice #include "ns3/core-module.h" From 250faaa547d6d7744a88281554268144bfef8d74 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 24 Apr 2017 21:17:45 +0200 Subject: [PATCH 017/551] aodv: update documentation to be in-line with current features. --- src/aodv/doc/aodv.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/src/aodv/doc/aodv.rst b/src/aodv/doc/aodv.rst index b71bafe964c..d048e1eb06c 100644 --- a/src/aodv/doc/aodv.rst +++ b/src/aodv/doc/aodv.rst @@ -79,7 +79,6 @@ Scope and Limitations The model is for IPv4 only. The following optional protocol optimizations are not implemented: -#. Expanding ring search. #. Local link repair. #. RREP, RREQ and HELLO message extensions. From 850e4cc02eb5df4567bed5029bc5fbdb2d69cf5b Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Wed, 26 Apr 2017 06:51:40 -0700 Subject: [PATCH 018/551] visualizer: Correct doxygen warnings --- src/visualizer/model/pyviz.cc | 72 +++- src/visualizer/model/pyviz.h | 281 ++++++++++++--- src/visualizer/model/visual-simulator-impl.cc | 1 + src/visualizer/model/visual-simulator-impl.h | 10 +- src/visualizer/visualizer/base.py | 26 +- src/visualizer/visualizer/core.py | 334 +++++++++++++++++- src/visualizer/visualizer/higcontainer.py | 79 ++++- src/visualizer/visualizer/hud.py | 53 +++ src/visualizer/visualizer/ipython_view.py | 264 ++++++++------ .../plugins/interface_statistics.py | 57 +++ .../visualizer/plugins/ipv4_routing_table.py | 28 ++ src/visualizer/visualizer/plugins/olsr.py | 28 ++ .../visualizer/plugins/show_last_packets.py | 59 ++++ .../plugins/wifi_intrastructure_link.py | 63 +++- src/visualizer/visualizer/svgitem.py | 72 ++++ 15 files changed, 1250 insertions(+), 177 deletions(-) diff --git a/src/visualizer/model/pyviz.cc b/src/visualizer/model/pyviz.cc index 82c19b07e54..ea3b774f10f 100644 --- a/src/visualizer/model/pyviz.cc +++ b/src/visualizer/model/pyviz.cc @@ -62,10 +62,12 @@ PathSplit (std::string str) namespace ns3 { -static PyViz* g_visualizer = NULL; - +static PyViz* g_visualizer = NULL; ///< the visualizer +/** + * PyVizPacketTag structure + */ struct PyVizPacketTag : public Tag { static TypeId GetTypeId (void); @@ -76,10 +78,14 @@ struct PyVizPacketTag : public Tag virtual void Print (std::ostream &os) const; PyVizPacketTag (); - uint32_t m_packetId; + uint32_t m_packetId; ///< packet id }; +/** + * \brief Get the type ID. + * \return the object TypeId + */ TypeId PyVizPacketTag::GetTypeId (void) { @@ -936,67 +942,104 @@ PyViz::GetLastPackets (uint32_t nodeId) const namespace { -// Adapted from http://en.wikipedia.org/w/index.php?title=Line_clipping&oldid=248609574 +/// Adapted from http://en.wikipedia.org/w/index.php?title=Line_clipping&oldid=248609574 class FastClipping { public: + /// Vector2 structure struct Vector2 { - double x; - double y; + double x; ///< X + double y; ///< Y }; - Vector2 m_clipMin, m_clipMax; + Vector2 m_clipMin; ///< clip minimum + Vector2 m_clipMax; ///< clip maximum + /// Line structure struct Line { - Vector2 start, end; - double dx, dy; + Vector2 start; ///< start + Vector2 end; ///< end + double dx; ///< dX + double dy; ///< dY }; private: + /** + * Clip start top function + * \param line the clip line + */ void ClipStartTop (Line &line) { line.start.x += line.dx * (m_clipMin.y - line.start.y) / line.dy; line.start.y = m_clipMin.y; } + /** + * Clip start bottom function + * \param line the clip line + */ void ClipStartBottom (Line &line) { line.start.x += line.dx * (m_clipMax.y - line.start.y) / line.dy; line.start.y = m_clipMax.y; } + /** + * Clip start right function + * \param line the clip line + */ void ClipStartRight (Line &line) { line.start.y += line.dy * (m_clipMax.x - line.start.x) / line.dx; line.start.x = m_clipMax.x; } + /** + * Clip start left function + * \param line the clip line + */ void ClipStartLeft (Line &line) { line.start.y += line.dy * (m_clipMin.x - line.start.x) / line.dx; line.start.x = m_clipMin.x; } + /** + * Clip end top function + * \param line the clip line + */ void ClipEndTop (Line &line) { line.end.x += line.dx * (m_clipMin.y - line.end.y) / line.dy; line.end.y = m_clipMin.y; } + /** + * Clip end bottom function + * \param line the clip line + */ void ClipEndBottom (Line &line) { line.end.x += line.dx * (m_clipMax.y - line.end.y) / line.dy; line.end.y = m_clipMax.y; } + /** + * Clip end right function + * \param line the clip line + */ void ClipEndRight (Line &line) { line.end.y += line.dy * (m_clipMax.x - line.end.x) / line.dx; line.end.x = m_clipMax.x; } + /** + * Clip end left function + * \param line the clip line + */ void ClipEndLeft (Line &line) { line.end.y += line.dy * (m_clipMin.x - line.end.x) / line.dx; @@ -1004,12 +1047,23 @@ class FastClipping } public: + /** + * Constructor + * + * \param clipMin minimum clipping vector + * \param clipMax maximum clipping vector + */ FastClipping (Vector2 clipMin, Vector2 clipMax) : m_clipMin (clipMin), m_clipMax (clipMax) { } + /** + * Clip line function + * \param line the clip line + * \returns true if clipped + */ bool ClipLine (Line &line) { uint8_t lineCode = 0; diff --git a/src/visualizer/model/pyviz.h b/src/visualizer/model/pyviz.h index 9c70503a6da..5a35a856a54 100644 --- a/src/visualizer/model/pyviz.h +++ b/src/visualizer/model/pyviz.h @@ -54,173 +54,360 @@ class PyViz PyViz (); ~PyViz (); + /** + * Register drop trace path function + * \param tracePath the path to trace + */ void RegisterDropTracePath (std::string const &tracePath); + /** + * Register CSMA like device function + * \param deviceTypeName the device type name + */ void RegisterCsmaLikeDevice (std::string const &deviceTypeName); + /** + * Register WIFI like device function + * \param deviceTypeName the device type name + */ void RegisterWifiLikeDevice (std::string const &deviceTypeName); + /** + * Register point to point like device function + * \param deviceTypeName the device type name + */ void RegisterPointToPointLikeDevice (std::string const &deviceTypeName); - // Run simulation until a given (simulated, absolute) time is reached + /** + * Run simulation until a given (simulated, absolute) time is reached + * \param time the run time + */ void SimulatorRunUntil (Time time); + /** + * Pause function + * \param message the pause message + */ static void Pause (std::string const &message); + /** + * Get pause message function + * \returns the pause message + */ std::vector GetPauseMessages () const; + /// TransmissionSample structure struct TransmissionSample { - Ptr transmitter; - Ptr receiver; // NULL if broadcast - Ptr channel; - uint32_t bytes; + Ptr transmitter; ///< transmitter + Ptr receiver; ///< NULL if broadcast + Ptr channel; ///< channel + uint32_t bytes; ///< bytes }; - typedef std::vector TransmissionSampleList; + typedef std::vector TransmissionSampleList; ///< TransmissionSampleList typedef + /** + * Get transmission samples + * \returns the transmission sample list + */ TransmissionSampleList GetTransmissionSamples () const; + /// PacketDropSample structure struct PacketDropSample { - Ptr transmitter; - uint32_t bytes; + Ptr transmitter; ///< transmitter + uint32_t bytes; ///< bytes }; - typedef std::vector PacketDropSampleList; + typedef std::vector PacketDropSampleList; ///< PacketDropSampleList typedef + /** + * Get packet drop samples + * \returns the packet drop sample list + */ PacketDropSampleList GetPacketDropSamples () const; + /// PacketSample structure struct PacketSample { - Time time; - Ptr packet; - Ptr device; + Time time; ///< time + Ptr packet; ///< packet + Ptr device; ///< device }; + /// TxPacketSample structure struct TxPacketSample : PacketSample { - Mac48Address to; + Mac48Address to; ///< to }; + /// RxPacketSample structure struct RxPacketSample : PacketSample { - Mac48Address from; + Mac48Address from; ///< from }; + /// LastPacketsSample structure struct LastPacketsSample { - std::vector lastReceivedPackets; - std::vector lastTransmittedPackets; - std::vector lastDroppedPackets; + std::vector lastReceivedPackets; ///< last received packets + std::vector lastTransmittedPackets; ///< last transmitted packets + std::vector lastDroppedPackets; ///< last dropped packets }; + /** + * Get last packets function + * \param nodeId the node ID + * \returns the last packets + */ LastPacketsSample GetLastPackets (uint32_t nodeId) const; + /** + * Set nodes of interest function + * \param nodes the collection of nodes + */ void SetNodesOfInterest (std::set nodes); + /// NetDeviceStatistics structure struct NetDeviceStatistics { + /// constructor NetDeviceStatistics () : transmittedBytes (0), receivedBytes (0), transmittedPackets (0), receivedPackets (0) {} - uint64_t transmittedBytes; - uint64_t receivedBytes; - uint32_t transmittedPackets; - uint32_t receivedPackets; + uint64_t transmittedBytes; ///< transmitted bytes + uint64_t receivedBytes; ///< received bytes + uint32_t transmittedPackets; ///< transmitted packets + uint32_t receivedPackets; ///< received packets }; + /// NodeStatistics structure struct NodeStatistics { - uint32_t nodeId; - std::vector statistics; + uint32_t nodeId; ///< node ID + std::vector statistics; ///< statistics }; + /** + * Get node statistics + * \returns the node statistics + */ std::vector GetNodesStatistics () const; + /// PacketCaptureMode enumeration enum PacketCaptureMode { PACKET_CAPTURE_DISABLED=1, // packet capture is disabled PACKET_CAPTURE_FILTER_HEADERS_OR, // packet capture if any of the indicated headers is present PACKET_CAPTURE_FILTER_HEADERS_AND, // packet capture if all of the indicated headers are present }; + /// PacketCaptureOptions structure struct PacketCaptureOptions { - std::set headers; - uint32_t numLastPackets; - PacketCaptureMode mode; + std::set headers; ///< headers + uint32_t numLastPackets; ///< num last packets + PacketCaptureMode mode; ///< mode }; + /** + * Set packet capture options function + * \param nodeId the node ID + * \param options the capture options + */ void SetPacketCaptureOptions (uint32_t nodeId, PacketCaptureOptions options); // Yes, I know, this is just a utility function, not really related to the class in any way. // -#- @lineX1(direction=inout); @lineY1(direction=inout); @lineX2(direction=inout); @lineY2(direction=inout) -#- - static void LineClipping (double boundsX1, double boundsY1, double boundsX2, double boundsY2, double &lineX1, double &lineY1, double &lineX2, double &lineY2); // don't break this line or pybindgen will not be able to pick up the above annotation :( + static void LineClipping (double boundsX1, double boundsY1, double boundsX2, double boundsY2, double &lineX1, double &lineY1, double &lineX2, double &lineY2); ///< don't break this line or pybindgen will not be able to pick up the above annotation :( private: + /** + * Get packet capture options function + * \param nodeId the node ID + * \param outOptions the packet capture options + * \returns true if successful + */ bool GetPacketCaptureOptions (uint32_t nodeId, const PacketCaptureOptions **outOptions) const; + /** + * Filter packet function + * \param packet the packet + * \param options the capture options + * \returns true if successful + */ static bool FilterPacket (Ptr packet, const PacketCaptureOptions &options); - typedef std::pair, uint32_t> TxRecordKey; + typedef std::pair, uint32_t> TxRecordKey; ///< TxRecordKey typedef + /// TxRecordValue structure struct TxRecordValue { - Time time; - Ptr srcNode; - bool isBroadcast; + Time time; ///< time + Ptr srcNode; ///< source node + bool isBroadcast; ///< is broadcast? }; + /// TransmissionSampleKey structure struct TransmissionSampleKey { + /** + * less than operator + * + * \param other object to compare + * \return true if less than + */ bool operator < (TransmissionSampleKey const &other) const; + /** + * equality operator + * + * \param other object to compare + * \return true if equal + */ bool operator == (TransmissionSampleKey const &other) const; - Ptr transmitter; - Ptr receiver; // NULL if broadcast - Ptr channel; + Ptr transmitter; ///< transmitter + Ptr receiver; ///< NULL if broadcast + Ptr channel; ///< channel }; + /// TransmissionSampleValue structure struct TransmissionSampleValue { - uint32_t bytes; + uint32_t bytes; ///< bytes }; // data - std::map m_packetCaptureOptions; - std::vector m_pauseMessages; - std::map m_txRecords; - std::map m_transmissionSamples; - std::map, uint32_t> m_packetDrops; - std::set m_nodesOfInterest; // list of node IDs whose transmissions will be monitored - std::map m_packetsOfInterest; // list of packet UIDs that will be monitored - std::map m_lastPackets; - std::map > m_nodesStatistics; + std::map m_packetCaptureOptions; ///< packet capture options + std::vector m_pauseMessages; ///< pause message + std::map m_txRecords; ///< transmit records + std::map m_transmissionSamples; ///< transmission samples + std::map, uint32_t> m_packetDrops; ///< packt drops + std::set m_nodesOfInterest; ///< list of node IDs whose transmissions will be monitored + std::map m_packetsOfInterest; ///< list of packet UIDs that will be monitored + std::map m_lastPackets; ///< last packets + std::map > m_nodesStatistics; ///< node statsitics // Trace callbacks + /** + * network transmit common trace callback function + * \param context the context + * \param packet the packet + * \param destination the destination MAC address + */ void TraceNetDevTxCommon (std::string const &context, Ptr packet, Mac48Address const &destination); + /** + * network receive common trace callback function + * \param context the context + * \param packet the packet + * \param source the source MAC address + */ void TraceNetDevRxCommon (std::string const &context, Ptr packet, Mac48Address const &source); + /** + * WIFI transmit trace callback function + * \param context the context + * \param packet the packet + */ void TraceNetDevTxWifi (std::string context, Ptr packet); + /** + * WIFI receive trace callback function + * \param context the context + * \param packet the packet + */ void TraceNetDevRxWifi (std::string context, Ptr packet); + /** + * queue drop trace callback function + * \param context the context + * \param packet the packet + */ void TraceDevQueueDrop (std::string context, Ptr packet); - void TraceIpv4Drop (std::string context, ns3::Ipv4Header const &hdr, Ptr packet, + /** + * ipv4 drop trace callback function + * \param context the context + * \param hdr the header + * \param packet the packet + * \param reason the drop reason + * \param dummy_ipv4 + * \param interface the interface + */ + void TraceIpv4Drop (std::string context, ns3::Ipv4Header const &hdr, Ptr packet, ns3::Ipv4L3Protocol::DropReason reason, Ptr dummy_ipv4, uint32_t interface); + /** + * CSMA transmit trace callback function + * \param context the context + * \param packet the packet + */ void TraceNetDevTxCsma (std::string context, Ptr packet); + /** + * CSMA receive trace callback function + * \param context the context + * \param packet the packet + */ void TraceNetDevRxCsma (std::string context, Ptr packet); + /** + * CSMA promiscious receive function + * \param context the context + * \param packet the packet + */ void TraceNetDevPromiscRxCsma (std::string context, Ptr packet); + /** + * Point to point transmit trace calllback function + * \param context the context + * \param packet the packet + */ void TraceNetDevTxPointToPoint (std::string context, Ptr packet); + /** + * Point to point receive trace callback function + * \param context the context + * \param packet the packet + */ void TraceNetDevRxPointToPoint (std::string context, Ptr packet); + /** + * WIMax transmit trace callback function + * \param context the context + * \param packet the packet + * \param destination the destination MAC address + */ void TraceNetDevTxWimax (std::string context, Ptr packet, Mac48Address const &destination); + /** + * WIMax transmit trace callback function + * \param context the context + * \param packet the packet + * \param source the source MAC address + */ void TraceNetDevRxWimax (std::string context, Ptr packet, Mac48Address const &source); + /** + * LTE transmit trace callback function + * \param context the context + * \param packet the packet + * \param destination the destination MAC address + */ void TraceNetDevTxLte (std::string context, Ptr packet, Mac48Address const &destination); + /** + * LTE receive trace callback function + * \param context the context + * \param packet the packet + * \param source the MAC address of the source + */ void TraceNetDevRxLte (std::string context, Ptr packet, Mac48Address const &source); + /** + * Findnet device statistics function + * \param node the node + * \param interface the interface number + * \returns the device statistics + */ inline NetDeviceStatistics & FindNetDeviceStatistics (int node, int interface); + /** + * Do pause function + * \param message the pause message + */ void DoPause (std::string const &message); - bool m_stop; - Time m_runUntil; + bool m_stop; ///< stop? + Time m_runUntil; ///< run until time + /// stop simulation callback function void CallbackStopSimulation (); }; diff --git a/src/visualizer/model/visual-simulator-impl.cc b/src/visualizer/model/visual-simulator-impl.cc index 87cc2bf53f6..2748d7189aa 100644 --- a/src/visualizer/model/visual-simulator-impl.cc +++ b/src/visualizer/model/visual-simulator-impl.cc @@ -30,6 +30,7 @@ NS_OBJECT_ENSURE_REGISTERED (VisualSimulatorImpl); namespace { +/// Get an object factory configured to the default simulator implementation ObjectFactory GetDefaultSimulatorImplFactory () { diff --git a/src/visualizer/model/visual-simulator-impl.h b/src/visualizer/model/visual-simulator-impl.h index da177c51e07..d27321a175b 100644 --- a/src/visualizer/model/visual-simulator-impl.h +++ b/src/visualizer/model/visual-simulator-impl.h @@ -44,6 +44,10 @@ namespace ns3 { class VisualSimulatorImpl : public SimulatorImpl { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); VisualSimulatorImpl (); @@ -76,9 +80,9 @@ class VisualSimulatorImpl : public SimulatorImpl void NotifyConstructionCompleted (void); private: - Ptr GetSim (); - Ptr m_simulator; - ObjectFactory m_simulatorImplFactory; + Ptr GetSim (); ///< get the simulator implementation + Ptr m_simulator; ///< the simulator implementation + ObjectFactory m_simulatorImplFactory; ///< simulator implementation factory }; diff --git a/src/visualizer/visualizer/base.py b/src/visualizer/visualizer/base.py index f277ea9d306..74b2b692d0c 100644 --- a/src/visualizer/visualizer/base.py +++ b/src/visualizer/visualizer/base.py @@ -14,22 +14,44 @@ PIXELS_PER_METER = 3.0 # pixels-per-meter, at 100% zoom level +## PyVizObject class class PyVizObject(gobject.GObject): - __gtype_name__ = "PyVizObject" - + ## @var __gtype_name__ + # global type name + __gtype_name__ = "PyVizObject" + ## Returns tooltip text string. + # + ## @param tooltip: tooltip object. + ## @return: Tooltip text. def tooltip_query(self, tooltip): tooltip.set_text("TODO: tooltip for %r" % self) +## Link class class Link(PyVizObject): pass +## InformationWindow class class InformationWindow(object): + ## update function + # + ## @return: NotImplementedError exception def update(self): raise NotImplementedError +## NetDeviceTraits class class NetDeviceTraits(object): + ## class variables + ## @var is_wireless + # is wireless + ## @var is_virtual + # is virtual def __init__(self, is_wireless=None, is_virtual=False): + ''' Initialize function. + + @param is_wireless is wireless flag + @param is_virtual is virtual flag + ''' assert is_virtual or is_wireless is not None self.is_wireless = is_wireless self.is_virtual = is_virtual diff --git a/src/visualizer/visualizer/core.py b/src/visualizer/visualizer/core.py index b9b5e32b46e..2e413cfaacd 100644 --- a/src/visualizer/visualizer/core.py +++ b/src/visualizer/visualizer/core.py @@ -66,17 +66,55 @@ PI_OVER_2 = math.pi/2 PI_TIMES_2 = math.pi*2 +## Node class class Node(PyVizObject): - + ## @var visualizer + # visualier object + ## @var node_index + # node index + ## @var canvas_item + # canvas item + ## @var links + # links + ## @var _has_mobility + # has mobility model + ## @var _selected + # is selected + ## @var _highlighted + # is highlighted + ## @var _color + # color + ## @var _size + # size + ## @var menu + # menu + ## @var svg_item + # svg item + ## @var svg_align_x + # svg align X + ## @var svg_align_y + # svg align Y + ## @var _label + # label + ## @var _label_canvas_item + # label canvas + ## @var selected + # selected property + ## @var highlighted + # highlighted property + ## @var __gsignals__ + # signal emitted whenever a tooltip is about to be shown for the node + # the first signal parameter is a python list of strings, to which information can be appended __gsignals__ = { - - # signal emitted whenever a tooltip is about to be shown for the node - # the first signal parameter is a python list of strings, to which information can be appended 'query-extra-tooltip-info': (gobject.SIGNAL_RUN_LAST, None, (object,)), - } def __init__(self, visualizer, node_index): + """ Initialize function. + @param self The object pointer. + @param visualizer: visualizer object + @param node_index: node index + """ super(Node, self).__init__() self.visualizer = visualizer @@ -101,7 +139,7 @@ def __init__(self, visualizer, node_index): self._update_appearance() # call this last def set_svg_icon(self, file_base_name, width=None, height=None, align_x=0.5, align_y=0.5): - """ + """! Set a background SVG icon for the node. @param file_base_name: base file name, including .svg @@ -109,7 +147,7 @@ def set_svg_icon(self, file_base_name, width=None, height=None, align_x=0.5, ali src/contrib/visualizer/resource. @param width: scale to the specified width, in meters - @param width: scale to the specified height, in meters + @param height: scale to the specified height, in meters @param align_x: horizontal alignment of the icon relative to the node position, from 0 (icon fully to the left of the node) @@ -119,6 +157,8 @@ def set_svg_icon(self, file_base_name, width=None, height=None, align_x=0.5, ali node position, from 0 (icon fully to the top of the node) to 1.0 (icon fully to the bottom of the node) + @return a ValueError exception if invalid dimensions. + """ if width is None and height is None: raise ValueError("either width or height must be given") @@ -145,11 +185,27 @@ def set_svg_icon(self, file_base_name, width=None, height=None, align_x=0.5, ali self._update_appearance() def set_label(self, label): + """! + Set a label for the node. + + @param self: class object. + @param label: label to set + + @return: an exception if invalid parameter. + """ assert isinstance(label, basestring) self._label = label self._update_appearance() def _update_svg_position(self, x, y): + """! + Update svg position. + + @param self: class object. + @param x: x position + @param y: y position + @return none + """ w = self.svg_item.width h = self.svg_item.height self.svg_item.set_properties(x=(x - (1-self.svg_align_x)*w), @@ -157,6 +213,13 @@ def _update_svg_position(self, x, y): def tooltip_query(self, tooltip): + """! + Query tooltip. + + @param self: class object. + @param tooltip: tooltip + @return none + """ self.visualizer.simulation.lock.acquire() try: ns3_node = ns.network.NodeList.GetNode(self.node_index) @@ -212,30 +275,88 @@ def tooltip_query(self, tooltip): self.visualizer.simulation.lock.release() def on_enter_notify_event(self, view, target, event): + """! + On Enter event handle. + + @param self: class object. + @param view: view + @param target: target + @param event: event + @return none + """ self.highlighted = True def on_leave_notify_event(self, view, target, event): + """! + On Leave event handle. + + @param self: class object. + @param view: view + @param target: target + @param event: event + @return none + """ self.highlighted = False def _set_selected(self, value): + """! + Set selected function. + + @param self: class object. + @param value: selected value + @return none + """ self._selected = value self._update_appearance() def _get_selected(self): + """! + Get selected function. + + @param self: class object. + @return selected status + """ return self._selected + selected = property(_get_selected, _set_selected) def _set_highlighted(self, value): + """! + Set highlighted function. + + @param self: class object. + @param value: selected value + @return none + """ self._highlighted = value self._update_appearance() def _get_highlighted(self): + """! + Get highlighted function. + + @param self: class object. + @return highlighted status + """ return self._highlighted + highlighted = property(_get_highlighted, _set_highlighted) def set_size(self, size): + """! + Set size function. + + @param self: class object. + @param size: selected size + @return none + """ self._size = size self._update_appearance() def _update_appearance(self): - """Update the node aspect to reflect the selected/highlighted state""" + """! + Update the node aspect to reflect the selected/highlighted state + + @param self: class object. + @return none + """ size = transform_distance_simulation_to_canvas(self._size) if self.svg_item is not None: @@ -271,6 +392,14 @@ def _update_appearance(self): self._update_position() def set_position(self, x, y): + """! + Set position function. + + @param self: class object. + @param x: x position + @param y: y position + @return none + """ self.canvas_item.set_property("center_x", x) self.canvas_item.set_property("center_y", y) if self.svg_item is not None: @@ -283,13 +412,32 @@ def set_position(self, x, y): self._label_canvas_item.set_properties(x=x, y=(y+self._size*3)) def get_position(self): + """! + Get position function. + + @param self: class object. + @return x and y position + """ return (self.canvas_item.get_property("center_x"), self.canvas_item.get_property("center_y")) def _update_position(self): + """! + Update position function. + + @param self: class object. + @return none + """ x, y = self.get_position() self.set_position(x, y) def set_color(self, color): + """! + Set color function. + + @param self: class object. + @param color: color to set. + @return none + """ if isinstance(color, str): color = gtk.gdk.color_parse(color) color = ((color.red>>8) << 24) | ((color.green>>8) << 16) | ((color.blue>>8) << 8) | 0xff @@ -297,15 +445,35 @@ def set_color(self, color): self._update_appearance() def add_link(self, link): + """! + Add link function. + + @param self: class object. + @param link: link to add. + @return none + """ assert isinstance(link, Link) self.links.append(link) def remove_link(self, link): + """! + Remove link function. + + @param self: class object. + @param link: link to add. + @return none + """ assert isinstance(link, Link) self.links.remove(link) @property def has_mobility(self): + """! + Has mobility function. + + @param self: class object. + @return modility option + """ if self._has_mobility is None: node = ns.network.NodeList.GetNode(self.node_index) mobility = node.GetObject(ns.mobility.MobilityModel.GetTypeId()) @@ -313,8 +481,23 @@ def has_mobility(self): return self._has_mobility +## Channel class Channel(PyVizObject): + ## @var channel + # channel + ## @var canvas_item + # canvas + ## @var links + # list of links + # def __init__(self, channel): + """! + Initializer function. + + @param self: class object. + @param channel: channel. + @return none + """ self.channel = channel self.canvas_item = goocanvas.Ellipse(radius_x=30, radius_y=30, fill_color="white", @@ -325,6 +508,14 @@ def __init__(self, channel): self.links = [] def set_position(self, x, y): + """! + Initializer function. + + @param self: class object. + @param x: x position. + @param y: y position. + @return + """ self.canvas_item.set_property("center_x", x) self.canvas_item.set_property("center_y", y) @@ -332,11 +523,33 @@ def set_position(self, x, y): link.update_points() def get_position(self): + """! + Initializer function. + + @param self: class object. + @return x / y position. + """ return (self.canvas_item.get_property("center_x"), self.canvas_item.get_property("center_y")) +## WiredLink class WiredLink(Link): + ## @var node1 + # first node + ## @var node2 + # second node + ## @var canvas_item + # canvas + # def __init__(self, node1, node2): + """! + Initializer function. + + @param self: class object. + @param node1: class object. + @param node2: class object. + @return none + """ assert isinstance(node1, Node) assert isinstance(node2, (Node, Channel)) self.node1 = node1 @@ -347,14 +560,41 @@ def __init__(self, node1, node2): self.node2.links.append(self) def update_points(self): + """! + Update points function. + + @param self: class object. + @return none + """ pos1_x, pos1_y = self.node1.get_position() pos2_x, pos2_y = self.node2.get_position() self.canvas_item.set_property("data", "M %r %r L %r %r" % (pos1_x, pos1_y, pos2_x, pos2_y)) - +## SimulationThread class SimulationThread(threading.Thread): + ## @var viz + # Visualizer object + ## @var lock + # thread lock + ## @var go + # thread event + ## @var target_time + # in seconds + ## @var quit + # quit indicator + ## @var sim_helper + # helper function + ## @var pause_messages + # pause messages def __init__(self, viz): + """! + Initializer function. + + @param self: class object. + @param viz: class object. + @return none + """ super(SimulationThread, self).__init__() assert isinstance(viz, Visualizer) self.viz = viz # Visualizer object @@ -367,6 +607,13 @@ def __init__(self, viz): self.pause_messages = [] def set_nodes_of_interest(self, nodes): + """! + Set nodes of interest function. + + @param self: class object. + @param nodes: class object. + @return + """ self.lock.acquire() try: self.sim_helper.SetNodesOfInterest(nodes) @@ -374,6 +621,12 @@ def set_nodes_of_interest(self, nodes): self.lock.release() def run(self): + """! + Initializer function. + + @param self: class object. + @return none + """ while not self.quit: #print "sim: Wait for go" self.go.wait() # wait until the main (view) thread gives us the go signal @@ -400,14 +653,25 @@ def run(self): self.lock.release() #print "sim: Release lock, loop." -# enumeration +## ShowTransmissionsMode class ShowTransmissionsMode(object): + ## @var ALL + # all + ## @var NONE + # none + ## @var SELECTED + # seleced + ## @var __slots__ + # enumeration __slots__ = [] -ShowTransmissionsMode.ALL = ShowTransmissionsMode() -ShowTransmissionsMode.NONE = ShowTransmissionsMode() -ShowTransmissionsMode.SELECTED = ShowTransmissionsMode() + ShowTransmissionsMode.ALL = ShowTransmissionsMode() + ShowTransmissionsMode.NONE = ShowTransmissionsMode() + ShowTransmissionsMode.SELECTED = ShowTransmissionsMode() +## Visualizer class Visualizer(gobject.GObject): + ## @var INSTANCE + # all INSTANCE = None if _import_error is None: @@ -429,6 +693,12 @@ class Visualizer(gobject.GObject): } def __init__(self): + """! + Initializer function. + + @param self: class object. + @return none + """ assert Visualizer.INSTANCE is None Visualizer.INSTANCE = self super(Visualizer, self).__init__() @@ -470,6 +740,13 @@ def __init__(self): plugin(self) def set_show_transmissions_mode(self, mode): + """! + Set show transmission mode. + + @param self: class object. + @param mode: mode to set. + @return none + """ assert isinstance(mode, ShowTransmissionsMode) self._show_transmissions_mode = mode if self._show_transmissions_mode == ShowTransmissionsMode.ALL: @@ -483,6 +760,12 @@ def set_show_transmissions_mode(self, mode): self.simulation.set_nodes_of_interest([self.selected_node.node_index]) def _create_advanced_controls(self): + """! + Create advanced controls. + + @param self: class object. + @return expander + """ expander = gtk.Expander("Advanced") expander.show() @@ -565,10 +848,20 @@ def node_size_changed(adj): return expander + ## PanningState class class _PanningState(object): + ## @var __slots__ + # internal variables __slots__ = ['initial_mouse_pos', 'initial_canvas_pos', 'motion_signal'] def _begin_panning(self, widget, event): + """! + Set show trnamission mode. + + @param self: class object. + @param mode: mode to set. + @return none + """ self.canvas.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR)) self._panning_state = self._PanningState() x, y, dummy = widget.window.get_pointer() @@ -579,6 +872,13 @@ def _begin_panning(self, widget, event): self._panning_state.motion_signal = self.canvas.connect("motion-notify-event", self._panning_motion) def _end_panning(self, event): + """! + End panning function. + + @param self: class object. + @param event: active event. + @return none + """ if self._panning_state is None: return self.canvas.window.set_cursor(None) @@ -586,6 +886,14 @@ def _end_panning(self, event): self._panning_state = None def _panning_motion(self, widget, event): + """! + Panning motion function. + + @param self: class object. + @param widget: widget. + @param event: event. + @return true if successful + """ assert self._panning_state is not None if event.is_hint: x, y, dummy = widget.window.get_pointer() diff --git a/src/visualizer/visualizer/higcontainer.py b/src/visualizer/visualizer/higcontainer.py index 81a925563f3..efac06e336d 100644 --- a/src/visualizer/visualizer/higcontainer.py +++ b/src/visualizer/visualizer/higcontainer.py @@ -7,15 +7,54 @@ #root_library = 'hig' - +## HIGContainer class class HIGContainer(gtk.Bin): + ## @var __title_text + # title + ## @var __title + # title + ## @var __indent + # indent + ## @var title_req + # title request + ## @var indent_req + # indent request + ## @var child + # child + ## @var child_req + # child request + ## @var requisition + # reqisition + ## @var allocation + # allocation + ## @var title_alloc + # title allocation + ## @var child_alloc + # child allocation + ## @var title_alloc.x + # allocation x + ## @var title_alloc.y + # allocation y + ## @var title_alloc.width + # allocation width + ## @var title_alloc.height + # allocation height + ## @var __gtype_name__ + # global type name __gtype_name__ = 'HIGContainer' + ## @var __gproperties__ + # global properties __gproperties__ = { 'title': (str, 'Group Title', 'the group title', '', gobject.PARAM_READWRITE|gobject.PARAM_CONSTRUCT), } def __init__(self, title=None): + """ Initializer + + @param self: this object + @param title: title + """ self.__title_text = None gtk.widget_push_composite_child() self.__title = gobject.new(gtk.Label, visible=True, xalign=0, yalign=0.5) @@ -28,6 +67,13 @@ def __init__(self, title=None): self.props.title = title def do_size_request(self, requisition): + """! + Size request function + + @param self: this object + @param requisition: requisition + @return none + """ title_req = gtk.gdk.Rectangle(0, 0, *self.__title.size_request()) indent_req = gtk.gdk.Rectangle(0, 0, *self.__indent.size_request()) if self.child is None: @@ -39,6 +85,13 @@ def do_size_request(self, requisition): requisition.width = max(title_req.width, indent_req.width + child_req.width) def do_size_allocate(self, allocation): + """! + Allocate size function + + @param self: this object + @param allocation: allocation + @return none + """ self.allocation = allocation ## title @@ -63,6 +116,15 @@ def do_size_allocate(self, allocation): self.child.size_allocate(child_alloc) def do_forall(self, internal, callback, data): + """! + For all function + + @param self: this object + @param internal: internal + @param callback: callback + @param data: data + @return none + """ if internal: callback(self.__title, data) callback(self.__indent, data) @@ -70,6 +132,14 @@ def do_forall(self, internal, callback, data): callback(self.child, data) def do_set_property(self, pspec, value): + """! + Set property function + + @param self: this object + @param pspec: internal + @param value: callback + @return AttributeError if unknown property + """ if pspec.name == 'title': self.__title.set_markup('%s' % gobject.markup_escape_text(value)) @@ -78,6 +148,13 @@ def do_set_property(self, pspec, value): raise AttributeError, 'unknown property %s' % pspec.name def do_get_property(self, pspec): + """! + Set property function + + @param self: this object + @param pspec: internal + @return title text + """ if pspec.name == 'title': return self.__title_text else: diff --git a/src/visualizer/visualizer/hud.py b/src/visualizer/visualizer/hud.py index 6040823daa3..2129cb7e002 100644 --- a/src/visualizer/visualizer/hud.py +++ b/src/visualizer/visualizer/hud.py @@ -5,8 +5,28 @@ import gtk +## Axes class class Axes(object): + ## @var viz + # visualizer + ## @var color + # color + ## @var hlines + # horizontal lines + ## @var vlines + # vertical lines + ## @var labels + # list of labels + ## @var visible + # visible def __init__(self, viz): + """! + Initializer function + + @param self: this object + @param viz: visualization object + @return none + """ self.viz = viz self.color = 0x8080C0FF self.hlines = goocanvas.Path(parent=viz.canvas.get_root_item(), stroke_color_rgba=self.color) @@ -27,6 +47,13 @@ def update(adj): self.update_view() def set_visible(self, visible): + """! + Set visible function + + @param self: this object + @param visible: visible indicator + @return none + """ self.visible = visible if self.visible: self.hlines.props.visibility = goocanvas.ITEM_VISIBLE @@ -38,6 +65,14 @@ def set_visible(self, visible): label.props.visibility = goocanvas.ITEM_HIDDEN def _compute_divisions(self, xi, xf): + """! + Compute divisions function + + @param self: this object + @param xi: xi + @param xf: xf + @return x0 and div + """ assert xf > xi dx = xf - xi size = dx @@ -45,6 +80,12 @@ def _compute_divisions(self, xi, xf): text_width = dx/ndiv/2 def rint(x): + """! + Compute divisions function + + @param x: x + @return x rounded up + """ return math.floor(x+0.5) dx_over_ndiv = dx / ndiv @@ -63,6 +104,12 @@ def rint(x): def update_view(self): + """! + Update view function + + @param self: this object + @return none + """ if self.viz.zoom is None: return @@ -71,6 +118,12 @@ def update_view(self): for label in unused_labels: label.set_property("visibility", goocanvas.ITEM_HIDDEN) def get_label(): + """! + Get label function + + @param self: this object + @return label + """ try: label = unused_labels.pop(0) except IndexError: diff --git a/src/visualizer/visualizer/ipython_view.py b/src/visualizer/visualizer/ipython_view.py index 8f281519be2..70b2a0649fe 100644 --- a/src/visualizer/visualizer/ipython_view.py +++ b/src/visualizer/visualizer/ipython_view.py @@ -26,29 +26,65 @@ try: import IPython except ImportError: + ##@ var IPython + # IPython = None +## IterableIPShell class class IterableIPShell: - def __init__(self,argv=None,user_ns=None,user_global_ns=None, + ## @var IP + # IP + ## @var iter_more + # iterate more + ## @var history_level + # history level + ## @var complete_sep + # separators + ## @var prompt + # prompt + ## @var header + # header + ## @var config + # config + ## @var user_ns + # user_ns + ## @var old_stdout + # saved stdout + ## @var old_stderr + # saved stderr + ## @var system + # system + ## @var cfg + # configuration + ## @var colors + # colors + ## @var raw_input_original + # original raw input + ## @var stdin + # cin + ## @var stdout + # cout + ## @var stderr + # cerr + ## @var raw_input + # raw input + ## @var excepthook + # exception hook + ## Constructor + def __init__(self,argv=None,user_ns=None,user_global_ns=None, cin=None, cout=None,cerr=None, input_func=None): - ''' - + """! Initializer + @param self: this object @param argv: Command line options for IPython - @type argv: list @param user_ns: User namespace. - @type user_ns: dictionary @param user_global_ns: User global namespace. - @type user_global_ns: dictionary. @param cin: Console standard input. - @type cin: IO stream @param cout: Console standard output. - @type cout: IO stream @param cerr: Console standard error. - @type cerr: IO stream @param input_func: Replacement for builtin raw_input() - @type input_func: function - ''' + @return none + """ io = IPython.utils.io if input_func: if parse_version(IPython.release.version) >= parse_version("1.2.1"): @@ -110,17 +146,17 @@ def __init__(self,argv=None,user_ns=None,user_global_ns=None, self.__update_namespace() def __update_namespace(self): - ''' + """! Update self.IP namespace for autocompletion with sys.modules - ''' + """ for k, v in list(sys.modules.items()): if not '.' in k: self.IP.user_ns.update({k:v}) def execute(self): - ''' + """! Executes the current line provided by the shell object. - ''' + """ self.history_level = 0 orig_stdout = sys.stdout sys.stdout = IPython.utils.io.stdout @@ -169,16 +205,13 @@ def execute(self): sys.stdin = orig_stdin def generatePrompt(self, is_continuation): - ''' + """! Generate prompt depending on is_continuation value @param is_continuation - @type is_continuation: boolean - @return: The prompt string representation - @rtype: string - ''' + """ # Backwards compatibility with ipyton-0.11 # @@ -195,35 +228,35 @@ def generatePrompt(self, is_continuation): def historyBack(self): - ''' + """! Provides one history command back. + @param self this object @return: The command string. - @rtype: string - ''' + """ self.history_level -= 1 if not self._getHistory(): self.history_level +=1 return self._getHistory() def historyForward(self): - ''' + """! Provides one history command forward. + @param self this object @return: The command string. - @rtype: string - ''' + """ if self.history_level < 0: self.history_level += 1 return self._getHistory() def _getHistory(self): - ''' + """! Get's the command string of the current history level. + @param self this object @return: Historic command string. - @rtype: string - ''' + """ try: rv = self.IP.user_ns['In'][self.history_level].strip('\n') except IndexError: @@ -231,25 +264,21 @@ def _getHistory(self): return rv def updateNamespace(self, ns_dict): - ''' + """! Add the current dictionary to the shell namespace. @param ns_dict: A dictionary of symbol-values. - @type ns_dict: dictionary - ''' + @return none + """ self.IP.user_ns.update(ns_dict) def complete(self, line): - ''' + """! Returns an auto completed line and/or posibilities for completion. @param line: Given line so far. - @type line: string - - @return: Line completed as for as possible, - and possible further completions. - @rtype: tuple - ''' + @return: Line completed as for as possible, and possible further completions. + """ split_line = self.complete_sep.split(line) if split_line[-1]: possibilities = self.IP.complete(split_line[-1]) @@ -258,17 +287,13 @@ def complete(self, line): possibilities = ['', []] if possibilities: def _commonPrefix(str1, str2): - ''' + """! Reduction function. returns common prefix of two given strings. @param str1: First string. - @type str1: string @param str2: Second string - @type str2: string - @return: Common prefix to both strings. - @rtype: string - ''' + """ for i in range(len(str1)): if not str2.startswith(str1[:i+1]): return str1[:i] @@ -284,18 +309,15 @@ def _commonPrefix(str1, str2): def shell(self, cmd,verbose=0,debug=0,header=''): - ''' + """! Replacement method to allow shell commands without them blocking. @param cmd: Shell command to execute. - @type cmd: string @param verbose: Verbosity - @type verbose: integer @param debug: Debug level - @type debug: integer @param header: Header to be printed before output - @type header: string - ''' + @return none + """ stat = 0 if verbose or debug: print header+cmd # flush stdout so we don't mangle python's buffering @@ -305,8 +327,19 @@ def shell(self, cmd,verbose=0,debug=0,header=''): output.close() input.close() +## ConsoleView class class ConsoleView(gtk.TextView): - ''' + ## @var ANSI_COLORS + # color list + ## @var text_buffer + # text buffer + ## @var mark + # scroll mark + ## @var color_pat + # color pattern + ## @var line_start + # line start + """ Specialized text view for console-like workflow. @cvar ANSI_COLORS: Mapping of terminal colors to X11 names. @@ -320,7 +353,7 @@ class ConsoleView(gtk.TextView): @type mark: gtk.TextMark @ivar line_start: Start of command line mark. @type line_start: gtk.TextMark - ''' + """ ANSI_COLORS = {'0;30': 'Black', '0;31': 'Red', '0;32': 'Green', '0;33': 'Brown', '0;34': 'Blue', '0;35': 'Purple', @@ -331,9 +364,9 @@ class ConsoleView(gtk.TextView): '1;36': 'LightCyan', '1;37': 'White'} def __init__(self): - ''' + """ Initialize console view. - ''' + """ gtk.TextView.__init__(self) self.modify_font(pango.FontDescription('Mono')) self.set_cursor_visible(True) @@ -354,17 +387,23 @@ def __init__(self): self.connect('key-press-event', self.onKeyPress) def write(self, text, editable=False): + """! + Write given text to buffer. + + @param text: Text to append. + @param editable: If true, added text is editable. + @return none + """ gobject.idle_add(self._write, text, editable) def _write(self, text, editable=False): - ''' + """! Write given text to buffer. @param text: Text to append. - @type text: string @param editable: If true, added text is editable. - @type editable: boolean - ''' + @return none + """ segments = self.color_pat.split(text) segment = segments.pop(0) start_mark = self.text_buffer.create_mark(None, @@ -387,56 +426,73 @@ def _write(self, text, editable=False): self.scroll_mark_onscreen(self.mark) def showPrompt(self, prompt): + """! + Prints prompt at start of line. + + @param prompt: Prompt to print. + @return none + """ gobject.idle_add(self._showPrompt, prompt) def _showPrompt(self, prompt): - ''' + """! Prints prompt at start of line. @param prompt: Prompt to print. - @type prompt: string - ''' + @return none + """ self._write(prompt) self.text_buffer.move_mark(self.line_start, self.text_buffer.get_end_iter()) def changeLine(self, text): + """! + Replace currently entered command line with given text. + + @param text: Text to use as replacement. + @return none + """ gobject.idle_add(self._changeLine, text) def _changeLine(self, text): - ''' + """! Replace currently entered command line with given text. @param text: Text to use as replacement. - @type text: string - ''' + @return none + """ iter = self.text_buffer.get_iter_at_mark(self.line_start) iter.forward_to_line_end() self.text_buffer.delete(self.text_buffer.get_iter_at_mark(self.line_start), iter) self._write(text, True) def getCurrentLine(self): - ''' + """! Get text in current command line. - @return: Text of current command line. - @rtype: string - ''' + @return Text of current command line. + """ rv = self.text_buffer.get_slice( self.text_buffer.get_iter_at_mark(self.line_start), self.text_buffer.get_end_iter(), False) return rv def showReturned(self, text): + """! + Show returned text from last command and print new prompt. + + @param text: Text to show. + @return none + """ gobject.idle_add(self._showReturned, text) def _showReturned(self, text): - ''' + """! Show returned text from last command and print new prompt. @param text: Text to show. - @type text: string - ''' + @return none + """ iter = self.text_buffer.get_iter_at_mark(self.line_start) iter.forward_to_line_end() self.text_buffer.apply_tag_by_name( @@ -455,19 +511,15 @@ def _showReturned(self, text): self.text_buffer.insert_at_cursor(indentation) def onKeyPress(self, widget, event): - ''' + """! Key press callback used for correcting behavior for console-like interfaces. For example 'home' should go to prompt, not to begining of line. @param widget: Widget that key press accored in. - @type widget: gtk.Widget @param event: Event object - @type event: gtk.gdk.Event - - @return: Return True if event should not trickle. - @rtype: boolean - ''' + @return Return True if event should not trickle. + """ insert_mark = self.text_buffer.get_insert() insert_iter = self.text_buffer.get_iter_at_mark(insert_mark) selection_mark = self.text_buffer.get_selection_bound() @@ -502,20 +554,37 @@ def onKeyPress(self, widget, event): return self.onKeyPressExtend(event) def onKeyPressExtend(self, event): - ''' + """! For some reason we can't extend onKeyPress directly (bug #500900). - ''' + @param event key press + @return none + """ pass +## IPythonView class class IPythonView(ConsoleView, IterableIPShell): - ''' + ## @var cout + # cout + ## @var interrupt + # interrupt + ## @var execute + # execute + ## @var prompt + # prompt + ## @var showPrompt + # show prompt + ## @var history_pos + # history list + ## @var window + # GTK Window + """ Sub-class of both modified IPython shell and L{ConsoleView} this makes a GTK+ IPython console. - ''' + """ def __init__(self): - ''' + """ Initialize. Redirect I/O to console. - ''' + """ ConsoleView.__init__(self) self.cout = StringIO() IterableIPShell.__init__(self, cout=self.cout,cerr=self.cout, @@ -527,33 +596,25 @@ def __init__(self): self.showPrompt(self.prompt) def raw_input(self, prompt=''): - ''' + """! Custom raw_input() replacement. Get's current line from console buffer. @param prompt: Prompt to print. Here for compatability as replacement. - @type prompt: string - - @return: The current command line text. - @rtype: string - ''' + @return The current command line text. + """ if self.interrupt: self.interrupt = False raise KeyboardInterrupt return self.getCurrentLine() def onKeyPressExtend(self, event): - ''' + """! Key press callback with plenty of shell goodness, like history, autocompletions, etc. - @param widget: Widget that key press occured in. - @type widget: gtk.Widget @param event: Event object. - @type event: gtk.gdk.Event - - @return: True if event should not trickle. - @rtype: boolean - ''' + @return True if event should not trickle. + """ if event.state & gtk.gdk.CONTROL_MASK and event.keyval == 99: self.interrupt = True @@ -582,9 +643,10 @@ def onKeyPressExtend(self, event): return True def _processLine(self): - ''' + """! Process current command line. - ''' + @return none + """ self.history_pos = 0 self.execute() rv = self.cout.getvalue() diff --git a/src/visualizer/visualizer/plugins/interface_statistics.py b/src/visualizer/visualizer/plugins/interface_statistics.py index 1cb0ef57381..25ebe2d3217 100644 --- a/src/visualizer/visualizer/plugins/interface_statistics.py +++ b/src/visualizer/visualizer/plugins/interface_statistics.py @@ -6,20 +6,39 @@ NODE_STATISTICS_MEMORY = 10 +## StatisticsCollector class class StatisticsCollector(object): """ Collects interface statistics for all nodes. """ + ## @var node_statistics + # node statistics + ## @var visualizer + # visualizer + ## NetDevStats class class NetDevStats(object): + ## @var __slots__ + # class members __slots__ = ['rxPackets', 'rxBytes', 'txPackets', 'txBytes', 'rxPacketRate', 'rxBitRate', 'txPacketRate', 'txBitRate'] def __init__(self, visualizer): + """ + Collects interface statistics for all nodes. + @param self this object + @param visualizer visualizer object + """ self.node_statistics = {} # nodeid -> list(raw statistics) self.visualizer = visualizer def simulation_periodic_update(self, viz): + """! + Simulation Periodic Update function. + @param self this object + @param viz visualizer object + @return none + """ nodes_statistics = viz.simulation.sim_helper.GetNodesStatistics() for stats in nodes_statistics: try: @@ -32,6 +51,12 @@ def simulation_periodic_update(self, viz): raw_stats_list.pop(0) def get_interface_statistics(self, nodeId): + """! + Get interface statistics function. + @param self this object + @param nodeId node ID + @return the statistics + """ try: raw_stats_list = self.node_statistics[nodeId] except KeyError: @@ -68,7 +93,20 @@ def get_interface_statistics(self, nodeId): return retval +## ShowInterfaceStatistics class class ShowInterfaceStatistics(InformationWindow): + ## @var win + # window + ## @var visualizer + # visualizer + ## @var statistics_collector + # statistics collector + ## @var node_index + # node index + ## @var viz_node + # visualizer node + ## @var table_model + # table model ( COLUMN_INTERFACE, @@ -85,6 +123,13 @@ class ShowInterfaceStatistics(InformationWindow): ) = range(9) def __init__(self, visualizer, node_index, statistics_collector): + """ + Initializer. + @param self this object + @param visualizer the visualizer object + @param node_index the node index + @param statistics_collector statistics collector class + """ InformationWindow.__init__(self) self.win = gtk.Dialog(parent=visualizer.window, flags=gtk.DIALOG_DESTROY_WITH_PARENT|gtk.DIALOG_NO_SEPARATOR, @@ -122,10 +167,22 @@ def add_column(descr, colid): self.win.show() def _response_cb(self, win, response): + """! + Response callback function. + @param self this object + @param win the window + @param response the response + @return none + """ self.win.destroy() self.visualizer.remove_information_window(self) def update(self): + """! + Update function. + @param self this object + @return none + """ node = ns.network.NodeList.GetNode(self.node_index) stats_list = self.statistics_collector.get_interface_statistics(self.node_index) self.table_model.clear() diff --git a/src/visualizer/visualizer/plugins/ipv4_routing_table.py b/src/visualizer/visualizer/plugins/ipv4_routing_table.py index 134e7d795c4..b186acd249a 100644 --- a/src/visualizer/visualizer/plugins/ipv4_routing_table.py +++ b/src/visualizer/visualizer/plugins/ipv4_routing_table.py @@ -6,7 +6,16 @@ from visualizer.base import InformationWindow +## ShowIpv4RoutingTable class class ShowIpv4RoutingTable(InformationWindow): + ## @var win + # window + ## @var visualizer + # visualizer + ## @var node_index + # node index + ## @var table_model + # table model ( COLUMN_DESTINATION, COLUMN_NEXT_HOP, @@ -16,6 +25,13 @@ class ShowIpv4RoutingTable(InformationWindow): ) = range(5) def __init__(self, visualizer, node_index): + """ + Initializer + @param self this object + @param visualizer visualizer object + @param node_index the node index + @return the statistics + """ InformationWindow.__init__(self) self.win = gtk.Dialog(parent=visualizer.window, flags=gtk.DIALOG_DESTROY_WITH_PARENT|gtk.DIALOG_NO_SEPARATOR, @@ -66,10 +82,22 @@ def __init__(self, visualizer, node_index): self.win.show() def _response_cb(self, win, response): + """! + Response callback function + @param self this object + @param win the window + @param response the response + @return none + """ self.win.destroy() self.visualizer.remove_information_window(self) def update(self): + """! + Update function + @param self this object + @return none + """ node = ns.network.NodeList.GetNode(self.node_index) ipv4 = node.GetObject(ns.internet.Ipv4.GetTypeId()) routing = ipv4.GetRoutingProtocol() diff --git a/src/visualizer/visualizer/plugins/olsr.py b/src/visualizer/visualizer/plugins/olsr.py index b5752c8f3a4..ba36145b9c4 100644 --- a/src/visualizer/visualizer/plugins/olsr.py +++ b/src/visualizer/visualizer/plugins/olsr.py @@ -7,7 +7,16 @@ from visualizer.base import InformationWindow +## ShowOlsrRoutingTable class class ShowOlsrRoutingTable(InformationWindow): + ## @var win + # window + ## @var visualizer + # visualizer + ## @var node_index + # node index + ## @var table_model + # table model ( COLUMN_DESTINATION, COLUMN_NEXT_HOP, @@ -16,6 +25,13 @@ class ShowOlsrRoutingTable(InformationWindow): ) = range(4) def __init__(self, visualizer, node_index): + """! + Initializer + @param self this object + @param visualizer visualizer object + @param node_index the node index + @return none + """ InformationWindow.__init__(self) self.win = gtk.Dialog(parent=visualizer.window, flags=gtk.DIALOG_DESTROY_WITH_PARENT|gtk.DIALOG_NO_SEPARATOR, @@ -61,10 +77,22 @@ def __init__(self, visualizer, node_index): self.win.show() def _response_cb(self, win, response): + """! + Initializer + @param self this object + @param win the window + @param response the response + @return none + """ self.win.destroy() self.visualizer.remove_information_window(self) def update(self): + """! + Update function + @param self this object + @return none + """ node = ns.network.NodeList.GetNode(self.node_index) olsr = node.GetObject(ns.olsr.olsr.RoutingProtocol.GetTypeId()) ipv4 = node.GetObject(ns.internet.Ipv4.GetTypeId()) diff --git a/src/visualizer/visualizer/plugins/show_last_packets.py b/src/visualizer/visualizer/plugins/show_last_packets.py index 8971dfc18c4..6678cb40f3b 100644 --- a/src/visualizer/visualizer/plugins/show_last_packets.py +++ b/src/visualizer/visualizer/plugins/show_last_packets.py @@ -9,8 +9,38 @@ from visualizer.higcontainer import HIGContainer from kiwi.ui.objectlist import ObjectList, Column +## ShowLastPackets class class ShowLastPackets(InformationWindow): + ## @var win + # window + ## @var visualizer + # visualizer + ## @var viz_node + # visualizer node + ## @var node + # the node + ## @var tx_list + # packet transmit list + ## @var rx_list + # packet receive list + ## @var drop_list + # packet drop list + ## @var packet_capture_options + # packet capture options + ## @var packet_filter_widget + # packet filter widget + ## @var packet_filter_list + # list of TypeIdConfig instances + ## @var op_AND_button + # AND button + ## @var op_OR_button + # OR button class PacketList(gtk.ScrolledWindow): + """ + PacketList class + """ + ## @var table_model + # table model ( COLUMN_TIME, COLUMN_INTERFACE, @@ -19,6 +49,10 @@ class PacketList(gtk.ScrolledWindow): ) = range(4) def __init__(self): + """ + Initializer + @param self this object + """ super(ShowLastPackets.PacketList, self).__init__() self.set_properties(hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_AUTOMATIC) @@ -37,6 +71,13 @@ def add_column(descr, colid): add_column("Contents", self.COLUMN_CONTENTS) def update(self, node, packet_list): + """! + Update function + @param self this object + @param node the node + @param packet_list packet list + @return none + """ self.table_model.clear() for sample in packet_list: tree_iter = self.table_model.append() @@ -55,6 +96,12 @@ def update(self, node, packet_list): def __init__(self, visualizer, node_index): + """ + Initializer + @param self this object + @param visualizer the visualizer object + @param node_index the node index + """ InformationWindow.__init__(self) self.win = gtk.Dialog(parent=visualizer.window, flags=gtk.DIALOG_DESTROY_WITH_PARENT|gtk.DIALOG_NO_SEPARATOR, @@ -210,10 +257,22 @@ def cell_edited(l, obj, attribute): self.win.show() def _response_cb(self, win, response): + """! + Response callback function + @param self this object + @param win the window + @param response the response + @return none + """ self.win.destroy() self.visualizer.remove_information_window(self) def update(self): + """! + Update function + @param self this object + @return none + """ last_packets = self.visualizer.simulation.sim_helper.GetLastPackets(self.node.GetId()) self.tx_list.update(self.node, last_packets.lastTransmittedPackets) diff --git a/src/visualizer/visualizer/plugins/wifi_intrastructure_link.py b/src/visualizer/visualizer/plugins/wifi_intrastructure_link.py index f48df8e8c5d..b3791614ac8 100644 --- a/src/visualizer/visualizer/plugins/wifi_intrastructure_link.py +++ b/src/visualizer/visualizer/plugins/wifi_intrastructure_link.py @@ -4,8 +4,27 @@ import goocanvas from visualizer.base import Link, transform_distance_canvas_to_simulation +## WifiLink class class WifiLink(Link): + ## @var node1 + # sta + ## @var dev + # dev + ## @var node2 + # ap + ## @var canvas_item + # parent_canvas_item + ## @var invisible_line + # invisible line + ## @var visible_line + # visible line def __init__(self, parent_canvas_item, sta, dev): + """! Initialize function. + @param self The object pointer. + @param parent_canvas_item: parent canvas + @param sta The STA node + @param dev The dev + """ self.node1 = sta self.dev = dev self.node2 = None # ap @@ -25,6 +44,11 @@ def __init__(self, parent_canvas_item, sta, dev): self.set_ap(None) def set_ap(self, ap): + """! Set AP. + @param self The object pointer. + @param ap The AP node + @return none + """ if ap is self.node2: return if self.node2 is not None: @@ -38,6 +62,10 @@ def set_ap(self, ap): self.update_points() def update_points(self): + """! Update points function. + @param self The object pointer. + @return none + """ if self.node2 is None: return pos1_x, pos1_y = self.node1.get_position() @@ -47,11 +75,20 @@ def update_points(self): self.invisible_line.set_property("points", points) def destroy(self): + """! Destroy function. + @param self The object pointer. + @return none + """ self.canvas_item.destroy() self.node1 = None self.node2 = None def tooltip_query(self, tooltip): + """! Destroy function. + @param self The object pointer. + @param tooltip The tooltip. + @return tooltip + """ pos1_x, pos1_y = self.node1.get_position() pos2_x, pos2_y = self.node2.get_position() dx = pos2_x - pos1_x @@ -64,13 +101,27 @@ def tooltip_query(self, tooltip): % (self.node1.node_index, self.node2.node_index, d, mac.GetSsid(), mac.GetBssid())) - +## WifiLinkMonitor class class WifiLinkMonitor(object): + ## @var access_points + # bssid -> node + ## @var stations + # list of (sta_netdevice, viz_node, wifi_link) def __init__(self, dummy_viz): + """! Initialize function. + @param self The object pointer. + @param dummy_viz A dummy visualizer + @return none + """ self.access_points = {} # bssid -> node self.stations = [] # list of (sta_netdevice, viz_node, wifi_link) def scan_nodes(self, viz): + """! Scan nodes function. + @param self The object pointer. + @param viz The visualizer object + @return none + """ for (sta_netdevice, viz_node, wifi_link) in self.stations: wifi_link.destroy() @@ -94,6 +145,11 @@ def scan_nodes(self, viz): #print "STAs: ", self.stations def simulation_periodic_update(self, viz): + """! Simulation Periodic Update function. + @param self The object pointer. + @param viz The visualizer object + @return none + """ for (sta_netdevice, viz_node, wifi_link) in self.stations: if not sta_netdevice.IsLinkUp(): wifi_link.set_ap(None) @@ -106,6 +162,11 @@ def simulation_periodic_update(self, viz): wifi_link.set_ap(ap) def update_view(self, viz): + """! Update View function. + @param self The object pointer. + @param viz The visualizer object + @return none + """ for (dummy_sta_netdevice, dummy_viz_node, wifi_link) in self.stations: if wifi_link is not None: wifi_link.update_points() diff --git a/src/visualizer/visualizer/svgitem.py b/src/visualizer/visualizer/svgitem.py index d3591564db6..0d71ca5485e 100644 --- a/src/visualizer/visualizer/svgitem.py +++ b/src/visualizer/visualizer/svgitem.py @@ -5,7 +5,35 @@ import os.path +## SvgItem class class SvgItem(goocanvas.ItemSimple): + ## @var x + # x + ## @var y + # y + ## @var sx + # x step + ## @var sy + # y step + ## @var handle + # handle + ## @var width + # width + ## @var height + # height + ## @var custom_width + # custom width + ## @var custom_height + # custom height + ## @var bounds_x1 + # minimum x + ## @var bounds_y1 + # minimum y + ## @var bounds_x2 + # maximum x + ## @var bounds_y2 + # maximum y + ## @var __gproperties__ # setup our custom properties __gproperties__ = { 'x': (float, # property type @@ -42,6 +70,10 @@ class SvgItem(goocanvas.ItemSimple): } def __init__(self, x, y, rsvg_handle, **kwargs): + """ + Initializer + @param self this object + """ super(SvgItem, self).__init__(**kwargs) assert isinstance(rsvg_handle, rsvg.Handle) self.x = x @@ -55,6 +87,13 @@ def __init__(self, x, y, rsvg_handle, **kwargs): self.custom_height = None def do_set_property(self, pspec, value): + """! + Set Property + @param self this object + @param pspec property name + @param value property value + @return exception if unknown property + """ if pspec.name == 'x': self.x = value @@ -85,6 +124,11 @@ def do_set_property(self, pspec, value): raise AttributeError, 'unknown property %s' % pspec.name def _size_changed(self): + """! + Size Changed function + @param self this object + @return exception if unknown property + """ if self.custom_width is None and self.custom_height is None: self.width = self.handle.props.width self.height = self.handle.props.height @@ -107,6 +151,12 @@ def _size_changed(self): self.sy = self.custom_height / self.handle.props.height def do_get_property(self, pspec): + """! + Get Property + @param self this object + @param pspec property name + @return property value or exception if unknown property + """ if pspec.name == 'x': return self.x @@ -126,17 +176,39 @@ def do_get_property(self, pspec): raise AttributeError, 'unknown property %s' % pspec.name def do_simple_paint(self, cr, bounds): + """! + Simple Paint function + @param self this object + @param cr rendered + @param bounds bounds + @return none + """ cr.translate(self.x, self.y) cr.scale(self.sx, self.sy) self.handle.render_cairo(cr) def do_simple_update(self, cr): + """! + Simple Update function + @param self this object + @param cr rendered + @return none + """ self.bounds_x1 = float(self.x) self.bounds_y1 = float(self.y) self.bounds_x2 = float(self.x + self.width) self.bounds_y2 = float(self.y + self.height) def do_simple_is_item_at(self, x, y, cr, is_pointer_event): + """! + Simple Is Item At function + @param self this object + @param x the X position + @param y the Y position + @param cr rendered + @param is_pointer_event is the event a pointer event + @return true if at or false if not + """ if ((x < self.x) or (x > self.x + self.width)) or ((y < self.y) or (y > self.y + self.height)): return False else: From 5710d7cb3307b3a982e8249fcf784e216fdedba7 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Wed, 26 Apr 2017 19:48:43 +0200 Subject: [PATCH 019/551] wifi: (fixes #1034) WifiMac::m_macTxDropTrace is fed with packets dropped in the wifi MAC queues --- RELEASE_NOTES | 1 + src/wifi/model/ap-wifi-mac.cc | 4 ++++ src/wifi/model/dca-txop.cc | 17 +++++++++++++++++ src/wifi/model/dca-txop.h | 19 +++++++++++++++++++ src/wifi/model/regular-wifi-mac.cc | 2 ++ src/wifi/model/wifi-mac.cc | 2 +- 6 files changed, 44 insertions(+), 1 deletion(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 39cd67fab50..eb4052b54ab 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -34,6 +34,7 @@ New user-visible features Bugs fixed ---------- +- Bug 1034 - No trace source for packet dropping from WifiMacQueue - Bug 2007 - uan: Remove deprecation on SetRxThresholdDb - Bug 2214 - tcp: Use of ScheduleNow only in selected part of the code - Bug 2221 - network: Remove constraint on size of ns3::Packet Tag objects diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index 35b3f7da459..e3f467bbe95 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -352,6 +352,10 @@ ApWifiMac::Enqueue (Ptr packet, Mac48Address to, Mac48Address from { ForwardDown (packet, from, to); } + else + { + NotifyTxDrop (packet); + } } void diff --git a/src/wifi/model/dca-txop.cc b/src/wifi/model/dca-txop.cc index 5a8231efc6d..1f418ccf6e2 100644 --- a/src/wifi/model/dca-txop.cc +++ b/src/wifi/model/dca-txop.cc @@ -142,6 +142,23 @@ DcaTxop::SetTxFailedCallback (TxFailed callback) m_txFailedCallback = callback; } +void +DcaTxop::SetTxDroppedCallback (TxDropped callback) +{ + NS_LOG_FUNCTION (this << &callback); + m_txDroppedCallback = callback; + m_queue->TraceConnectWithoutContext ("Drop", MakeCallback (&DcaTxop::TxDroppedPacket, this)); +} + +void +DcaTxop::TxDroppedPacket (Ptr item) +{ + if (!m_txDroppedCallback.IsNull ()) + { + m_txDroppedCallback (item->GetPacket ()); + } +} + Ptr DcaTxop::GetQueue () const { diff --git a/src/wifi/model/dca-txop.h b/src/wifi/model/dca-txop.h index 05ee4055df3..63e696304f6 100644 --- a/src/wifi/model/dca-txop.h +++ b/src/wifi/model/dca-txop.h @@ -80,6 +80,11 @@ class DcaTxop : public Object * packet transmission was failed. */ typedef Callback TxFailed; + /** + * typedef for a callback to invoke when a + * packet is dropped. + */ + typedef Callback > TxDropped; /** * Check for EDCA. @@ -123,6 +128,11 @@ class DcaTxop : public Object * packet transmission was completed unsuccessfully. */ void SetTxFailedCallback (TxFailed callback); + /** + * \param callback the callback to invoke when a + * packet is dropped. + */ + void SetTxDroppedCallback (TxDropped callback); /** * Return the MacLow associated with this DcaTxop. @@ -382,11 +392,20 @@ class DcaTxop : public Object * false otherwise. */ virtual bool IsLastFragment (void) const; + /** + * + * Pass the packet included in the wifi MAC queue item to the + * packet dropped callback. + * + * \param item the wifi MAC queue item. + */ + void TxDroppedPacket (Ptr item); DcfState *m_dcf; //!< the DCF state DcfManager *m_manager; //!< the DCF manager TxOk m_txOkCallback; //!< the transmit OK callback TxFailed m_txFailedCallback; //!< the transmit failed callback + TxDropped m_txDroppedCallback; //!< the packet dropped callback Ptr m_queue; //!< the wifi MAC queue MacTxMiddle *m_txMiddle; //!< the MacTxMiddle Ptr m_low; //!< the MacLow diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index 1ed04007dd8..c1753d5023d 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -59,6 +59,7 @@ RegularWifiMac::RegularWifiMac () m_dca->SetTxMiddle (m_txMiddle); m_dca->SetTxOkCallback (MakeCallback (&RegularWifiMac::TxOk, this)); m_dca->SetTxFailedCallback (MakeCallback (&RegularWifiMac::TxFailed, this)); + m_dca->SetTxDroppedCallback (MakeCallback (&RegularWifiMac::NotifyTxDrop, this)); //Construct the EDCAFs. The ordering is important - highest //priority (Table 9-1 UP-to-AC mapping; IEEE 802.11-2012) must be created @@ -425,6 +426,7 @@ RegularWifiMac::SetupEdcaQueue (AcIndex ac) edca->SetTxMiddle (m_txMiddle); edca->SetTxOkCallback (MakeCallback (&RegularWifiMac::TxOk, this)); edca->SetTxFailedCallback (MakeCallback (&RegularWifiMac::TxFailed, this)); + edca->SetTxDroppedCallback (MakeCallback (&RegularWifiMac::NotifyTxDrop, this)); edca->SetAccessCategory (ac); edca->CompleteConfig (); diff --git a/src/wifi/model/wifi-mac.cc b/src/wifi/model/wifi-mac.cc index abd2dd19ca3..f8ea68b4bbe 100644 --- a/src/wifi/model/wifi-mac.cc +++ b/src/wifi/model/wifi-mac.cc @@ -209,7 +209,7 @@ WifiMac::GetTypeId (void) MakeTraceSourceAccessor (&WifiMac::m_macTxTrace), "ns3::Packet::TracedCallback") .AddTraceSource ("MacTxDrop", - "A packet has been dropped in the MAC layer before being queued for transmission.", + "A packet has been dropped in the MAC layer before transmission.", MakeTraceSourceAccessor (&WifiMac::m_macTxDropTrace), "ns3::Packet::TracedCallback") .AddTraceSource ("MacPromiscRx", From 855987401ede9d3e979d68a032de8ebf3f0e7a5f Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Wed, 26 Apr 2017 11:42:11 -0700 Subject: [PATCH 020/551] netanim: Correct Doxygen warnings --- .../examples/colors-link-description.cc | 7 +- src/netanim/examples/resources-counters.cc | 7 +- src/netanim/examples/uan-animation.h | 48 +- src/netanim/model/animation-interface.cc | 2 +- src/netanim/model/animation-interface.h | 1048 +++++++++++++---- src/netanim/test/netanim-test.cc | 56 +- 6 files changed, 932 insertions(+), 236 deletions(-) diff --git a/src/netanim/examples/colors-link-description.cc b/src/netanim/examples/colors-link-description.cc index fd5757e24cf..45c6cfae046 100644 --- a/src/netanim/examples/colors-link-description.cc +++ b/src/netanim/examples/colors-link-description.cc @@ -30,10 +30,11 @@ using namespace ns3; AnimationInterface * pAnim = 0; +/// RGB structure struct rgb { - uint8_t r; - uint8_t g; - uint8_t b; + uint8_t r; ///< red + uint8_t g; ///< green + uint8_t b; ///< blue }; struct rgb colors [] = { diff --git a/src/netanim/examples/resources-counters.cc b/src/netanim/examples/resources-counters.cc index 60885307d11..ba01f106b8e 100644 --- a/src/netanim/examples/resources-counters.cc +++ b/src/netanim/examples/resources-counters.cc @@ -30,10 +30,11 @@ using namespace ns3; AnimationInterface * pAnim = 0; +/// RGB struture struct rgb { - uint8_t r; - uint8_t g; - uint8_t b; + uint8_t r; ///< red + uint8_t g; ///< green + uint8_t b; ///< blue }; struct rgb colors [] = { diff --git a/src/netanim/examples/uan-animation.h b/src/netanim/examples/uan-animation.h index 3060baf4541..7ac8ca8bab4 100644 --- a/src/netanim/examples/uan-animation.h +++ b/src/netanim/examples/uan-animation.h @@ -34,27 +34,45 @@ using namespace ns3; class NetAnimExperiment { public: + /** + * Run function + * \param uan the UAN helper + */ void Run (UanHelper &uan); + /** + * Receive packet function + * \param socket the socket to receive from + */ void ReceivePacket (Ptr socket); + /** + * Update positions function + * \param nodes the collection of nodes + */ void UpdatePositions (NodeContainer &nodes); + /// Reset data function void ResetData (); + /** + * Increment CW function + * \param cw the CW + */ void IncrementCw (uint32_t cw); - uint32_t m_numNodes; - uint32_t m_dataRate; - double m_depth; - double m_boundary; - uint32_t m_packetSize; - uint32_t m_bytesTotal; - uint32_t m_cwMin; - uint32_t m_cwMax; - uint32_t m_cwStep; - uint32_t m_avgs; - - Time m_slotTime; - Time m_simTime; - - std::vector m_throughputs; + uint32_t m_numNodes; ///< number of nodes + uint32_t m_dataRate; ///< data rate + double m_depth; ///< depth + double m_boundary; ///< boundary + uint32_t m_packetSize; ///< packet size + uint32_t m_bytesTotal; ///< bytes total + uint32_t m_cwMin; ///< CW minimum + uint32_t m_cwMax; ///< CW maximum + uint32_t m_cwStep; ///< CW step + uint32_t m_avgs; ///< averages + Time m_slotTime; ///< slot time + Time m_simTime; ///< simulation time + + std::vector m_throughputs; ///< throughputs + + /// the experiment NetAnimExperiment (); }; diff --git a/src/netanim/model/animation-interface.cc b/src/netanim/model/animation-interface.cc index 8e5dc29bdf1..29ae830e7cd 100644 --- a/src/netanim/model/animation-interface.cc +++ b/src/netanim/model/animation-interface.cc @@ -66,7 +66,7 @@ NS_LOG_COMPONENT_DEFINE ("AnimationInterface"); // Globals -static bool initialized = false; +static bool initialized = false; //!< Initialization flag // Public methods diff --git a/src/netanim/model/animation-interface.h b/src/netanim/model/animation-interface.h index 387a62da46a..b86a3a08b1c 100644 --- a/src/netanim/model/animation-interface.h +++ b/src/netanim/model/animation-interface.h @@ -390,7 +390,7 @@ class AnimationInterface * * \brief Get trace file packet count (This used only for testing) * - * returns Number of packets recorded in the current trace file + * \returns Number of packets recorded in the current trace file */ uint64_t GetTracePktCount (); @@ -400,7 +400,7 @@ class AnimationInterface * \param counterName A string to identify the counter * \param counterType The type of the counter, such as uint32, double etc * - * returns The id of the counter to be used as a reference for future + * \returns The id of the counter to be used as a reference for future */ uint32_t AddNodeCounter (std::string counterName, CounterType counterType); @@ -409,59 +409,91 @@ class AnimationInterface * \brief Add a resource such as the path to an image file * \param resourcePath Absolute Path to an image/resource * - * returns a number identifying the resource + * \returns a number identifying the resource */ uint32_t AddResource (std::string resourcePath); /** * * \brief Get node's energy fraction (This used only for testing) + * \param node * - * returns current node's remaining energy (between [0, 1]) + * \returns current node's remaining energy (between [0, 1]) */ double GetNodeEnergyFraction (Ptr node) const; private: + /** + * AnimPacketInfo class + */ class AnimPacketInfo { public: AnimPacketInfo (); + /** + * Constructor + * + * \param pInfo anim packet info + */ AnimPacketInfo (const AnimPacketInfo & pInfo); + /** + * Constructor + * + * \param tx_nd transmit device + * \param fbTx fb transmit + * \param txNodeId transmit node ID + */ AnimPacketInfo(Ptr tx_nd, const Time fbTx, uint32_t txNodeId = 0); - Ptr m_txnd; - uint32_t m_txNodeId; - double m_fbTx; - double m_lbTx; - double m_fbRx; - double m_lbRx; - Ptr m_rxnd; + Ptr m_txnd; ///< transmit device + uint32_t m_txNodeId; ///< node ID + double m_fbTx; ///< fb transmit + double m_lbTx; ///< lb transmit + double m_fbRx; ///< fb receive + double m_lbRx; ///< lb receive + Ptr m_rxnd; ///< receive device + /** + * Process receive begin + * \param nd the device + * \param fbRx + */ void ProcessRxBegin (Ptr nd, const double fbRx); }; + /// RGB structure typedef struct { - uint8_t r; - uint8_t g; - uint8_t b; - } Rgb; + uint8_t r; ///< r + uint8_t g; ///< g + uint8_t b; ///< b + } Rgb; ///< RGB structure + /// P2pLinkNodeIdPair structure typedef struct { - uint32_t fromNode; - uint32_t toNode; - } P2pLinkNodeIdPair; + uint32_t fromNode; ///< from node + uint32_t toNode; ///< to node + } P2pLinkNodeIdPair; ///< P2P link node id pair + /// LinkProperties structure typedef struct { - std::string fromNodeDescription; - std::string toNodeDescription; - std::string linkDescription; - } LinkProperties; + std::string fromNodeDescription; ///< from node description + std::string toNodeDescription; ///< to node description + std::string linkDescription; ///< link description + } LinkProperties; ///< link properties + /// LinkPairCompare structure struct LinkPairCompare { + /** + * comparison operator + * + * \param first + * \param second + * \return true if equal + */ bool operator () (P2pLinkNodeIdPair first, P2pLinkNodeIdPair second) const { //Check if they are the same node pairs but flipped @@ -479,18 +511,21 @@ class AnimationInterface }; + /// Ipv4RouteTrackElement structure typedef struct { - std::string destination; - uint32_t fromNodeId; - } Ipv4RouteTrackElement; + std::string destination; ///< destination + uint32_t fromNodeId; ///< from node ID + } Ipv4RouteTrackElement; ///< IPv4 route track element + /// Ipv4RoutePathElement structure typedef struct { - uint32_t nodeId; - std::string nextHop; - } Ipv4RoutePathElement; + uint32_t nodeId; ///< node ID + std::string nextHop; ///< next hop + } Ipv4RoutePathElement; ///< IPv4 route path element + /// ProtocolType enumeration typedef enum { UAN, @@ -502,41 +537,69 @@ class AnimationInterface WAVE } ProtocolType; + /// NodeSize structure typedef struct { - double width; - double height; - } NodeSize; - typedef std::map LinkPropertiesMap; - typedef std::map NodeDescriptionsMap; - typedef std::map NodeColorsMap; - typedef std::map AnimUidPacketInfoMap; - typedef std::map EnergyFractionMap; - typedef std::vector Ipv4RoutePathElements; - typedef std::multimap NodeIdIpv4Map; - typedef std::multimap NodeIdIpv6Map; - typedef std::pair NodeIdIpv4Pair; - typedef std::pair NodeIdIpv6Pair; + double width; ///< width + double height; ///< height + } NodeSize; ///< node size + typedef std::map LinkPropertiesMap; ///< LinkPropertiesMap typedef + typedef std::map NodeDescriptionsMap; ///< NodeDescriptionsMap typedef + typedef std::map NodeColorsMap; ///< NodeColorsMap typedef + typedef std::map AnimUidPacketInfoMap; ///< AnimUidPacketInfoMap typedef + typedef std::map EnergyFractionMap; ///< EnergyFractionMap typedef + typedef std::vector Ipv4RoutePathElements; ///< Ipv4RoutePathElements typedef + typedef std::multimap NodeIdIpv4Map; ///< NodeIdIpv4Map typedef + typedef std::multimap NodeIdIpv6Map; ///< NodeIdIpv6Map typedef + typedef std::pair NodeIdIpv4Pair; ///< NodeIdIpv4Pair typedef + typedef std::pair NodeIdIpv6Pair; ///< NodeIdIpv6Pair typedef // Node Counters - typedef std::map NodeCounterMap64; + typedef std::map NodeCounterMap64; ///< NodeCounterMap64 typedef + /// AnimXmlElement class class AnimXmlElement { - public: - AnimXmlElement(std::string tagName, bool emptyElement = true); - template - void AddAttribute(std::string attribute, T value, bool xmlEscape = false); - void SetText(std::string text); - void AppendChild(AnimXmlElement e); - std::string ToString(bool autoClose = true); + public: + /** + * Constructor + * + * \param tagName tag name + * \param emptyElement empty element? + */ + AnimXmlElement (std::string tagName, bool emptyElement=true); + template + /** + * Add attribute function + * \param attribute the attribute name + * \param value the attribute value + * \param xmlEscape true to escape + */ + void AddAttribute (std::string attribute, T value, bool xmlEscape=false); + /** + * Set text function + * \param text the text for the element + */ + void SetText(std::string text); + /** + * Append child function + * \param e the element to add as a child + */ + void AppendChild(AnimXmlElement e); + /** + * Get text for the element function + * \param autoClose auto close the element + * \returns the text + */ + std::string ToString(bool autoClose = true); + private: - std::string m_tagName; - std::string m_text; - std::vector m_attributes; - std::vector m_children; + std::string m_tagName; ///< tag name + std::string m_text; ///< element string + std::vector m_attributes; ///< list of attributes + std::vector m_children; ///< list of children }; @@ -544,273 +607,800 @@ class AnimationInterface // ##### State ##### - FILE * m_f; // File handle for output (0 if none) - FILE * m_routingF; // File handle for routing table output (0 if None); - Time m_mobilityPollInterval; - std::string m_outputFileName; - uint64_t gAnimUid ; // Packet unique identifier used by AnimationInterface - AnimWriteCallback m_writeCallback; - bool m_started; - bool m_enablePacketMetadata; - Time m_startTime; - Time m_stopTime; - uint64_t m_maxPktsPerFile; - std::string m_originalFileName; - Time m_routingStopTime; - std::string m_routingFileName; - Time m_routingPollInterval; - NodeContainer m_routingNc; - Time m_ipv4L3ProtocolCountersStopTime; - Time m_ipv4L3ProtocolCountersPollInterval; - Time m_queueCountersStopTime; - Time m_queueCountersPollInterval; - Time m_wifiMacCountersStopTime; - Time m_wifiMacCountersPollInterval; - Time m_wifiPhyCountersStopTime; - Time m_wifiPhyCountersPollInterval; - static Rectangle * userBoundary; - bool m_trackPackets; + FILE * m_f; ///< File handle for output (0 if none) + FILE * m_routingF; ///< File handle for routing table output (0 if None); + Time m_mobilityPollInterval; ///< mobility poll interval + std::string m_outputFileName; ///< output file name + uint64_t gAnimUid ; ///< Packet unique identifier used by AnimationInterface + AnimWriteCallback m_writeCallback; ///< write callback + bool m_started; ///< started + bool m_enablePacketMetadata; ///< enable packet metadata + Time m_startTime; ///< start time + Time m_stopTime; ///< stop time + uint64_t m_maxPktsPerFile; ///< maximum pakets per file + std::string m_originalFileName; ///< original file name + Time m_routingStopTime; ///< routing stop time + std::string m_routingFileName; ///< routing file name + Time m_routingPollInterval; ///< routing poll interval + NodeContainer m_routingNc; ///< routing node container + Time m_ipv4L3ProtocolCountersStopTime; ///< IPv4 L3 protocol counters stop time + Time m_ipv4L3ProtocolCountersPollInterval; ///< IPv4 L3 protocol counters poll interval + Time m_queueCountersStopTime; ///< queue counters stop time + Time m_queueCountersPollInterval; ///< queue counters poll interval + Time m_wifiMacCountersStopTime; ///< wifi MAC counters stop time + Time m_wifiMacCountersPollInterval; ///< wifi MAC counters poll interval + Time m_wifiPhyCountersStopTime; ///< wifi Phy counters stop time + Time m_wifiPhyCountersPollInterval; ///< wifi Phy counters poll interval + static Rectangle * userBoundary; ///< user boundary + bool m_trackPackets; ///< track packets // Counter ID - uint32_t m_remainingEnergyCounterId; + uint32_t m_remainingEnergyCounterId; ///< remaining energy counter ID - uint32_t m_ipv4L3ProtocolTxCounterId; - uint32_t m_ipv4L3ProtocolRxCounterId; - uint32_t m_ipv4L3ProtocolDropCounterId; - - uint32_t m_queueEnqueueCounterId; - uint32_t m_queueDequeueCounterId; - uint32_t m_queueDropCounterId; - - uint32_t m_wifiMacTxCounterId; - uint32_t m_wifiMacTxDropCounterId; - uint32_t m_wifiMacRxCounterId; - uint32_t m_wifiMacRxDropCounterId; + uint32_t m_ipv4L3ProtocolTxCounterId; ///< IPv4 L3 protocol transmit counter ID + uint32_t m_ipv4L3ProtocolRxCounterId; ///< IPv4 L3 protocol receive counter ID + uint32_t m_ipv4L3ProtocolDropCounterId; ///< IPv4 protocol drop counter ID + + uint32_t m_queueEnqueueCounterId; ///< queue enqueue counter ID + uint32_t m_queueDequeueCounterId; ///< queue dequeue counter ID + uint32_t m_queueDropCounterId; ///< queue drop counter ID + + uint32_t m_wifiMacTxCounterId; ///< wifi MAC transmit counter ID + uint32_t m_wifiMacTxDropCounterId; ///< wifi MAC transmit drop counter ID + uint32_t m_wifiMacRxCounterId; ///< wifi MAC receive counter ID + uint32_t m_wifiMacRxDropCounterId; ///< wifi MAC receive drop counter ID - uint32_t m_wifiPhyTxDropCounterId; - uint32_t m_wifiPhyRxDropCounterId; + uint32_t m_wifiPhyTxDropCounterId; ///< wifi Phy transmit drop counter ID + uint32_t m_wifiPhyRxDropCounterId; ///< wifi Phy receive drop counter ID - AnimUidPacketInfoMap m_pendingWifiPackets; - AnimUidPacketInfoMap m_pendingWimaxPackets; - AnimUidPacketInfoMap m_pendingLrWpanPackets; - AnimUidPacketInfoMap m_pendingLtePackets; - AnimUidPacketInfoMap m_pendingCsmaPackets; - AnimUidPacketInfoMap m_pendingUanPackets; - AnimUidPacketInfoMap m_pendingWavePackets; - - std::map m_nodeLocation; - std::map m_macToNodeIdMap; - std::map m_ipv4ToNodeIdMap; - std::map m_ipv6ToNodeIdMap; - NodeIdIpv4Map m_nodeIdIpv4Map; - NodeIdIpv6Map m_nodeIdIpv6Map; - - NodeColorsMap m_nodeColors; - NodeDescriptionsMap m_nodeDescriptions; - LinkPropertiesMap m_linkProperties; - EnergyFractionMap m_nodeEnergyFraction; - uint64_t m_currentPktCount; - std::vector m_ipv4RouteTrackElements; - std::map m_nodeSizes; - std::vector m_resources; - std::vector m_nodeCounters; + AnimUidPacketInfoMap m_pendingWifiPackets; ///< pending wifi packets + AnimUidPacketInfoMap m_pendingWimaxPackets; ///< pending wimax packets + AnimUidPacketInfoMap m_pendingLrWpanPackets; ///< pending LR-WPAN packets + AnimUidPacketInfoMap m_pendingLtePackets; ///< pending LTE packets + AnimUidPacketInfoMap m_pendingCsmaPackets; ///< pending CSMA packets + AnimUidPacketInfoMap m_pendingUanPackets; ///< pending UAN packets + AnimUidPacketInfoMap m_pendingWavePackets; ///< pending WAVE packets + + std::map m_nodeLocation; ///< node location + std::map m_macToNodeIdMap; ///< MAC to node ID map + std::map m_ipv4ToNodeIdMap; ///< IPv4 to node ID map + std::map m_ipv6ToNodeIdMap; ///< IPv6 to node ID map + NodeIdIpv4Map m_nodeIdIpv4Map; ///< node ID to IPv4 map + NodeIdIpv6Map m_nodeIdIpv6Map; ///< node ID to IPv6 map + + NodeColorsMap m_nodeColors; ///< node colors + NodeDescriptionsMap m_nodeDescriptions; ///< node description + LinkPropertiesMap m_linkProperties; ///< link properties + EnergyFractionMap m_nodeEnergyFraction; ///< node energy fraction + uint64_t m_currentPktCount; ///< current packet count + std::vector m_ipv4RouteTrackElements; ///< IPv route track elements + std::map m_nodeSizes; ///< node sizes + std::vector m_resources; ///< resources + std::vector m_nodeCounters; ///< node counters /* Value-added custom counters */ - NodeCounterMap64 m_nodeIpv4Drop; - NodeCounterMap64 m_nodeIpv4Tx; - NodeCounterMap64 m_nodeIpv4Rx; - NodeCounterMap64 m_nodeQueueEnqueue; - NodeCounterMap64 m_nodeQueueDequeue; - NodeCounterMap64 m_nodeQueueDrop; - NodeCounterMap64 m_nodeWifiMacTx; - NodeCounterMap64 m_nodeWifiMacTxDrop; - NodeCounterMap64 m_nodeWifiMacRx; - NodeCounterMap64 m_nodeWifiMacRxDrop; - NodeCounterMap64 m_nodeWifiPhyTxDrop; - NodeCounterMap64 m_nodeWifiPhyRxDrop; - NodeCounterMap64 m_nodeLrWpanMacTx; - NodeCounterMap64 m_nodeLrWpanMacTxDrop; - NodeCounterMap64 m_nodeLrWpanMacRx; - NodeCounterMap64 m_nodeLrWpanMacRxDrop; + NodeCounterMap64 m_nodeIpv4Drop; ///< node IPv4 drop + NodeCounterMap64 m_nodeIpv4Tx; ///< node IPv4 transmit + NodeCounterMap64 m_nodeIpv4Rx; ///< node IPv4 receive + NodeCounterMap64 m_nodeQueueEnqueue; ///< node queue enqueue + NodeCounterMap64 m_nodeQueueDequeue; ///< node queue dequeue + NodeCounterMap64 m_nodeQueueDrop; ///< node queue drop + NodeCounterMap64 m_nodeWifiMacTx; ///< node wifi MAC transmit + NodeCounterMap64 m_nodeWifiMacTxDrop; ///< node wifi MAC transmit drop + NodeCounterMap64 m_nodeWifiMacRx; ///< node wifi MAC receive + NodeCounterMap64 m_nodeWifiMacRxDrop; ///< node wifi MAC receive drop + NodeCounterMap64 m_nodeWifiPhyTxDrop; ///< node wifi Phy transmit drop + NodeCounterMap64 m_nodeWifiPhyRxDrop; ///< node wifi Phy receive drop + NodeCounterMap64 m_nodeLrWpanMacTx; ///< node LR-WPAN MAC transmit + NodeCounterMap64 m_nodeLrWpanMacTxDrop; ///< node LR-WPAN MAC transmit drop + NodeCounterMap64 m_nodeLrWpanMacRx;///< node LR-WPAN MAC receive + NodeCounterMap64 m_nodeLrWpanMacRxDrop;///< node LR-WPAN MAC receive drop + /** + * Get elements from context + * \param context the context string + * \returns the elements + */ const std::vector GetElementsFromContext (const std::string& context) const; + /** + * Get node from context + * \param context the context string + * \returns the node + */ Ptr GetNodeFromContext (const std::string& context) const; + /** + * Get net device from context + * \param context the context string + * \returns the device + */ Ptr GetNetDeviceFromContext (std::string context); // ##### General ##### + /** + * Start animation function + * + * \param restart + */ void StartAnimation (bool restart = false); + /** + * Set output file function + * + * \param fn the file name + * \param routing + */ void SetOutputFile (const std::string& fn, bool routing = false); + /** + * Stop animation function + * + * \param onlyAnimation + */ void StopAnimation (bool onlyAnimation = false); + /** + * Counter type to string function + * \param counterType the counter type + * \returns the string + */ std::string CounterTypeToString (CounterType counterType); + /** + * Get packet metadata function + * \param p the packet + * \returns the meta data + */ std::string GetPacketMetadata (Ptr p); + /** + * Add byte tag function + * \param animUid the UID + * \param p the packet + */ void AddByteTag (uint64_t animUid, Ptr p); - int WriteN (const char*, uint32_t, FILE * f); - int WriteN (const std::string&, FILE * f); + /** + * WriteN functon + * \param data the data t write + * \param count the number of bytes to write + * \param f the file to write to + * \returns the number of bytes written + */ + int WriteN (const char* data, uint32_t count, FILE * f); + /** + * WriteN function + * \param st the string to output + * \param f the file to write to + * \returns the number of bytes written + */ + int WriteN (const std::string& st, FILE * f); + /** + * Get MAC address function + * \param nd the device + * \returns the MAC address + */ std::string GetMacAddress (Ptr nd); + /** + * Get IPv4 address + * \param nd the device + * \returns the IPv4 address + */ std::string GetIpv4Address (Ptr nd); + /** + * Get IPv6 address + * \param nd the device + * \returns the IPv6 address + */ std::string GetIpv6Address(Ptr nd); + /** + * Get IPv4 addresses + * \param nd the device + * \returns the IPv4 address list + */ std::vector GetIpv4Addresses (Ptr nd); + /** + * Get IPv6 addresses + * \param nd the device + * \returns the IPv6 address list + */ std::vector GetIpv6Addresses (Ptr nd); + /** + * Get netanim version function + * \returns the net anim version string + */ std::string GetNetAnimVersion (); + /// Mobility auto check function void MobilityAutoCheck (); + /** + * Is packet pending function + * \param animUid the UID + * \param protocolType the protocol type + * \returns true if a packet is pending + */ bool IsPacketPending (uint64_t animUid, ProtocolType protocolType); + /** + * Purge pending packets function + * \param protocolType the protocol type + */ void PurgePendingPackets (ProtocolType protocolType); + /** + * Protocol type to pending packets function + * \param protocolType the protocol type + * \returns AnimUidPacketInfoMap * + */ AnimUidPacketInfoMap * ProtocolTypeToPendingPackets (ProtocolType protocolType); + /** + * Protocol type to string function + * \param protocolType the protocol type + * \returns the protocol type string + */ std::string ProtocolTypeToString (ProtocolType protocolType); + /** + * Add pending packet function + * \param protocolType the protocol type + * \param animUid the UID + * \param pktInfo the packet info + */ void AddPendingPacket (ProtocolType protocolType, uint64_t animUid, AnimPacketInfo pktInfo); + /** + * Get anim UID from packet function + * \param p the packet + * \returns the UID + */ uint64_t GetAnimUidFromPacket (Ptr ); - void AddToIpv4AddressNodeIdTable (std::string, uint32_t); - void AddToIpv4AddressNodeIdTable(std::vector, uint32_t); - void AddToIpv6AddressNodeIdTable(std::string, uint32_t); - void AddToIpv6AddressNodeIdTable(std::vector, uint32_t); + /** + * Add to IPv4 address node ID table function + * \param ipv4Address the IPv4 address + * \param nodeId the node ID + */ + void AddToIpv4AddressNodeIdTable (std::string ipv4Address, uint32_t nodeId); + /** + * Add to IPv4 address node ID table function + * \param ipv4Addresses the list of IPv4 addresses + * \param nodeId the node ID + */ + void AddToIpv4AddressNodeIdTable (std::vector ipv4Addresses, uint32_t nodeId); + /** + * Add to IPv6 address node ID table function + * \param ipv6Address the IPv6 address + * \param nodeId the node ID + */ + void AddToIpv6AddressNodeIdTable (std::string ipv6Address, uint32_t nodeId); + /** + * Add to IPv6 address node ID table function + * \param ipv6Addresses the list of IPv6 addresses + * \param nodeId the node ID + */ + void AddToIpv6AddressNodeIdTable (std::vector ipv6Addresses, uint32_t nodeId); + /** + * Is in time window function + * \returns true if in the time window + */ bool IsInTimeWindow (); + /// Check maximum packets per trace file function void CheckMaxPktsPerTraceFile (); + /// Track wifi phy counters function void TrackWifiPhyCounters (); + /// Track wifi MAC counters function void TrackWifiMacCounters (); + /// Track IPv4 L3 protocol counters function void TrackIpv4L3ProtocolCounters (); + /// Track queue counters function void TrackQueueCounters (); // ##### Routing ##### + /// Track IPv4 router function void TrackIpv4Route (); + /// Track IPv4 route paths function void TrackIpv4RoutePaths (); + /** + * Get IPv4 routing table function + * \param n the node + * \returns the IPv4 routing table + */ std::string GetIpv4RoutingTable (Ptr n); - void RecursiveIpv4RoutePathSearch (std::string fromIpv4, std::string toIpv4, Ipv4RoutePathElements &); + /** + * Recursive IPv4 route path search function + * \param from the source node + * \param to the destination node + * \param rpElements the IPv4 routing path elements + */ + void RecursiveIpv4RoutePathSearch (std::string from, std::string to, Ipv4RoutePathElements &rpElements); + /** + * Write route path function + * \param nodeId the node ID + * \param destination the destination + * \param rpElements the IPv4 routing path elements + */ void WriteRoutePath (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements); // ##### Trace ##### - void EnqueueTrace (std::string context, - Ptr); - void DequeueTrace (std::string context, - Ptr); - void QueueDropTrace (std::string context, - Ptr); + /** + * Enqueue trace function + * \param context the context + * \param p the packet + */ + void EnqueueTrace (std::string context, Ptr); + /** + * Dequeue trace function + * \param context the context + * \param p the packet + */ + void DequeueTrace (std::string context, Ptr); + /** + * Queue trace function + * \param context the context + * \param p the packet + */ + void QueueDropTrace (std::string context, Ptr); + /** + * IPv4 transmit trace function + * \param context the context + * \param p the packet + * \param ipv4 the IP + * \param interfaceIndex the interface index + */ void Ipv4TxTrace (std::string context, - Ptr, Ptr, - uint32_t); + Ptr p, Ptr ipv4, + uint32_t interfaceIndex); + /** + * IPv4 receive trace function + * \param context the context + * \param p the packet + * \param ipv4 the IP + * \param interfaceIndex the interface index + */ void Ipv4RxTrace (std::string context, - Ptr, Ptr, - uint32_t); + Ptr p, Ptr ipv4, + uint32_t interfaceIndex); + /** + * IPv4 drop trace function + * \param context the context + * \param ipv4Header the IPv4 header + * \param p the packet + * \param dropReason the reason for the drop + * \param ipv4 the IP + * \param interfaceIndex the interface index + */ void Ipv4DropTrace (std::string context, - const Ipv4Header &, - Ptr, - Ipv4L3Protocol::DropReason, Ptr, - uint32_t); - - void WifiMacTxTrace (std::string context, - Ptr); - void WifiMacTxDropTrace (std::string context, - Ptr); - void WifiMacRxTrace (std::string context, - Ptr); - void WifiMacRxDropTrace (std::string context, - Ptr); - void WifiPhyTxDropTrace (std::string context, - Ptr); - void WifiPhyRxDropTrace (std::string context, - Ptr); + const Ipv4Header & ipv4Header, + Ptr p, + Ipv4L3Protocol::DropReason dropReason, Ptr ipv4, + uint32_t interfaceIndex); + + /** + * wifi MAC transmit trace function + * \param context the context + * \param p the packet + */ + void WifiMacTxTrace (std::string context, Ptr p); + /** + * wifi MAC transmit drop trace function + * \param context the context + * \param p the packet + */ + void WifiMacTxDropTrace (std::string context, Ptr p); + /** + * wifi MAC receive trace function + * \param context the context + * \param p the packet + */ + void WifiMacRxTrace (std::string context, Ptr p); + /** + * wifi MAC receive drop trace function + * \param context the context + * \param p the packet + */ + void WifiMacRxDropTrace (std::string context, Ptr p); + /** + * wifi Phy transmit drop trace function + * \param context the context + * \param p the packet + */ + void WifiPhyTxDropTrace (std::string context, Ptr p); + /** + * wifi Phy recieve drop trace function + * \param context the context + * \param p the packet + */ + void WifiPhyRxDropTrace (std::string context, Ptr p); + /** + * LR-WPAN MAC transmit trace function + * \param context the context + * \param p the packet + */ void LrWpanMacTxTrace (std::string context, - Ptr); + Ptr p); + /** + * LR-WPAN MAC transmit drop trace function + * \param context the context + * \param p the packet + */ void LrWpanMacTxDropTrace (std::string context, - Ptr); + Ptr p); + /** + * LR-WPAN MAC receive trace function + * \param context the context + * \param p the packet + */ void LrWpanMacRxTrace (std::string context, - Ptr); + Ptr p); + /** + * LR-WPAN MAC receive drop trace function + * \param context the context + * \param p the packet + */ void LrWpanMacRxDropTrace (std::string context, - Ptr); + Ptr p); + /** + * Device transmit trace function + * \param context the context + * \param p the packet + * \param tx the transmit device + * \param rx the receive device + * \param txTime the transmit time + * \param rxTime the reeive time + */ void DevTxTrace (std::string context, Ptr p, Ptr tx, Ptr rx, Time txTime, Time rxTime); - void WifiPhyTxBeginTrace (std::string context, - Ptr p); - void WifiPhyRxBeginTrace (std::string context, - Ptr p); + /** + * wifi Phy transmit begin trace function + * \param context the context + * \param p the packet + */ + void WifiPhyTxBeginTrace (std::string context, Ptr p); + /** + * wifi Phy receive begin trace function + * + * \param context the context + * \param p the packet + */ + void WifiPhyRxBeginTrace (std::string context, Ptr p); + /** + * WAVE Phy transmit begin trace function + * \param context the context + * \param p the packet + */ void WavePhyTxBeginTrace (std::string context, Ptr p); + /** + * WAVE Phy receive begin trace function + * + * \param context the context + * \param p the packet + */ void WavePhyRxBeginTrace (std::string context, Ptr p); + /** + * LR-WPAN Phy receive begin trace function + * + * \param context the context + * \param p the packet + */ void LrWpanPhyTxBeginTrace (std::string context, Ptr p); + /** + * LR-WPAN Phy receive begin trace function + * + * \param context the context + * \param p the packet + */ void LrWpanPhyRxBeginTrace (std::string context, Ptr p); + /** + * WIMax transmit trace function + * \param context the context + * \param p the packet + * \param m the MAC address + */ void WimaxTxTrace (std::string context, Ptr p, - const Mac48Address &); + const Mac48Address & m); + /** + * WIMax receive trace function + * \param context the context + * \param p the packet + * \param m the MAC address + */ void WimaxRxTrace (std::string context, Ptr p, - const Mac48Address &); - void CsmaPhyTxBeginTrace (std::string context, - Ptr p); - void CsmaPhyTxEndTrace (std::string context, - Ptr p); - void CsmaPhyRxEndTrace (std::string context, - Ptr p); - void CsmaMacRxTrace (std::string context, - Ptr p); + const Mac48Address & m); + /** + * CSMA Phy transmit begin trace function + * \param context the context + * \param p the packet + */ + void CsmaPhyTxBeginTrace (std::string context, Ptr p); + /** + * CSMA Phy transmit end trace function + * + * \param context the context + * \param p the packet + */ + void CsmaPhyTxEndTrace (std::string context, Ptr p); + /** + * CSMA Phy receive end trace function + * + * \param context the context + * \param p the packet + */ + void CsmaPhyRxEndTrace (std::string context, Ptr p); + /** + * CSMA MAC receive trace function + * + * \param context the context + * \param p the packet + */ + void CsmaMacRxTrace (std::string context, Ptr p); + /** + * LTE transmit trace function + * \param context the context + * \param p the packet + * \param m the MAC address + */ void LteTxTrace (std::string context, Ptr p, - const Mac48Address &); + const Mac48Address & m); + /** + * LTE receive trace function + * \param context the context + * \param p the packet + * \param m the MAC address + */ void LteRxTrace (std::string context, Ptr p, - const Mac48Address &); - void LteSpectrumPhyTxStart (std::string context, - Ptr pb); - void LteSpectrumPhyRxStart (std::string context, - Ptr pb); - void UanPhyGenTxTrace (std::string context, - Ptr); - void UanPhyGenRxTrace (std::string context, - Ptr); + const Mac48Address & m); + /** + * LTE Spectrum Phy transmit start function + * \param context the context + * \param pb the packet burst + */ + void LteSpectrumPhyTxStart (std::string context, Ptr pb); + /** + * LTE Spectrum Phy receive start function + * \param context the context + * \param pb the packet burst + */ + void LteSpectrumPhyRxStart (std::string context, Ptr pb); + /** + * UAN Phy gen transmit trace function + * \param context the context + * \param p the packet + */ + void UanPhyGenTxTrace (std::string context, Ptr); + /** + * UAN Phy gen receive trace function + * \param context the context + * \param p the packet + */ + void UanPhyGenRxTrace (std::string context, Ptr); + /** + * Remaining energy trace function + * \param context the context + * \param previousEnergy The previous energy + * \param currentEnergy The current energy + */ void RemainingEnergyTrace (std::string context, double previousEnergy, double currentEnergy); - void GenericWirelessTxTrace (std::string context, Ptr, ProtocolType protocolType); - void GenericWirelessRxTrace (std::string context, Ptr, ProtocolType protocolType); + /** + * Generic wireless transmit trace function + * \param context the context + * \param p the packet + * \param protocolType the protocol type + */ + void GenericWirelessTxTrace (std::string context, Ptr p, ProtocolType protocolType); + /** + * Generic wireless receive trace function + * \param context the context + * \param p the packet + * \param protocolType the protocol type + */ + void GenericWirelessRxTrace (std::string context, Ptr p, ProtocolType protocolType); + /// Connect callbacks function void ConnectCallbacks (); + /// Connect LTE function void ConnectLte (); + /** + * Connect LTE ue function + * \param n the node + * \param nd the device + * \param devIndex the device index + */ void ConnectLteUe (Ptr n, Ptr nd, uint32_t devIndex); + /** + * Connect LTE ENB function + * \param n the node + * \param nd the device + * \param devIndex the device index + */ void ConnectLteEnb (Ptr n, Ptr nd, uint32_t devIndex); // ##### Mobility ##### + /** + * Get position function + * \param n the node + * \returns the position vector + */ Vector GetPosition (Ptr n); + /** + * Update position function + * \param n the node + * \returns the position vector + */ Vector UpdatePosition (Ptr n); + /** + * Update position function + * \param n the node + * \param v the vector + * \returns the postition vector + */ Vector UpdatePosition (Ptr n, Vector v); + /** + * Update position function + * \param ndev the device + * \returns the position vector + */ Vector UpdatePosition (Ptr ndev); + /** + * Node has moved function + * \param n the node + * \param newLocation the new location vector + * \returns true if the node has moved + */ bool NodeHasMoved (Ptr n, Vector newLocation); + /** + * Get moved nodes function + * \returns the list of moved nodes + */ std::vector < Ptr > GetMovedNodes (); + /** + * Mobility course change trace function + * \param mob the mobility model + */ void MobilityCourseChangeTrace (Ptr mob); // ##### XML Helpers ##### + /** + * Write non P2P link properties function + * \param id the ID + * \param ipv4Address the IP address + * \param channelType the channel type + */ void WriteNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType); + /** + * Write node update function + * \param nodeId the node ID + */ void WriteNodeUpdate (uint32_t nodeId); + /** + * Output wireless packet transmit info + * \param p the packet + * \param pktInfo the packet info + * \param animUid the UID + */ void OutputWirelessPacketTxInfo (Ptr p, AnimPacketInfo& pktInfo, uint64_t animUid); + /** + * Output wireless packet receive info + * \param p the packet + * \param pktInfo the packet info + * \param animUid the UID + */ void OutputWirelessPacketRxInfo (Ptr p, AnimPacketInfo& pktInfo, uint64_t animUid); + /** + * Output CSMA packet function + * \param p the packet + * \param pktInfo the packet info + */ void OutputCsmaPacket (Ptr p, AnimPacketInfo& pktInfo); + /// Write link properties function void WriteLinkProperties (); + /// Write IPv4 Addresses function void WriteIpv4Addresses (); + /// Write IPv6 Addresses function void WriteIpv6Addresses (); + /// Write nodes function void WriteNodes (); + /// Write node colors function void WriteNodeColors (); + /// Write node sizes function void WriteNodeSizes (); + /// Write node energies function void WriteNodeEnergies (); + /** + * Write XML anim function + * \param routing the routing + */ void WriteXmlAnim (bool routing = false); + /** + * Write XML update node position function + * \param nodeId the node ID + * \param x the X position + * \param y the Y position + */ void WriteXmlUpdateNodePosition (uint32_t nodeId, double x, double y); + /** + * Write XML update node color function + * \param nodeId the node ID + * \param r the red color + * \param g the green color + * \param b the blue color + */ void WriteXmlUpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b); + /** + * Write XML update node description function + * \param nodeId the node ID + */ void WriteXmlUpdateNodeDescription (uint32_t nodeId); + /** + * Write XML update node size function + * \param nodeId the node ID + * \param width the width + * \param height the height + */ void WriteXmlUpdateNodeSize (uint32_t nodeId, double width, double height); + /** + * Write XML add resource function + * \param resourceId the resource ID + * \param resourcePath the resource path + */ void WriteXmlAddResource (uint32_t resourceId, std::string resourcePath); + /** + * Write XML add node counter function + * \param counterId the counter ID + * \param counterName the counter name + * \param counterType the counter type + */ void WriteXmlAddNodeCounter (uint32_t counterId, std::string counterName, CounterType counterType); + /** + * Write XML update node image function + * \param nodeId the node ID + * \param resourceId the resource ID + */ void WriteXmlUpdateNodeImage (uint32_t nodeId, uint32_t resourceId); + /** + * Write XML update node counter function + * \param counterId the counter ID + * \param nodeId the node ID + * \param value the node counter value + */ void WriteXmlUpdateNodeCounter (uint32_t counterId, uint32_t nodeId, double value); + /** + * Write XML node function + * \param id the ID + * \param sysId the system ID + * \param locX the x location + * \param locY the y location + */ void WriteXmlNode (uint32_t id, uint32_t sysId, double locX, double locY); + /** + * Write XML link counter function + * \param fromId the from device + * \param toLp the to device + * \param toId the to ID + */ void WriteXmlLink (uint32_t fromId, uint32_t toLp, uint32_t toId); - void WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string); + /** + * Write XML update link counter function + * \param fromId the from device + * \param toId the to device + * \param linkDescription the link description + */ + void WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string linkDescription); + /** + * Write XMLP function + * \param pktType the packet type + * \param fId the FID + * \param fbTx the FB transmit + * \param lbTx the LB transmit + * \param tId the TID + * \param fbRx the FB receive + * \param lbRx the LB receive + * \param metaInfo the meta info + */ void WriteXmlP (std::string pktType, uint32_t fId, double fbTx, @@ -819,15 +1409,71 @@ class AnimationInterface double fbRx, double lbRx, std::string metaInfo = ""); + /** + * Write XMLP function + * \param animUid the UID + * \param pktType the packet type + * \param fId the FID + * \param fbTx the FB transmit + * \param lbTx the LB transmit + */ void WriteXmlP (uint64_t animUid, std::string pktType, uint32_t fId, double fbTx, double lbTx); + /** + * Write XMLP Ref function + * \param animUid the UID + * \param fId the FID + * \param fbTx the FB transmit + * \param metaInfo the meta info + */ void WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo = ""); + /** + * Write XML close function + * \param name the name + * \param routing true if routing + */ void WriteXmlClose (std::string name, bool routing = false); + /** + * Write XML non P2P link properties function + * \param id the ID + * \param ipAddress the IP address + * \param channelType the channel type + */ void WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipAddress, std::string channelType); + /** + * Write XML routing function + * \param id the ID + * \param routingInfo the routing info + */ void WriteXmlRouting (uint32_t id, std::string routingInfo); + /** + * Write XMLRP function + * \param nodeId the node ID + * \param destination the destination + * \param rpElements the route path elements + */ void WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements); + /** + * Write XML update background function + * \param fileName the file name + * \param x the X value + * \param y the Y value + * \param scaleX the X scale + * \param scaleY the Y scale + * \param opacity the opacity + */ void WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity); + /** + * Write XML Ipv4 addresses function + * \param nodeId the node ID + * \param ipv4Addresses the list of Ipv4 addresses + */ void WriteXmlIpv4Addresses (uint32_t nodeId, std::vector ipv4Addresses); - void WriteXmlIpv6Addresses (uint32_t nodeId, std::vector ipv4Addresses); + /** + * Write XML Ipv6 addresses function + * \param nodeId the node ID + * \param ipv6Addresses the list of Ipv6 addresses + */ + void WriteXmlIpv6Addresses (uint32_t nodeId, std::vector ipv6Addresses); }; @@ -906,7 +1552,7 @@ class AnimByteTag : public Tag uint64_t Get (void) const; private: - uint64_t m_AnimUid; + uint64_t m_AnimUid; ///< the UID }; diff --git a/src/netanim/test/netanim-test.cc b/src/netanim/test/netanim-test.cc index 22b99418238..83c7ea76e1e 100644 --- a/src/netanim/test/netanim-test.cc +++ b/src/netanim/test/netanim-test.cc @@ -32,6 +32,18 @@ using namespace ns3; +/** + * \ingroup netanim-test + * \defgroup netanim-test animation module tests + */ + + +/** + * \ingroup netanim-test + * \ingroup tests + * + * \brief Abstract Animation Interface Test Case + */ class AbstractAnimationInterfaceTestCase : public TestCase { public: @@ -53,21 +65,21 @@ class AbstractAnimationInterfaceTestCase : public TestCase protected: - NodeContainer m_nodes; - AnimationInterface* m_anim; + NodeContainer m_nodes; ///< the nodes + AnimationInterface* m_anim; ///< animation private: - virtual void - PrepareNetwork () = 0; + /// Prepare nework function + virtual void PrepareNetwork () = 0; - virtual void - CheckLogic () = 0; + /// Check logic function + virtual void CheckLogic () = 0; - virtual void - CheckFileExistence (); + /// Check file existence + virtual void CheckFileExistence (); - const char* m_traceFileName; + const char* m_traceFileName; ///< trace file name }; AbstractAnimationInterfaceTestCase::AbstractAnimationInterfaceTestCase (std::string name) : @@ -102,6 +114,12 @@ AbstractAnimationInterfaceTestCase::CheckFileExistence () unlink (m_traceFileName); } +/** + * \ingroup netanim-test + * \ingroup tests + * + * \brief Animation Interface Test Case + */ class AnimationInterfaceTestCase : public AbstractAnimationInterfaceTestCase { public: @@ -169,6 +187,12 @@ AnimationInterfaceTestCase::CheckLogic (void) NS_TEST_ASSERT_MSG_EQ (m_anim->GetTracePktCount (), 16, "Expected 16 packets traced"); } +/** + * \ingroup netanim-test + * \ingroup tests + * + * \brief Animation Remaining Energy Test Case + */ class AnimationRemainingEnergyTestCase : public AbstractAnimationInterfaceTestCase { public: @@ -185,9 +209,9 @@ class AnimationRemainingEnergyTestCase : public AbstractAnimationInterfaceTestCa virtual void CheckLogic (); - Ptr m_energySource; - Ptr m_energyModel; - const double m_initialEnergy; + Ptr m_energySource; ///< energy source + Ptr m_energyModel; ///< energy model + const double m_initialEnergy; ///< initial energy }; AnimationRemainingEnergyTestCase::AnimationRemainingEnergyTestCase () : @@ -228,6 +252,12 @@ AnimationRemainingEnergyTestCase::CheckLogic (void) "Wrong remaining energy value was traced"); } +/** + * \ingroup netanim-test + * \ingroup tests + * + * \brief Animation Interface Test Suite + */ static class AnimationInterfaceTestSuite : public TestSuite { public: @@ -237,4 +267,4 @@ static class AnimationInterfaceTestSuite : public TestSuite AddTestCase (new AnimationInterfaceTestCase (), TestCase::QUICK); AddTestCase (new AnimationRemainingEnergyTestCase (), TestCase::QUICK); } -} g_animationInterfaceTestSuite; +} g_animationInterfaceTestSuite; ///< the test suite From 8cfc0f1b4012b21ccb91f24b35dc673ea30b12e8 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Fri, 28 Apr 2017 02:29:26 +0200 Subject: [PATCH 021/551] documentation: various test grouping fixes --- src/mesh/model/flame/flame-protocol.h | 2 +- src/mesh/test/dot11s/dot11s-test-suite.cc | 6 ++--- src/mesh/test/flame/flame-regression.h | 6 +++++ ...h-information-element-vector-test-suite.cc | 5 ++++ src/mobility/test/geo-to-cartesian-test.cc | 25 +++++++++---------- src/netanim/test/netanim-test.cc | 2 +- .../adaptive-red-queue-disc-test-suite.cc | 2 +- src/uan/test/uan-energy-model-test.cc | 2 +- src/wifi/test/80211b.c | 2 +- src/wimax/test/mac-messages-test.cc | 2 +- 10 files changed, 32 insertions(+), 22 deletions(-) diff --git a/src/mesh/model/flame/flame-protocol.h b/src/mesh/model/flame/flame-protocol.h index dc7e42f2c32..ef151b65c77 100644 --- a/src/mesh/model/flame/flame-protocol.h +++ b/src/mesh/model/flame/flame-protocol.h @@ -28,7 +28,7 @@ #include /** - * \ingroup flame + * \ingroup mesh * \defgroup flame FLAME * * \brief Forwarding LAyer for MEshing protocol diff --git a/src/mesh/test/dot11s/dot11s-test-suite.cc b/src/mesh/test/dot11s/dot11s-test-suite.cc index 48a7accb5db..f57b8d1b391 100644 --- a/src/mesh/test/dot11s/dot11s-test-suite.cc +++ b/src/mesh/test/dot11s/dot11s-test-suite.cc @@ -30,8 +30,8 @@ using namespace ns3; using namespace dot11s; /** - * \ingroup dot11s-test - * \defgroup dot11s-test mesh module tests + * \ingroup mesh-test + * \defgroup dot11s-test dot11s sub-module tests */ @@ -39,7 +39,7 @@ using namespace dot11s; * \ingroup dot11s-test * \ingroup tests * - * \brief Built-in self test for FlameHeader + * \brief Built-in self test for MeshHeader */ struct MeshHeaderTest : public TestCase { diff --git a/src/mesh/test/flame/flame-regression.h b/src/mesh/test/flame/flame-regression.h index 08e1439ad50..05e209d1e29 100644 --- a/src/mesh/test/flame/flame-regression.h +++ b/src/mesh/test/flame/flame-regression.h @@ -25,6 +25,12 @@ #include "ns3/pcap-file.h" using namespace ns3; + +/** + * \ingroup mesh-test + * \defgroup flame-test flame sub-module tests + */ + /** * \ingroup flame-test * \ingroup tests diff --git a/src/mesh/test/mesh-information-element-vector-test-suite.cc b/src/mesh/test/mesh-information-element-vector-test-suite.cc index baccac3d8ad..93ffa1d1626 100644 --- a/src/mesh/test/mesh-information-element-vector-test-suite.cc +++ b/src/mesh/test/mesh-information-element-vector-test-suite.cc @@ -34,6 +34,11 @@ using namespace ns3; +/** + * \ingroup mesh + * \defgroup mesh-test mesh module tests + */ + /** * \ingroup mesh-test * \ingroup tests diff --git a/src/mobility/test/geo-to-cartesian-test.cc b/src/mobility/test/geo-to-cartesian-test.cc index 06022c93d52..5995a45eeb1 100644 --- a/src/mobility/test/geo-to-cartesian-test.cc +++ b/src/mobility/test/geo-to-cartesian-test.cc @@ -22,18 +22,6 @@ #include #include -/** - * This test verifies the accuracy of the GeographicToCartesianCoordinates() - * method in the GeographicPositions class, which converts earth - * geographic/geodetic coordinates to ECEF Cartesian coordinates. To do so, it - * compares the values generated from the method to values generated from the - * MATLAB function geodetic2ecef(), which is part of the MATLAB Mapping Toolbox, - * using the built-in earth referenceSphere, GRS80 referenceEllipsoid, and WGS84 - * referenceEllipsoid in MATLAB. A description of the MATLAB function can be - * found at this webpage: http://www.mathworks.com/help/map/ref/geodetic2ecef.html - * Values are compared using 216 test cases for each of the three earth spheroid - * models. - */ NS_LOG_COMPONENT_DEFINE ("GeoToCartesianTest"); using namespace ns3; @@ -487,7 +475,7 @@ const double ZWGS84_MATLAB[216] = {0, 0, 0, 0, 0, 0, 6043686.27224277, /** - * \ingroup mobility-test + * \ingroup mobility * \defgroup mobility-test mobility module tests */ @@ -497,6 +485,17 @@ const double ZWGS84_MATLAB[216] = {0, 0, 0, 0, 0, 0, 6043686.27224277, * \ingroup tests * * \brief Geo To Cartesian Test Case + * + * This test verifies the accuracy of the GeographicToCartesianCoordinates() + * method in the GeographicPositions class, which converts earth + * geographic/geodetic coordinates to ECEF Cartesian coordinates. To do so, it + * compares the values generated from the method to values generated from the + * MATLAB function geodetic2ecef(), which is part of the MATLAB Mapping Toolbox, + * using the built-in earth referenceSphere, GRS80 referenceEllipsoid, and WGS84 + * referenceEllipsoid in MATLAB. A description of the MATLAB function can be + * found at this webpage: http://www.mathworks.com/help/map/ref/geodetic2ecef.html + * Values are compared using 216 test cases for each of the three earth spheroid + * models. */ class GeoToCartesianTestCase : public TestCase { diff --git a/src/netanim/test/netanim-test.cc b/src/netanim/test/netanim-test.cc index 83c7ea76e1e..443d5c3b424 100644 --- a/src/netanim/test/netanim-test.cc +++ b/src/netanim/test/netanim-test.cc @@ -33,7 +33,7 @@ using namespace ns3; /** - * \ingroup netanim-test + * \ingroup netanim * \defgroup netanim-test animation module tests */ diff --git a/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc b/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc index 8be49990b31..2dc171b2bd2 100644 --- a/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc @@ -31,7 +31,7 @@ using namespace ns3; /** - * \ingroup traffic-control-test + * \ingroup traffic-control * \defgroup traffic-control-test traffic-control module tests */ diff --git a/src/uan/test/uan-energy-model-test.cc b/src/uan/test/uan-energy-model-test.cc index faaedf47acb..7db59b208f3 100644 --- a/src/uan/test/uan-energy-model-test.cc +++ b/src/uan/test/uan-energy-model-test.cc @@ -41,7 +41,7 @@ using namespace ns3; NS_LOG_COMPONENT_DEFINE ("UanEnergyModelTestSuite"); /** - * \ingroup uan-test + * \ingroup uan * \defgroup uan-test uan module tests */ diff --git a/src/wifi/test/80211b.c b/src/wifi/test/80211b.c index 96b9aa36a00..115fa8b5c1f 100644 --- a/src/wifi/test/80211b.c +++ b/src/wifi/test/80211b.c @@ -47,7 +47,7 @@ #define WLAN_SIR_impossible 0.1 // if SIR < -10dB, impossible to receive /** - * \ingroup wifi-test + * \ingroup wifi * \defgroup wifi-test wifi module tests */ diff --git a/src/wimax/test/mac-messages-test.cc b/src/wimax/test/mac-messages-test.cc index 84c084901d0..9d7c25653e1 100644 --- a/src/wimax/test/mac-messages-test.cc +++ b/src/wimax/test/mac-messages-test.cc @@ -25,7 +25,7 @@ using namespace ns3; /** - * \ingroup wimax-test + * \ingroup wimax * \defgroup wimax-test wimax module tests */ From 4fa9b44a3cfb96b341c347f51df7ef56082cb1f8 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 28 Apr 2017 16:53:51 +0300 Subject: [PATCH 022/551] spectrum: Call CalcRxPowerSpectralDensity recursively --- src/spectrum/model/spectrum-propagation-loss-model.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/spectrum/model/spectrum-propagation-loss-model.cc b/src/spectrum/model/spectrum-propagation-loss-model.cc index 26a271a5216..f047ae45545 100644 --- a/src/spectrum/model/spectrum-propagation-loss-model.cc +++ b/src/spectrum/model/spectrum-propagation-loss-model.cc @@ -68,7 +68,7 @@ SpectrumPropagationLossModel::CalcRxPowerSpectralDensity (Ptr rxPsd = DoCalcRxPowerSpectralDensity (txPsd, a, b); if (m_next != 0) { - rxPsd = m_next->DoCalcRxPowerSpectralDensity (rxPsd, a, b); + rxPsd = m_next->CalcRxPowerSpectralDensity (rxPsd, a, b); } return rxPsd; } From f31b0ed2d8f8a22e8603c3bbcd15d07a1af81789 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Fri, 28 Apr 2017 21:52:08 +0200 Subject: [PATCH 023/551] wave: doxygen wave group added --- src/wave/helper/wave-helper.h | 2 ++ src/wave/helper/wifi-80211p-helper.h | 1 + src/wave/model/channel-coordinator.h | 1 + src/wave/model/channel-manager.h | 2 ++ src/wave/model/channel-scheduler.h | 19 ++++++++++++++++--- src/wave/model/higher-tx-tag.h | 2 ++ src/wave/model/vendor-specific-action.h | 5 ++++- src/wave/model/vsa-manager.h | 6 ++++++ src/wave/model/wave-net-device.h | 11 +++++++++++ src/wave/test/mac-extension-test-suite.cc | 2 +- 10 files changed, 46 insertions(+), 5 deletions(-) diff --git a/src/wave/helper/wave-helper.h b/src/wave/helper/wave-helper.h index 70190ee2f5f..7eaa2018d9b 100644 --- a/src/wave/helper/wave-helper.h +++ b/src/wave/helper/wave-helper.h @@ -33,6 +33,7 @@ class WaveNetDevice; class Node; /** + * \ingroup wave * To trace WaveNetDevice, we have to overwrite the trace functions of class YansWifiPhyHelper. * The source code is very similar with YansWifiPhy, only with some adaptation. */ @@ -80,6 +81,7 @@ class YansWavePhyHelper : public YansWifiPhyHelper }; /** + * \ingroup wave * \brief helps to create WaveNetDevice objects * * This class can help to create a large set of similar diff --git a/src/wave/helper/wifi-80211p-helper.h b/src/wave/helper/wifi-80211p-helper.h index 20d227e53e3..b40000fd475 100644 --- a/src/wave/helper/wifi-80211p-helper.h +++ b/src/wave/helper/wifi-80211p-helper.h @@ -28,6 +28,7 @@ namespace ns3 { /** + * \ingroup wave * \brief helps to create wifi 802.11p objects of * WifiNetDevice class * diff --git a/src/wave/model/channel-coordinator.h b/src/wave/model/channel-coordinator.h index 749ebecda8a..27bf76b8513 100644 --- a/src/wave/model/channel-coordinator.h +++ b/src/wave/model/channel-coordinator.h @@ -24,6 +24,7 @@ namespace ns3 { /** + * \ingroup wave * \brief receive notifications about channel coordination events. */ class ChannelCoordinationListener : public SimpleRefCount diff --git a/src/wave/model/channel-manager.h b/src/wave/model/channel-manager.h index 8bccccb4fce..042c295e707 100644 --- a/src/wave/model/channel-manager.h +++ b/src/wave/model/channel-manager.h @@ -26,6 +26,8 @@ namespace ns3 { /** + * \ingroup wave + * * WAVE channels * channel number | 172 | 174 | 176 | 178 | 180 | 182 | 184 | * channel bandwidth 10MHz 10MHz 10MHz 10MHz 10MHz 10MHz 10MHz diff --git a/src/wave/model/channel-scheduler.h b/src/wave/model/channel-scheduler.h index 6e761453ba5..c84e46ab231 100644 --- a/src/wave/model/channel-scheduler.h +++ b/src/wave/model/channel-scheduler.h @@ -23,21 +23,34 @@ namespace ns3 { class WaveNetDevice; -/// EdcaParameter structure +/** + * \ingroup wave + * EdcaParameter structure + */ struct EdcaParameter { uint32_t cwmin; ///< minimum uint32_t cwmax; ///< maximum uint32_t aifsn; ///< AIFSN }; -/// EDCA parameters typedef + +/** + * \ingroup wave + * EDCA parameters typedef + */ typedef std::map EdcaParameters; -/// EDCA parameters iterator typedef + +/** + * \ingroup wave + * EDCA parameters iterator typedef + */ typedef std::map::const_iterator EdcaParametersI; #define EXTENDED_ALTERNATING 0x00 #define EXTENDED_CONTINUOUS 0xff /** + * \ingroup wave + * * \param channelNumber channel number that the SCH service * can be made available for communications. * \param operationalRateSet OperationalRateSet if present, as specified in IEEE Std 802.11. diff --git a/src/wave/model/higher-tx-tag.h b/src/wave/model/higher-tx-tag.h index 2992b0d1757..ad119105655 100644 --- a/src/wave/model/higher-tx-tag.h +++ b/src/wave/model/higher-tx-tag.h @@ -32,6 +32,8 @@ class TypeId; /** * \ingroup packet + * \ingroup wave + * * \brief This tag will be used to support higher layer control DataRate * and TxPwr_Level for transmission. * If the high layer enables adaptable mode, DataRate will be the diff --git a/src/wave/model/vendor-specific-action.h b/src/wave/model/vendor-specific-action.h index 9b38594acfe..c3bffaf6797 100644 --- a/src/wave/model/vendor-specific-action.h +++ b/src/wave/model/vendor-specific-action.h @@ -33,9 +33,10 @@ namespace ns3 { class VendorSpecificContentManager; /** + * \ingroup wave + * * \brief the organization identifier is a public organizationally * unique identifier assigned by the IEEE. - * \ingroup wave * * Similar to protocol field of data packets that indicates which * entity of higher layer should handle received packets, Organization @@ -196,6 +197,8 @@ class VendorSpecificActionHeader : public Header typedef Callback, const OrganizationIdentifier &, Ptr,const Address &> VscCallback; /** + * \ingroup wave + * * VendorSpecificContentManager class */ class VendorSpecificContentManager diff --git a/src/wave/model/vsa-manager.h b/src/wave/model/vsa-manager.h index a2c99692505..597d57b9441 100644 --- a/src/wave/model/vsa-manager.h +++ b/src/wave/model/vsa-manager.h @@ -24,6 +24,8 @@ namespace ns3 { /** + * \ingroup wave + * * \brief indicate which interval the VSA frames will be transmitted in. * VSA_TRANSMIT_IN_CCHI will only allow in CCH Interval; * VSA_TRANSMIT_IN_SCHI will only allow in SCH Interval; @@ -37,6 +39,8 @@ enum VsaTransmitInterval }; /** + * \ingroup wave + * * \param peer The address of the peer MAC entity to which the * VSA is sent. * \param oi Identifies the source of the data when the source @@ -90,6 +94,8 @@ struct VsaInfo }; /** + * \ingroup wave + * * refer to 1609.4-2010 chapter 6.4 * Vendor Specific Action (VSA) frames transmission. * diff --git a/src/wave/model/wave-net-device.h b/src/wave/model/wave-net-device.h index 80a2b29b333..1cc7d852f7a 100644 --- a/src/wave/model/wave-net-device.h +++ b/src/wave/model/wave-net-device.h @@ -41,6 +41,13 @@ class VsaManager; class OcbWifiMac; /** + * \defgroup wave WAVE module + */ + + +/** + * \ingroup wave + * * \param channelNumber the specific channel * \param priority the priority of packet with range 0-7 * \param dataRate the transmit data rate of packet @@ -89,6 +96,8 @@ struct TxInfo }; /** + * \ingroup wave + * * \param channelNumber the channel number for the SCH. * \param adaptable if true, the actual power level and data * rate for transmission are adaptable. TxPwr_Level is the maximum @@ -133,6 +142,8 @@ struct TxProfile }; /** + * \ingroup wave + * * This class holds together multiple, ns3::WifiPhy, * and ns3::OcbWifiMac (including ns3::WifiRemoteStationManager). * Besides that, to support multiple channel operation this diff --git a/src/wave/test/mac-extension-test-suite.cc b/src/wave/test/mac-extension-test-suite.cc index 09ef1c1fe24..dc0d0fd4230 100644 --- a/src/wave/test/mac-extension-test-suite.cc +++ b/src/wave/test/mac-extension-test-suite.cc @@ -30,7 +30,7 @@ using namespace ns3; /** - * \ingroup wave-test + * \ingroup wave * \defgroup wave-test wave module tests */ From bd2a27113a72193fba48667145bb4168ab93da4f Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sun, 30 Apr 2017 00:05:35 +0200 Subject: [PATCH 024/551] applications: (fixes #2732) BulkSend Tx trace is fired too much --- src/applications/model/bulk-send-application.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/applications/model/bulk-send-application.cc b/src/applications/model/bulk-send-application.cc index 65ef8932ba6..74980e4f8f6 100644 --- a/src/applications/model/bulk-send-application.cc +++ b/src/applications/model/bulk-send-application.cc @@ -194,11 +194,11 @@ void BulkSendApplication::SendData (void) NS_LOG_LOGIC ("sending packet at " << Simulator::Now ()); Ptr packet = Create (toSend); - m_txTrace (packet); int actual = m_socket->Send (packet); if (actual > 0) { m_totBytes += actual; + m_txTrace (packet); } // We exit this loop when actual < toSend as the send side // buffer is full. The "DataSent" callback will pop when From f8da85356560f36083406bbe72f78bcca70d60b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 1 May 2017 20:58:13 +0200 Subject: [PATCH 025/551] wifi: Various fixes for ideal wifi manager --- src/wifi/examples/wifi-manager-example.cc | 27 +++++++--- src/wifi/model/ideal-wifi-manager.cc | 66 ++++++++++++----------- 2 files changed, 56 insertions(+), 37 deletions(-) diff --git a/src/wifi/examples/wifi-manager-example.cc b/src/wifi/examples/wifi-manager-example.cc index 351c151f056..b52e9bf646c 100644 --- a/src/wifi/examples/wifi-manager-example.cc +++ b/src/wifi/examples/wifi-manager-example.cc @@ -164,6 +164,7 @@ int main (int argc, char *argv[]) std::string standard ("802.11a"); StandardInfo serverSelectedStandard; StandardInfo clientSelectedStandard; + bool infrastructure = false; CommandLine cmd; cmd.AddValue ("rtsThreshold", "RTS threshold", rtsThreshold); @@ -179,6 +180,7 @@ int main (int argc, char *argv[]) cmd.AddValue ("clientShortGuardInterval", "Set short guard interval of the client (802.11n/ac)", clientShortGuardInterval); cmd.AddValue ("standard", "Set standard (802.11a, 802.11b, 802.11g, 802.11n-5GHz, 802.11n-2.4GHz, 802.11ac, 802.11-holland, 802.11-10MHz, 802.11-5MHz)", standard); cmd.AddValue ("wifiManager", "Set wifi rate manager (Aarf, Aarfcd, Amrr, Arf, Cara, Ideal, Minstrel, MinstrelHt, Onoe, Rraa)", wifiManager); + cmd.AddValue ("infrastructure", "Use infrastructure instead of adhoc", infrastructure); cmd.Parse (argc,argv); if (standard == "802.11b") @@ -326,12 +328,25 @@ int main (int argc, char *argv[]) NetDeviceContainer clientDevice; WifiMacHelper wifiMac; - // Use Adhoc so we don't get into association issues - wifiMac.SetType ("ns3::AdhocWifiMac", - "BE_MaxAmpduSize", UintegerValue (maxAmpduSize)); - - serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode); - clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode); + if (infrastructure) + { + Ssid ssid = Ssid ("ns-3-ssid"); + wifiMac.SetType ("ns3::StaWifiMac", + "Ssid", SsidValue (ssid), + "ActiveProbing", BooleanValue (false)); + serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode); + wifiMac.SetType ("ns3::ApWifiMac", + "Ssid", SsidValue (ssid), + "BeaconGeneration", BooleanValue (true)); + clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode); + } + else + { + wifiMac.SetType ("ns3::AdhocWifiMac", + "BE_MaxAmpduSize", UintegerValue (maxAmpduSize)); + serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode); + clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode); + } if (wifiManager == "MinstrelHt") { diff --git a/src/wifi/model/ideal-wifi-manager.cc b/src/wifi/model/ideal-wifi-manager.cc index 849ceedb7f1..ba3f1b12b37 100644 --- a/src/wifi/model/ideal-wifi-manager.cc +++ b/src/wifi/model/ideal-wifi-manager.cc @@ -116,40 +116,43 @@ IdealWifiManager::DoInitialize () AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); } // Add all Ht and Vht MCSes - txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ()); - if (HasVhtSupported () == true || HasHtSupported () == true ) + if (HasVhtSupported () == true || HasHtSupported () == true) { nModes = GetPhy ()->GetNMcs (); for (uint32_t i = 0; i < nModes; i++) { - mode = GetPhy ()->GetMcs (i); - if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT) + for (uint16_t j = 20; j <= GetPhy ()->GetChannelWidth (); j*=2) { - //derive NSS from the Mcs index - nss = (mode.GetMcsValue () / 8) + 1; - NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << - " channel width " << (uint16_t) GetPhy ()->GetChannelWidth () << - " nss " << (uint16_t) nss << - " short GI " << GetPhy ()->GetShortGuardInterval ()); - NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ()); - txVector.SetNss (nss); - txVector.SetMode (mode); - AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); - } - else - { - uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); - for (uint8_t i = 1; i <= maxNss; i++) + txVector.SetChannelWidth (j); + mode = GetPhy ()->GetMcs (i); + if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT) { + //derive NSS from the Mcs index + nss = (mode.GetMcsValue () / 8) + 1; NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << " channel width " << (uint16_t) GetPhy ()->GetChannelWidth () << - " nss " << (uint16_t) i << - " short GI " << GetPhy ()->GetShortGuardInterval ()); + " nss " << (uint16_t) nss << + " short GI " << j); NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ()); - txVector.SetNss (i); + txVector.SetNss (nss); txVector.SetMode (mode); AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); } + else //VHT + { + uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); + for (uint8_t i = 1; i <= maxNss; i++) + { + NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << + " channel width " << (uint16_t) GetPhy ()->GetChannelWidth () << + " nss " << (uint16_t) i << + " short GI " << j); + NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ()); + txVector.SetNss (i); + txVector.SetMode (mode); + AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); + } + } } } } @@ -163,13 +166,14 @@ IdealWifiManager::GetSnrThreshold (WifiTxVector txVector) const { NS_LOG_DEBUG ("Checking " << i->second.GetMode ().GetUniqueName () << " nss " << (uint16_t) i->second.GetNss () << + " GI " << i->second.GetGuardInterval () << " width " << (uint16_t) i->second.GetChannelWidth ()); NS_LOG_DEBUG ("against TxVector " << txVector.GetMode ().GetUniqueName () << " nss " << (uint16_t) txVector.GetNss () << + " GI " << txVector.GetGuardInterval () << " width " << (uint16_t) txVector.GetChannelWidth ()); if (txVector.GetMode () == i->second.GetMode () && txVector.GetNss () == i->second.GetNss () - && txVector.GetGuardInterval () == i->second.GetGuardInterval () && txVector.GetChannelWidth () == i->second.GetChannelWidth ()) { return i->first; @@ -272,12 +276,13 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) //to ensure correct packet delivery. double maxThreshold = 0.0; WifiMode maxMode = GetDefaultMode (); - std::vector candidateTxVectors; WifiTxVector txVector; WifiMode mode; uint8_t selectedNss = 1; - txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ()); - txVector.SetGuardInterval (GetPhy ()->GetShortGuardInterval () ? 400 : 800); + uint8_t channelWidth = std::min (GetChannelWidth (station), GetPhy ()->GetChannelWidth ()); + uint16_t guardInterval = std::max (GetShortGuardInterval (station) ? 400 : 800, GetPhy ()->GetShortGuardInterval () ? 400 : 800); + txVector.SetChannelWidth (channelWidth); + txVector.SetGuardInterval (guardInterval); if (station->m_lastSnrObserved == station->m_lastSnrCached) { // SNR has not changed, so skip the search and use the last @@ -405,14 +410,13 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) station->m_lastMode = maxMode; station->m_nss = selectedNss; } - uint8_t channelWidth = GetChannelWidth (station); NS_LOG_DEBUG ("Found maxMode: " << maxMode << " channelWidth: " << (uint16_t) channelWidth); - if (m_currentRate != maxMode.GetDataRate (channelWidth, GetPhy ()->GetShortGuardInterval () ? 400 : 800, selectedNss)) + if (m_currentRate != maxMode.GetDataRate (channelWidth, guardInterval, selectedNss)) { - NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetShortGuardInterval () ? 400 : 800, selectedNss)); - m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetShortGuardInterval () ? 400 : 800, selectedNss); + NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, guardInterval, selectedNss)); + m_currentRate = maxMode.GetDataRate (channelWidth, guardInterval, selectedNss); } - return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), GetPreambleForTransmission (maxMode, GetAddress (station)), 800, GetNumberOfAntennas (), selectedNss, 0, channelWidth, GetAggregation (station), false); + return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), GetPreambleForTransmission (maxMode, GetAddress (station)), guardInterval, GetNumberOfAntennas (), selectedNss, 0, channelWidth, GetAggregation (station), false); } WifiTxVector From 54be238d46d214e728dab44211eee5bfde83c5f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 1 May 2017 20:59:10 +0200 Subject: [PATCH 026/551] wifi: Add support for 802.11ax in ideal wifi manager --- src/wifi/examples/wifi-manager-example.cc | 100 +++--- src/wifi/model/adhoc-wifi-mac.cc | 21 +- src/wifi/model/ideal-wifi-manager.cc | 125 +++++-- src/wifi/model/ideal-wifi-manager.h | 2 - src/wifi/test/examples-to-run.py | 416 +++++++++++++--------- 5 files changed, 421 insertions(+), 243 deletions(-) diff --git a/src/wifi/examples/wifi-manager-example.cc b/src/wifi/examples/wifi-manager-example.cc index b52e9bf646c..fd8386e0141 100644 --- a/src/wifi/examples/wifi-manager-example.cc +++ b/src/wifi/examples/wifi-manager-example.cc @@ -143,7 +143,6 @@ int main (int argc, char *argv[]) std::vector serverStandards; std::vector clientStandards; uint32_t steps; - uint32_t rtsThreshold = 999999; // disabled even for large A-MPDU uint32_t maxAmpduSize = 65535; double stepSize = 1; // dBm @@ -156,8 +155,8 @@ int main (int argc, char *argv[]) int sta1_y = 0; uint16_t serverNss = 1; uint16_t clientNss = 1; - bool serverShortGuardInterval = false; - bool clientShortGuardInterval = false; + uint16_t serverShortGuardInterval = 800; + uint16_t clientShortGuardInterval = 800; uint16_t serverChannelWidth = 20; uint16_t clientChannelWidth = 20; std::string wifiManager ("Ideal"); @@ -176,13 +175,18 @@ int main (int argc, char *argv[]) cmd.AddValue ("clientChannelWidth", "Set channel width of the client (valid only for 802.11n or ac)", clientChannelWidth); cmd.AddValue ("serverNss", "Set nss of the server (valid only for 802.11n or ac)", serverNss); cmd.AddValue ("clientNss", "Set nss of the client (valid only for 802.11n or ac)", clientNss); - cmd.AddValue ("serverShortGuardInterval", "Set short guard interval of the server (802.11n/ac)", serverShortGuardInterval); - cmd.AddValue ("clientShortGuardInterval", "Set short guard interval of the client (802.11n/ac)", clientShortGuardInterval); - cmd.AddValue ("standard", "Set standard (802.11a, 802.11b, 802.11g, 802.11n-5GHz, 802.11n-2.4GHz, 802.11ac, 802.11-holland, 802.11-10MHz, 802.11-5MHz)", standard); + cmd.AddValue ("serverShortGuardInterval", "Set short guard interval of the server (802.11n/ac/ax) in nanoseconds", serverShortGuardInterval); + cmd.AddValue ("clientShortGuardInterval", "Set short guard interval of the client (802.11n/ac/ax) in nanoseconds", clientShortGuardInterval); + cmd.AddValue ("standard", "Set standard (802.11a, 802.11b, 802.11g, 802.11n-5GHz, 802.11n-2.4GHz, 802.11ac, 802.11-holland, 802.11-10MHz, 802.11-5MHz, 802.11ax-5GHz, 802.11ax-2.4GHz)", standard); cmd.AddValue ("wifiManager", "Set wifi rate manager (Aarf, Aarfcd, Amrr, Arf, Cara, Ideal, Minstrel, MinstrelHt, Onoe, Rraa)", wifiManager); cmd.AddValue ("infrastructure", "Use infrastructure instead of adhoc", infrastructure); cmd.Parse (argc,argv); - +/* + LogComponentEnable("MacLow", LOG_LEVEL_ALL); + LogComponentEnable("WifiPhy", LOG_LEVEL_ALL); + LogComponentEnable("WifiRemoteStationManager", LOG_LEVEL_ALL); + LogComponentEnable("IdealWifiManager", LOG_LEVEL_ALL); +*/ if (standard == "802.11b") { NS_ABORT_MSG_IF (serverChannelWidth != 22 && serverChannelWidth != 22, "Invalid channel width for standard " << standard); @@ -211,6 +215,13 @@ int main (int argc, char *argv[]) NS_ABORT_MSG_IF (clientChannelWidth != 20 && clientChannelWidth != 40 && clientChannelWidth != 80 && clientChannelWidth != 160, "Invalid channel width for standard " << standard); NS_ABORT_MSG_IF (clientNss == 0 || clientNss > 4, "Invalid nss " << clientNss << " for standard " << standard); } + else if (standard == "802.11ax-5GHz" || standard == "802.11ax-2.4GHz") + { + NS_ABORT_MSG_IF (serverChannelWidth != 20 && serverChannelWidth != 40 && serverChannelWidth != 80 && serverChannelWidth != 160, "Invalid channel width for standard " << standard); + NS_ABORT_MSG_IF (serverNss == 0 || serverNss > 4, "Invalid nss " << serverNss << " for standard " << standard); + NS_ABORT_MSG_IF (clientChannelWidth != 20 && clientChannelWidth != 40 && clientChannelWidth != 80 && clientChannelWidth != 160, "Invalid channel width for standard " << standard); + NS_ABORT_MSG_IF (clientNss == 0 || clientNss > 4, "Invalid nss " << clientNss << " for standard " << standard); + } std::string plotName = "wifi-manager-example-"; std::string dataName = "wifi-manager-example-"; @@ -220,35 +231,22 @@ int main (int argc, char *argv[]) dataName += "-"; plotName += standard; dataName += standard; - if (standard == "802.11n-5GHz" || standard == "802.11n-2.4GHz" || standard == "802.11ac") + if (standard == "802.11n-5GHz" || + standard == "802.11n-2.4GHz" || + standard == "802.11ac" || + standard == "802.11ax-5GHz" || + standard == "802.11ax-2.4GHz") { plotName += "-server="; dataName += "-server="; std::ostringstream oss; - std::string gi; - if (serverShortGuardInterval) - { - gi = "SGI"; - } - else - { - gi = "LGI"; - } - oss << serverChannelWidth << "MHz_" << gi << "_" << serverNss << "SS"; + oss << serverChannelWidth << "MHz_" << serverShortGuardInterval << "ns_" << serverNss << "SS"; plotName += oss.str (); dataName += oss.str (); plotName += "-client="; dataName += "-client="; oss.str(""); - if (clientShortGuardInterval) - { - gi = "SGI"; - } - else - { - gi = "LGI"; - } - oss << clientChannelWidth << "MHz_" << gi << "_" << clientNss << "SS"; + oss << clientChannelWidth << "MHz_" << clientShortGuardInterval << "ns_" << clientNss << "SS"; plotName += oss.str (); dataName += oss.str (); } @@ -273,6 +271,8 @@ int main (int argc, char *argv[]) serverStandards.push_back (StandardInfo ("802.11-holland", WIFI_PHY_STANDARD_holland, 20, 3, 27, 0, 30, 60)); serverStandards.push_back (StandardInfo ("802.11-10MHz", WIFI_PHY_STANDARD_80211_10MHZ, 10, 3, 27, 0, 30, 60)); serverStandards.push_back (StandardInfo ("802.11-5MHz", WIFI_PHY_STANDARD_80211_5MHZ, 5, 3, 27, 0, 30, 60)); + serverStandards.push_back (StandardInfo ("802.11ax-5GHz", WIFI_PHY_STANDARD_80211ax_5GHZ, serverChannelWidth, 5, 55, 0, 60, 120 * channelRateFactor)); + serverStandards.push_back (StandardInfo ("802.11ax-2.4GHz", WIFI_PHY_STANDARD_80211ax_2_4GHZ, serverChannelWidth, 5, 55, 0, 60, 120 * channelRateFactor)); clientStandards.push_back (StandardInfo ("802.11a", WIFI_PHY_STANDARD_80211a, 20, 3, 27, 0, 30, 60)); clientStandards.push_back (StandardInfo ("802.11b", WIFI_PHY_STANDARD_80211b, 22, -5, 11, -6, 15, 15)); @@ -283,6 +283,8 @@ int main (int argc, char *argv[]) clientStandards.push_back (StandardInfo ("802.11-holland", WIFI_PHY_STANDARD_holland, 20, 3, 27, 0, 30, 60)); clientStandards.push_back (StandardInfo ("802.11-10MHz", WIFI_PHY_STANDARD_80211_10MHZ, 10, 3, 27, 0, 30, 60)); clientStandards.push_back (StandardInfo ("802.11-5MHz", WIFI_PHY_STANDARD_80211_5MHZ, 5, 3, 27, 0, 30, 60)); + clientStandards.push_back (StandardInfo ("802.11ax-5GHz", WIFI_PHY_STANDARD_80211ax_5GHZ, clientChannelWidth, 5, 45, 0, 50, 160 * channelRateFactor)); + clientStandards.push_back (StandardInfo ("802.11ax-2.4GHz", WIFI_PHY_STANDARD_80211ax_2_4GHZ, clientChannelWidth, 5, 45, 0, 50, 160 * channelRateFactor)); for (std::vector::size_type i = 0; i != serverStandards.size (); i++) { @@ -396,9 +398,17 @@ int main (int argc, char *argv[]) || serverSelectedStandard.m_name == "802.11ac") { wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width); - wifiPhyPtrServer->SetShortGuardInterval (serverShortGuardInterval); + wifiPhyPtrServer->SetShortGuardInterval (serverShortGuardInterval == 400); wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width); - wifiPhyPtrClient->SetShortGuardInterval (clientShortGuardInterval); + wifiPhyPtrClient->SetShortGuardInterval (clientShortGuardInterval == 400); + } + else if (serverSelectedStandard.m_name == "802.11ax-5GHz" + || serverSelectedStandard.m_name == "802.11ax-2.4GHz") + { + wifiPhyPtrServer->SetChannelWidth (serverSelectedStandard.m_width); + wifiPhyPtrServer->SetGuardInterval (NanoSeconds (serverShortGuardInterval)); + wifiPhyPtrClient->SetChannelWidth (clientSelectedStandard.m_width); + wifiPhyPtrClient->SetGuardInterval (NanoSeconds (clientShortGuardInterval)); } NS_LOG_DEBUG ("Channel width " << wifiPhyPtrClient->GetChannelWidth () << " noiseDbm " << noiseDbm); NS_LOG_DEBUG ("NSS " << wifiPhyPtrClient->GetMaxSupportedTxSpatialStreams ()); @@ -474,40 +484,38 @@ int main (int argc, char *argv[]) title.append (" with "); title.append (wifiManager); title.append ("\\n"); - if (standard == "802.11n-5GHz" || standard == "802.11n-2.4GHz" || standard == "802.11ac") + if (standard == "802.11n-5GHz" + || standard == "802.11n-2.4GHz" + || standard == "802.11ac" + || standard == "802.11n-5GHz" + || standard == "802.11ax-2.4GHz") { + std::ostringstream serverGiStrStr; std::ostringstream serverWidthStrStr; std::ostringstream serverNssStrStr; title.append ("server: width="); serverWidthStrStr << serverSelectedStandard.m_width; title.append (serverWidthStrStr.str ()); title.append ("MHz"); - if (serverShortGuardInterval == true) - { - title.append (" GI=short"); - } - else - { - title.append (" GI=long"); - } + title.append (" GI="); + serverGiStrStr << serverShortGuardInterval; + title.append (serverGiStrStr.str ()); + title.append ("ns"); title.append (" nss="); serverNssStrStr << serverNss; title.append (serverNssStrStr.str ()); title.append ("\\n"); + std::ostringstream clientGiStrStr; std::ostringstream clientWidthStrStr; std::ostringstream clientNssStrStr; title.append ("client: width="); clientWidthStrStr << clientSelectedStandard.m_width; title.append (clientWidthStrStr.str ()); title.append ("MHz"); - if (clientShortGuardInterval == true) - { - title.append (" GI=short"); - } - else - { - title.append (" GI=long"); - } + title.append (" GI="); + clientGiStrStr << clientShortGuardInterval; + title.append (clientGiStrStr.str ()); + title.append ("ns"); title.append (" nss="); clientNssStrStr << clientNss; title.append (clientNssStrStr.str ()); diff --git a/src/wifi/model/adhoc-wifi-mac.cc b/src/wifi/model/adhoc-wifi-mac.cc index 469e3c387b1..625d7507936 100644 --- a/src/wifi/model/adhoc-wifi-mac.cc +++ b/src/wifi/model/adhoc-wifi-mac.cc @@ -75,15 +75,22 @@ AdhocWifiMac::Enqueue (Ptr packet, Mac48Address to) { //In ad hoc mode, we assume that every destination supports all //the rates we support. - if (m_htSupported || m_vhtSupported) + if (m_htSupported || m_vhtSupported || m_heSupported) { m_stationManager->AddAllSupportedMcs (to); + } + if (m_htSupported) + { m_stationManager->AddStationHtCapabilities (to, GetHtCapabilities()); } if (m_vhtSupported) { m_stationManager->AddStationVhtCapabilities (to, GetVhtCapabilities()); } + if (m_heSupported) + { + m_stationManager->AddStationHeCapabilities (to, GetHeCapabilities()); + } m_stationManager->AddAllSupportedModes (to); m_stationManager->RecordDisassociated (to); } @@ -126,7 +133,7 @@ AdhocWifiMac::Enqueue (Ptr packet, Mac48Address to) hdr.SetTypeData (); } - if (m_htSupported || m_vhtSupported) + if (m_htSupported || m_vhtSupported || m_heSupported) { hdr.SetNoOrder (); } @@ -171,15 +178,23 @@ AdhocWifiMac::Receive (Ptr packet, const WifiMacHeader *hdr) { //In ad hoc mode, we assume that every destination supports all //the rates we support. - if (m_htSupported || m_vhtSupported) + if (m_htSupported || m_vhtSupported || m_heSupported) { m_stationManager->AddAllSupportedMcs (from); m_stationManager->AddStationHtCapabilities (from, GetHtCapabilities()); } + if (m_htSupported) + { + m_stationManager->AddStationHtCapabilities (from, GetHtCapabilities()); + } if (m_vhtSupported) { m_stationManager->AddStationVhtCapabilities (from, GetVhtCapabilities()); } + if (m_heSupported) + { + m_stationManager->AddStationHeCapabilities (from, GetHeCapabilities()); + } m_stationManager->AddAllSupportedModes (from); m_stationManager->RecordDisassociated (from); } diff --git a/src/wifi/model/ideal-wifi-manager.cc b/src/wifi/model/ideal-wifi-manager.cc index ba3f1b12b37..152a1425a77 100644 --- a/src/wifi/model/ideal-wifi-manager.cc +++ b/src/wifi/model/ideal-wifi-manager.cc @@ -81,8 +81,9 @@ IdealWifiManager::SetupPhy (Ptr phy) uint8_t IdealWifiManager::GetChannelWidthForMode (WifiMode mode) const { - NS_ASSERT (mode.GetModulationClass () != WIFI_MOD_CLASS_HT); - NS_ASSERT (mode.GetModulationClass () != WIFI_MOD_CLASS_VHT); + NS_ASSERT (mode.GetModulationClass () != WIFI_MOD_CLASS_HT + && mode.GetModulationClass () != WIFI_MOD_CLASS_VHT + && mode.GetModulationClass () != WIFI_MOD_CLASS_HE); if (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS) { @@ -102,21 +103,17 @@ IdealWifiManager::DoInitialize () WifiTxVector txVector; uint8_t nss = 1; uint32_t nModes = GetPhy ()->GetNModes (); - txVector.SetGuardInterval (GetPhy ()->GetShortGuardInterval () ? 400 : 800); for (uint32_t i = 0; i < nModes; i++) { mode = GetPhy ()->GetMode (i); txVector.SetChannelWidth (GetChannelWidthForMode (mode)); txVector.SetNss (nss); txVector.SetMode (mode); - NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << - " channel width " << (uint16_t) txVector.GetChannelWidth () << - " nss " << (uint16_t) nss << - " short GI " << GetPhy ()->GetShortGuardInterval ()); + NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName ()); AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); } // Add all Ht and Vht MCSes - if (HasVhtSupported () == true || HasHtSupported () == true) + if (HasVhtSupported () == true || HasHtSupported () == true || HasHeSupported () == true) { nModes = GetPhy ()->GetNMcs (); for (uint32_t i = 0; i < nModes; i++) @@ -127,26 +124,37 @@ IdealWifiManager::DoInitialize () mode = GetPhy ()->GetMcs (i); if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT) { - //derive NSS from the Mcs index + uint16_t guardInterval = GetPhy ()->GetShortGuardInterval () ? 400 : 800; + txVector.SetGuardInterval (guardInterval); + //derive NSS from the MCS index nss = (mode.GetMcsValue () / 8) + 1; NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << - " channel width " << (uint16_t) GetPhy ()->GetChannelWidth () << + " channel width " << (uint16_t) j << " nss " << (uint16_t) nss << - " short GI " << j); + " GI " << guardInterval); NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ()); txVector.SetNss (nss); txVector.SetMode (mode); AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber)); } - else //VHT + else //VHT or HE { + uint16_t guardInterval; + if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT) + { + guardInterval = GetPhy ()->GetShortGuardInterval () ? 400 : 800; + } + else + { + guardInterval = GetPhy ()->GetGuardInterval ().GetNanoSeconds (); + } uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); for (uint8_t i = 1; i <= maxNss; i++) { NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << - " channel width " << (uint16_t) GetPhy ()->GetChannelWidth () << + " channel width " << (uint16_t) j << " nss " << (uint16_t) i << - " short GI " << j); + " GI " << guardInterval); NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ()); txVector.SetNss (i); txVector.SetMode (mode); @@ -279,10 +287,9 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) WifiTxVector txVector; WifiMode mode; uint8_t selectedNss = 1; + uint16_t guardInterval; uint8_t channelWidth = std::min (GetChannelWidth (station), GetPhy ()->GetChannelWidth ()); - uint16_t guardInterval = std::max (GetShortGuardInterval (station) ? 400 : 800, GetPhy ()->GetShortGuardInterval () ? 400 : 800); txVector.SetChannelWidth (channelWidth); - txVector.SetGuardInterval (guardInterval); if (station->m_lastSnrObserved == station->m_lastSnrCached) { // SNR has not changed, so skip the search and use the last @@ -295,8 +302,8 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) } else { - if ((HasVhtSupported () == true || HasHtSupported () == true) - && (GetHtSupported (st) == true || GetVhtSupported (st) == true)) + if ((HasVhtSupported () == true || HasHtSupported () == true || HasHeSupported () == true) + && (GetHtSupported (st) == true || GetVhtSupported (st) == true || GetHeSupported (st) == true)) { for (uint32_t i = 0; i < GetNMcsSupported (station); i++) { @@ -304,11 +311,18 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) txVector.SetMode (mode); if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT) { + guardInterval = std::max (GetShortGuardInterval (station) ? 400 : 800, GetPhy ()->GetShortGuardInterval () ? 400 : 800); + txVector.SetGuardInterval (guardInterval); // If the node and peer are both VHT capable, only search VHT modes if (HasVhtSupported () && GetVhtSupported (station)) { continue; } + // If the node and peer are both HE capable, only search HE modes + if (HasHeSupported () && GetHeSupported (station)) + { + continue; + } // Derive NSS from the MCS index. There is a different mode for each possible NSS value. uint8_t nss = (mode.GetMcsValue () / 8) + 1; txVector.SetNss (nss); @@ -336,8 +350,15 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) selectedNss = nss; } } - else + else if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT) { + guardInterval = std::max (GetShortGuardInterval (station) ? 400 : 800, GetPhy ()->GetShortGuardInterval () ? 400 : 800); + txVector.SetGuardInterval (guardInterval); + // If the node and peer are both HE capable, only search HE modes + if (HasHeSupported () && GetHeSupported (station)) + { + continue; + } // If the node and peer are not both VHT capable, only search HT modes if (!HasVhtSupported () || !GetVhtSupported (station)) { @@ -377,6 +398,49 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) } } } + else //HE + { + guardInterval = std::max (GetGuardInterval (station), static_cast (GetPhy ()->GetGuardInterval ().GetNanoSeconds ())); + txVector.SetGuardInterval (guardInterval); + // If the node and peer are not both HE capable, only search (V)HT modes + if (!HasHeSupported () || !GetHeSupported (station)) + { + continue; + } + uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); + for (uint8_t nss = 1; nss <= maxNss; nss++) + { + // If the peer does not support more streams, stop searching. + if (GetNumberOfSupportedStreams (station) < nss) + { + break; + } + txVector.SetNss (nss); + if (WifiPhy::IsValidTxVector (txVector) == false) + { + NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () << + " nss " << (uint16_t) nss << " width " << + (uint16_t) txVector.GetChannelWidth ()); + continue; + } + double threshold = GetSnrThreshold (txVector); + NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () << + " threshold " << threshold << " maxThreshold " << + maxThreshold << " last snr observed " << + station->m_lastSnrObserved << " cached " << + station->m_lastSnrCached); + if (threshold > maxThreshold && threshold < station->m_lastSnrObserved) + { + NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () << + " threshold " << threshold << + " last snr observed " << + station->m_lastSnrObserved); + maxThreshold = threshold; + maxMode = mode; + selectedNss = nss; + } + } + } } } else @@ -411,6 +475,14 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) station->m_nss = selectedNss; } NS_LOG_DEBUG ("Found maxMode: " << maxMode << " channelWidth: " << (uint16_t) channelWidth); + if (maxMode.GetModulationClass () == WIFI_MOD_CLASS_HE) + { + guardInterval = std::max (GetGuardInterval (station), static_cast (GetPhy ()->GetGuardInterval ().GetNanoSeconds ())); + } + else + { + guardInterval = std::max (GetShortGuardInterval (station) ? 400 : 800, GetPhy ()->GetShortGuardInterval () ? 400 : 800); + } if (m_currentRate != maxMode.GetDataRate (channelWidth, guardInterval, selectedNss)) { NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, guardInterval, selectedNss)); @@ -432,9 +504,8 @@ IdealWifiManager::DoGetRtsTxVector (WifiRemoteStation *st) WifiMode mode; uint8_t nss = 1; WifiMode maxMode = GetDefaultMode (); - //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac - // RTS is sent in a non-HT frame; RTS with (V)HT is not yet supported - txVector.SetGuardInterval (GetPhy ()->GetShortGuardInterval () ? 400 : 800); + //avoid to use legacy rate adaptation algorithms for IEEE 802.11n/ac/ax + //RTS is sent in a legacy frame; RTS with HT/VHT/HE is not yet supported for (uint32_t i = 0; i < GetNBasicModes (); i++) { mode = GetBasicMode (i); @@ -457,14 +528,4 @@ IdealWifiManager::IsLowLatency (void) const return true; } -void -IdealWifiManager::SetHeSupported (bool enable) -{ - //HE is not supported yet by this algorithm. - if (enable) - { - NS_FATAL_ERROR ("WifiRemoteStationManager selected does not support HE rates"); - } -} - } //namespace ns3 diff --git a/src/wifi/model/ideal-wifi-manager.h b/src/wifi/model/ideal-wifi-manager.h index bd48fad2b83..12a2d28d6ba 100644 --- a/src/wifi/model/ideal-wifi-manager.h +++ b/src/wifi/model/ideal-wifi-manager.h @@ -54,8 +54,6 @@ class IdealWifiManager : public WifiRemoteStationManager void SetupPhy (Ptr phy); - void SetHeSupported (bool enable); //HE rates not yet supported - private: //overriden from base class diff --git a/src/wifi/test/examples-to-run.py b/src/wifi/test/examples-to-run.py index fc293cee70a..735948ce937 100644 --- a/src/wifi/test/examples-to-run.py +++ b/src/wifi/test/examples-to-run.py @@ -81,172 +81,268 @@ ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-holland --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-10MHz --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-5MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11a --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11g --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11-holland --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11-10MHz --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11-5MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=0 --clientShortGuardInterval=0 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1 --clientShortGuardInterval=1 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), ] # A list of Python examples to run in order to ensure that they remain From bf9f756bb94322483e6b1bb5ef8d81021c29d108 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Mon, 1 May 2017 15:27:41 -0700 Subject: [PATCH 027/551] mesh: Do not encode defaults in command line doc strings --- src/mesh/examples/mesh.cc | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/src/mesh/examples/mesh.cc b/src/mesh/examples/mesh.cc index 0c58365e5cb..60bfc87097d 100644 --- a/src/mesh/examples/mesh.cc +++ b/src/mesh/examples/mesh.cc @@ -124,20 +124,17 @@ void MeshTest::Configure (int argc, char *argv[]) { CommandLine cmd; - cmd.AddValue ("x-size", "Number of nodes in a row grid. [6]", m_xSize); - cmd.AddValue ("y-size", "Number of rows in a grid. [6]", m_ySize); - cmd.AddValue ("step", "Size of edge in our grid, meters. [100 m]", m_step); - /* - * As soon as starting node means that it sends a beacon, - * simultaneous start is not good. - */ - cmd.AddValue ("start", "Maximum random start delay, seconds. [0.1 s]", m_randomStart); - cmd.AddValue ("time", "Simulation time, seconds [100 s]", m_totalTime); - cmd.AddValue ("packet-interval", "Interval between packets in UDP ping, seconds [0.001 s]", m_packetInterval); - cmd.AddValue ("packet-size", "Size of packets in UDP ping", m_packetSize); - cmd.AddValue ("interfaces", "Number of radio interfaces used by each mesh point. [1]", m_nIfaces); - cmd.AddValue ("channels", "Use different frequency channels for different interfaces. [0]", m_chan); - cmd.AddValue ("pcap", "Enable PCAP traces on interfaces. [0]", m_pcap); + cmd.AddValue ("x-size", "Number of nodes in a row grid", m_xSize); + cmd.AddValue ("y-size", "Number of rows in a grid", m_ySize); + cmd.AddValue ("step", "Size of edge in our grid (meters)", m_step); + // Avoid starting all mesh nodes at the same time (beacons may collide) + cmd.AddValue ("start", "Maximum random start delay for beacon jitter (sec)", m_randomStart); + cmd.AddValue ("time", "Simulation time (sec)", m_totalTime); + cmd.AddValue ("packet-interval", "Interval between packets in UDP ping (sec)", m_packetInterval); + cmd.AddValue ("packet-size", "Size of packets in UDP ping (bytes)", m_packetSize); + cmd.AddValue ("interfaces", "Number of radio interfaces used by each mesh point", m_nIfaces); + cmd.AddValue ("channels", "Use different frequency channels for different interfaces", m_chan); + cmd.AddValue ("pcap", "Enable PCAP traces on interfaces", m_pcap); cmd.AddValue ("stack", "Type of protocol stack. ns3::Dot11sStack by default", m_stack); cmd.AddValue ("root", "Mac address of root mesh point in HWMP", m_root); From 0b3359b41d52726f29d2501d802593cec14d8b51 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Mon, 1 May 2017 17:44:16 -0700 Subject: [PATCH 028/551] applications: Constructors for UdpClientHelper, UdpServerHelper The constructors with no arguments were not usable because a minimal configuration of the ObjectFactory TypeId is necessary. --- src/applications/helper/udp-client-server-helper.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/applications/helper/udp-client-server-helper.cc b/src/applications/helper/udp-client-server-helper.cc index 4b719a31841..fa4618fbb03 100644 --- a/src/applications/helper/udp-client-server-helper.cc +++ b/src/applications/helper/udp-client-server-helper.cc @@ -28,6 +28,7 @@ namespace ns3 { UdpServerHelper::UdpServerHelper () { + m_factory.SetTypeId (UdpServer::GetTypeId ()); } UdpServerHelper::UdpServerHelper (uint16_t port) @@ -66,6 +67,7 @@ UdpServerHelper::GetServer (void) UdpClientHelper::UdpClientHelper () { + m_factory.SetTypeId (UdpClient::GetTypeId ()); } UdpClientHelper::UdpClientHelper (Address address, uint16_t port) @@ -103,6 +105,7 @@ UdpClientHelper::Install (NodeContainer c) UdpTraceClientHelper::UdpTraceClientHelper () { + m_factory.SetTypeId (UdpTraceClient::GetTypeId ()); } UdpTraceClientHelper::UdpTraceClientHelper (Address address, uint16_t port, std::string filename) From d54ab3eda0e338ff66546926509a3e41edb9a237 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 2 May 2017 21:48:19 +0200 Subject: [PATCH 029/551] wifi: Fix ideal wifi manager tests for 802.11ax --- src/wifi/examples/wifi-manager-example.cc | 7 +- src/wifi/model/wifi-phy.cc | 2 +- src/wifi/test/examples-to-run.py | 128 +++++++++++----------- 3 files changed, 66 insertions(+), 71 deletions(-) diff --git a/src/wifi/examples/wifi-manager-example.cc b/src/wifi/examples/wifi-manager-example.cc index fd8386e0141..ae9db90506b 100644 --- a/src/wifi/examples/wifi-manager-example.cc +++ b/src/wifi/examples/wifi-manager-example.cc @@ -181,12 +181,7 @@ int main (int argc, char *argv[]) cmd.AddValue ("wifiManager", "Set wifi rate manager (Aarf, Aarfcd, Amrr, Arf, Cara, Ideal, Minstrel, MinstrelHt, Onoe, Rraa)", wifiManager); cmd.AddValue ("infrastructure", "Use infrastructure instead of adhoc", infrastructure); cmd.Parse (argc,argv); -/* - LogComponentEnable("MacLow", LOG_LEVEL_ALL); - LogComponentEnable("WifiPhy", LOG_LEVEL_ALL); - LogComponentEnable("WifiRemoteStationManager", LOG_LEVEL_ALL); - LogComponentEnable("IdealWifiManager", LOG_LEVEL_ALL); -*/ + if (standard == "802.11b") { NS_ABORT_MSG_IF (serverChannelWidth != 22 && serverChannelWidth != 22, "Invalid channel width for standard " << standard); diff --git a/src/wifi/model/wifi-phy.cc b/src/wifi/model/wifi-phy.cc index b24751da66f..52df0662f57 100644 --- a/src/wifi/model/wifi-phy.cc +++ b/src/wifi/model/wifi-phy.cc @@ -793,7 +793,7 @@ WifiPhy::ConfigureDefaultsForStandard (WifiPhyStandard standard) NS_ASSERT (GetChannelNumber () == 42); break; case WIFI_PHY_STANDARD_80211ax_2_4GHZ: - SetChannelWidth (40); + SetChannelWidth (20); SetFrequency (2412); // Channel number should be aligned by SetFrequency () to 1 NS_ASSERT (GetChannelNumber () == 1); diff --git a/src/wifi/test/examples-to-run.py b/src/wifi/test/examples-to-run.py index 735948ce937..ee0c3d00cc4 100644 --- a/src/wifi/test/examples-to-run.py +++ b/src/wifi/test/examples-to-run.py @@ -248,101 +248,101 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=3 --clientNss=3 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ] # A list of Python examples to run in order to ensure that they remain From 5bcbf9067c665ab3190a5829564a5b4488440efe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Sat, 6 May 2017 18:00:21 +0200 Subject: [PATCH 030/551] wifi: Add frame capture support --- src/wifi/examples/test-interference-helper.cc | 73 +++++- src/wifi/model/frame-capture-model.cc | 36 +++ src/wifi/model/frame-capture-model.h | 60 +++++ src/wifi/model/interference-helper.cc | 72 ++++-- src/wifi/model/interference-helper.h | 24 +- src/wifi/model/simple-frame-capture-model.cc | 88 +++++++ src/wifi/model/simple-frame-capture-model.h | 82 +++++++ src/wifi/model/wifi-phy-state-helper.cc | 29 +++ src/wifi/model/wifi-phy-state-helper.h | 4 + src/wifi/model/wifi-phy.cc | 232 +++++++++++------- src/wifi/model/wifi-phy.h | 54 +++- src/wifi/test/examples-to-run.py | 2 + src/wifi/wscript | 4 + 13 files changed, 647 insertions(+), 113 deletions(-) create mode 100644 src/wifi/model/frame-capture-model.cc create mode 100644 src/wifi/model/frame-capture-model.h create mode 100644 src/wifi/model/simple-frame-capture-model.cc create mode 100644 src/wifi/model/simple-frame-capture-model.h diff --git a/src/wifi/examples/test-interference-helper.cc b/src/wifi/examples/test-interference-helper.cc index 5b147418725..87b5781a52a 100644 --- a/src/wifi/examples/test-interference-helper.cc +++ b/src/wifi/examples/test-interference-helper.cc @@ -55,9 +55,17 @@ #include "ns3/propagation-delay-model.h" #include "ns3/nist-error-rate-model.h" #include "ns3/constant-position-mobility-model.h" +#include "ns3/simple-frame-capture-model.h" +#include "ns3/log.h" using namespace ns3; +NS_LOG_COMPONENT_DEFINE ("test-interference-helper"); + +bool checkResults = false; +bool expectRxASuccessfull = false; +bool expectRxBSuccessfull = false; + /// InterferenceExperiment class InterferenceExperiment { @@ -71,12 +79,14 @@ class InterferenceExperiment double xB; ///< x B std::string txModeA; ///< transmit mode A std::string txModeB; ///< transmit mode B - uint32_t txPowerLevelA; ///< transmit power level A - uint32_t txPowerLevelB; ///< transmit power level B + double txPowerLevelA; ///< transmit power level A + double txPowerLevelB; ///< transmit power level B uint32_t packetSizeA; ///< packet size A uint32_t packetSizeB; ///< packet size B WifiPhyStandard standard; ///< standard WifiPreamble preamble; ///< preamble + bool captureEnabled; ///< whether physical layer capture is enabled + double captureMargin; ///< margin used for physical layer capture }; InterferenceExperiment (); @@ -87,6 +97,8 @@ class InterferenceExperiment void Run (struct InterferenceExperiment::Input input); private: + /// Function triggered when a packet is dropped + void PacketDropped(Ptr packet); /// Send A function void SendA (void) const; /// Send B function @@ -94,6 +106,8 @@ class InterferenceExperiment Ptr m_txA; ///< transmit A function Ptr m_txB; ///< transmit B function struct Input m_input; ///< input + bool m_droppedA; ///< flag to indicate whether packet A has been dropped + bool m_droppedB; ///< flag to indicate whether packet B has been dropped }; void @@ -118,21 +132,44 @@ InterferenceExperiment::SendB (void) const m_txB->SendPacket (p, txVector); } +void +InterferenceExperiment::PacketDropped(Ptr packet) +{ + if (packet->GetUid () == 0) + { + m_droppedA = true; + } + else if (packet->GetUid () == 1) + { + m_droppedB = true; + } + else + { + NS_LOG_ERROR ("Unknown packet!"); + exit (1); + } +} + InterferenceExperiment::InterferenceExperiment () + : m_droppedA (false), + m_droppedB (false) { } + InterferenceExperiment::Input::Input () : interval (MicroSeconds (0)), xA (-5), xB (5), txModeA ("OfdmRate54Mbps"), txModeB ("OfdmRate54Mbps"), - txPowerLevelA (0), - txPowerLevelB (0), + txPowerLevelA (16.0206), + txPowerLevelB (16.0206), packetSizeA (1500), packetSizeB (1500), standard (WIFI_PHY_STANDARD_80211a), - preamble (WIFI_PREAMBLE_LONG) + preamble (WIFI_PREAMBLE_LONG), + captureEnabled (false), + captureMargin (0) { } @@ -157,7 +194,11 @@ InterferenceExperiment::Run (struct InterferenceExperiment::Input input) posRx->SetPosition (Vector (0.0, 0.0, 0.0)); m_txA = CreateObject (); + m_txA->SetTxPowerStart (input.txPowerLevelA); + m_txA->SetTxPowerEnd (input.txPowerLevelA); m_txB = CreateObject (); + m_txB->SetTxPowerStart (input.txPowerLevelB); + m_txB->SetTxPowerEnd (input.txPowerLevelB); Ptr rx = CreateObject (); Ptr error = CreateObject (); @@ -170,18 +211,31 @@ InterferenceExperiment::Run (struct InterferenceExperiment::Input input) m_txA->SetMobility (posTxA); m_txB->SetMobility (posTxB); rx->SetMobility (posRx); + if (input.captureEnabled) + { + Ptr frameCaptureModel = CreateObject (); + frameCaptureModel->SetMargin (input.captureMargin); + rx->SetFrameCaptureModel (frameCaptureModel); + } m_txA->ConfigureStandard (input.standard); m_txB->ConfigureStandard (input.standard); rx->ConfigureStandard (input.standard); + rx->TraceConnectWithoutContext("PhyRxDrop", MakeCallback(&InterferenceExperiment::PacketDropped, this)); + Simulator::Schedule (Seconds (0), &InterferenceExperiment::SendA, this); Simulator::Schedule (Seconds (0) + input.interval, &InterferenceExperiment::SendB, this); Simulator::Run (); Simulator::Destroy (); -} + if(checkResults && (m_droppedA == expectRxASuccessfull || m_droppedB == expectRxBSuccessfull)) + { + NS_LOG_ERROR ("Results are not expected!"); + exit (1); + } +} int main (int argc, char *argv[]) { @@ -202,10 +256,17 @@ int main (int argc, char *argv[]) cmd.AddValue ("txModeB", "Wifi mode used for payload transmission of sender B", input.txModeB); cmd.AddValue ("standard", "IEEE 802.11 flavor", str_standard); cmd.AddValue ("preamble", "Type of preamble", str_preamble); + cmd.AddValue ("enableCapture", "Enable/disable physical layer capture", input.captureEnabled); + cmd.AddValue ("captureMargin", "Margin used for physical layer capture", input.captureMargin); + cmd.AddValue ("checkResults", "Used to check results at the end of the test", checkResults); + cmd.AddValue ("expectRxASuccessfull", "Indicate whether packet A is expected to be successfully received", expectRxASuccessfull); + cmd.AddValue ("expectRxBSuccessfull", "Indicate whether packet B is expected to be successfully received", expectRxBSuccessfull); cmd.Parse (argc, argv); + LogComponentEnable ("WifiPhy", LOG_LEVEL_ALL); LogComponentEnable ("YansWifiPhy", LOG_LEVEL_ALL); LogComponentEnable ("InterferenceHelper", LOG_LEVEL_ALL); + LogComponentEnable ("SimpleFrameCaptureModel", LOG_LEVEL_ALL); input.interval = MicroSeconds (delay); diff --git a/src/wifi/model/frame-capture-model.cc b/src/wifi/model/frame-capture-model.cc new file mode 100644 index 00000000000..788005f213b --- /dev/null +++ b/src/wifi/model/frame-capture-model.cc @@ -0,0 +1,36 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Sébastien Deronne + */ + +#include "frame-capture-model.h" + +namespace ns3 { + +NS_OBJECT_ENSURE_REGISTERED (FrameCaptureModel); + +TypeId FrameCaptureModel::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::FrameCaptureModel") + .SetParent () + .SetGroupName ("Wifi") + ; + return tid; +} + +} //namespace ns3 diff --git a/src/wifi/model/frame-capture-model.h b/src/wifi/model/frame-capture-model.h new file mode 100644 index 00000000000..4c559347bc4 --- /dev/null +++ b/src/wifi/model/frame-capture-model.h @@ -0,0 +1,60 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Sébastien Deronne + */ + +#ifndef FRAME_CAPTURE_MODEL_H +#define FRAME_CAPTURE_MODEL_H + +#include "ns3/object.h" +#include "interference-helper.h" + +namespace ns3 { + +/** + * \ingroup wifi + * \brief the interface for Wifi's frame capture models + * + */ +class FrameCaptureModel : public Object +{ +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + + /** + * A pure virtual method that must be implemented in the subclass. + * This method returns whether the reception should be switched to a + * new incoming frame. + * + * \param currentEvent the event of the current frame + * \param newEvent the event of the new incoming frame + * + * \return true if the reception should be switched to a new incoming frame, + * false otherwise + */ + virtual bool CaptureNewFrame (Ptr currentEvent, Ptr newEvent) const = 0; +}; + +} //namespace ns3 + +#endif /* FRAME_CAPTURE_MODEL_H */ + diff --git a/src/wifi/model/interference-helper.cc b/src/wifi/model/interference-helper.cc index db383fd36f6..4f5139780aa 100644 --- a/src/wifi/model/interference-helper.cc +++ b/src/wifi/model/interference-helper.cc @@ -33,8 +33,9 @@ NS_LOG_COMPONENT_DEFINE ("InterferenceHelper"); * Phy event class ****************************************************************/ -InterferenceHelper::Event::Event (WifiTxVector txVector, Time duration, double rxPower) - : m_txVector (txVector), +InterferenceHelper::Event::Event (Ptr packet, WifiTxVector txVector, Time duration, double rxPower) + : m_packet (packet), + m_txVector (txVector), m_startTime (Simulator::Now ()), m_endTime (m_startTime + duration), m_rxPowerW (rxPower) @@ -45,6 +46,12 @@ InterferenceHelper::Event::~Event () { } +Ptr +InterferenceHelper::Event::GetPacket (void) const +{ + return m_packet; +} + Time InterferenceHelper::Event::GetDuration (void) const { @@ -87,9 +94,10 @@ InterferenceHelper::Event::GetPayloadMode (void) const * short period of time. ****************************************************************/ -InterferenceHelper::NiChange::NiChange (Time time, double delta) +InterferenceHelper::NiChange::NiChange (Time time, double delta, Ptr event) : m_time (time), - m_delta (delta) + m_delta (delta), + m_event (event) { } @@ -105,6 +113,12 @@ InterferenceHelper::NiChange::GetDelta (void) const return m_delta; } +Ptr +InterferenceHelper::NiChange::GetEvent (void) const +{ + return m_event; +} + bool InterferenceHelper::NiChange::operator < (const InterferenceHelper::NiChange& o) const { @@ -131,11 +145,10 @@ InterferenceHelper::~InterferenceHelper () } Ptr -InterferenceHelper::Add (WifiTxVector txVector, Time duration, double rxPowerW) +InterferenceHelper::Add (Ptr packet, WifiTxVector txVector, Time duration, double rxPowerW) { Ptr event; - - event = Create (txVector, duration, rxPowerW); + event = Create (packet, txVector, duration, rxPowerW); AppendEvent (event); return event; } @@ -146,7 +159,8 @@ InterferenceHelper::AddForeignSignal (Time duration, double rxPowerW) // Parameters other than duration and rxPowerW are unused for this type // of signal, so we provide dummy versions WifiTxVector fakeTxVector; - Add (fakeTxVector, duration, rxPowerW); + Ptr packet (0); + Add (packet, fakeTxVector, duration, rxPowerW); } void @@ -214,13 +228,13 @@ InterferenceHelper::AppendEvent (Ptr event) m_firstPower += i->GetDelta (); } m_niChanges.erase (m_niChanges.begin (), nowIterator); - m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW ())); + m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW (), event)); } else { - AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ())); + AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW (), event)); } - AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW ())); + AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW (), event)); } @@ -244,17 +258,41 @@ double InterferenceHelper::CalculateNoiseInterferenceW (Ptr event, NiChanges *ni) const { double noiseInterference = m_firstPower; - NS_ASSERT (m_rxing); - for (NiChanges::const_iterator i = m_niChanges.begin () + 1; i != m_niChanges.end (); i++) + NiChanges::const_iterator eventIterator = m_niChanges.begin (); + while (eventIterator != m_niChanges.end ()) + { + // Iterate the NI change list from the beginning to the end + // until find the position of the event in the NI change list + // The reason of using the event that causes the NI change to identify + // different NI changes is because in some special cases + // different NI changes happen at the same time with the same delta + // value. Therefore, it may be impossible to identify a NI change that belongs + // to which event based on just the NI time and NI delta value + if (eventIterator->GetEvent () != event) + { + // The NI changes which happen before the event should be considered + // as the interference. This considers the case that the receiving event + // arrives while another receiving event is going on. The SINR of + // the newly arrived event is calculated for checking the possibility of frame capture + noiseInterference += eventIterator->GetDelta (); + } + else + { + break; + } + ++eventIterator; + } + + for (NiChanges::const_iterator i = eventIterator + 1; i != m_niChanges.end (); ++i) { - if ((event->GetEndTime () == i->GetTime ()) && event->GetRxPowerW () == -i->GetDelta ()) + if (event->GetEndTime () == i->GetTime () && event == i->GetEvent ()) { break; } ni->push_back (*i); } - ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference)); - ni->push_back (NiChange (event->GetEndTime (), 0)); + ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference, event)); + ni->push_back (NiChange (event->GetEndTime (), 0, event)); return noiseInterference; } @@ -840,7 +878,7 @@ InterferenceHelper::EraseEvents (void) InterferenceHelper::NiChanges::iterator InterferenceHelper::GetPosition (Time moment) { - return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0)); + return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0, NULL)); } void diff --git a/src/wifi/model/interference-helper.h b/src/wifi/model/interference-helper.h index 4bdfd909b5b..bec3b1407a1 100644 --- a/src/wifi/model/interference-helper.h +++ b/src/wifi/model/interference-helper.h @@ -22,6 +22,7 @@ #define INTERFERENCE_HELPER_H #include "ns3/nstime.h" +#include "ns3/packet.h" #include "wifi-tx-vector.h" #include "error-rate-model.h" @@ -43,13 +44,19 @@ class InterferenceHelper /** * Create an Event with the given parameters. * + * \param packet the packet * \param txVector TXVECTOR of the packet * \param duration duration of the signal * \param rxPower the receive power (w) */ - Event (WifiTxVector txVector, Time duration, double rxPower); + Event (Ptr packet, WifiTxVector txVector, Time duration, double rxPower); ~Event (); + /** Return the packet. + * + * \return the packet + */ + Ptr GetPacket (void) const; /** * Return the duration of the signal. * @@ -89,6 +96,7 @@ class InterferenceHelper private: + Ptr m_packet; ///< packet WifiTxVector m_txVector; ///< TXVECTOR Time m_startTime; ///< start time Time m_endTime; ///< end time @@ -152,13 +160,14 @@ class InterferenceHelper /** * Add the packet-related signal to interference helper. * + * \param packet the packet * \param txVector TXVECTOR of the packet * \param duration the duration of the signal * \param rxPower receive power (W) * * \return InterferenceHelper::Event */ - Ptr Add (WifiTxVector txVector, Time duration, double rxPower); + Ptr Add (Ptr packet, WifiTxVector txVector, Time duration, double rxPower); /** * Add a non-Wifi signal to interference helper. @@ -211,8 +220,9 @@ class InterferenceHelper * * \param time time of the event * \param delta the power + * \param event causes this NI change */ - NiChange (Time time, double delta); + NiChange (Time time, double delta, Ptr event); /** * Return the event time. * @@ -225,6 +235,12 @@ class InterferenceHelper * \return the power */ double GetDelta (void) const; + /** + * Return the event causes the corresponding NI change + * + * \return the event + */ + Ptr GetEvent (void) const; /** * Compare the event time of two NiChange objects (a < o). * @@ -237,6 +253,7 @@ class InterferenceHelper private: Time m_time; ///< time double m_delta; ///< delta + Ptr m_event; }; /** * typedef for a vector of NiChanges @@ -309,6 +326,7 @@ class InterferenceHelper NiChanges m_niChanges; double m_firstPower; ///< first power bool m_rxing; ///< flag whether it is in receiving state + /// Returns an iterator to the first nichange, which is later than moment NiChanges::iterator GetPosition (Time moment); /** diff --git a/src/wifi/model/simple-frame-capture-model.cc b/src/wifi/model/simple-frame-capture-model.cc new file mode 100644 index 00000000000..4a40c926abd --- /dev/null +++ b/src/wifi/model/simple-frame-capture-model.cc @@ -0,0 +1,88 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Sébastien Deronne + */ + +#include "simple-frame-capture-model.h" +#include "ns3/simulator.h" +#include "ns3/log.h" +#include "ns3/double.h" +#include "wifi-utils.h" +#include "wifi-phy.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("SimpleFrameCaptureModel"); + +NS_OBJECT_ENSURE_REGISTERED (SimpleFrameCaptureModel); + +TypeId +SimpleFrameCaptureModel::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::SimpleFrameCaptureModel") + .SetParent () + .SetGroupName ("Wifi") + .AddConstructor () + .AddAttribute ("Margin", + "Reception is switched if the newly arrived frame has a power higher than " + "this value above the frame currently being received (expressed in dB).", + DoubleValue (10), + MakeDoubleAccessor (&SimpleFrameCaptureModel::GetMargin, + &SimpleFrameCaptureModel::SetMargin), + MakeDoubleChecker ()) + ; + return tid; +} + +SimpleFrameCaptureModel::SimpleFrameCaptureModel () +{ + NS_LOG_FUNCTION (this); +} + +SimpleFrameCaptureModel::~SimpleFrameCaptureModel () +{ + NS_LOG_FUNCTION (this); +} + +void +SimpleFrameCaptureModel::SetMargin (double margin) +{ + NS_LOG_FUNCTION (this << margin); + m_margin = margin; +} + +double +SimpleFrameCaptureModel::GetMargin (void) const +{ + return m_margin; +} + +bool +SimpleFrameCaptureModel::CaptureNewFrame (Ptr currentEvent, Ptr newEvent) const +{ + NS_LOG_FUNCTION (this); + if (newEvent->GetTxVector ().GetPreambleType () != WIFI_PREAMBLE_NONE + && (WToDbm (currentEvent->GetRxPowerW ()) + m_margin) < WToDbm (newEvent->GetRxPowerW ()) + && ((currentEvent->GetStartTime () + WifiPhy::CalculatePlcpPreambleAndHeaderDuration (currentEvent->GetTxVector ())) > Simulator::Now ())) + { + return true; + } + return false; +} + +} //namespace ns3 diff --git a/src/wifi/model/simple-frame-capture-model.h b/src/wifi/model/simple-frame-capture-model.h new file mode 100644 index 00000000000..b3baabac96b --- /dev/null +++ b/src/wifi/model/simple-frame-capture-model.h @@ -0,0 +1,82 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Sébastien Deronne + */ + +#ifndef SIMPLE_FRAME_CAPTURE_MODEL_H +#define SIMPLE_FRAME_CAPTURE_MODEL_H + +#include "frame-capture-model.h" + +namespace ns3 { +/** + * \ingroup wifi + * + * A simple threshold-based model for frame capture effect. + * If the new incoming frame arrives while the receiver is + * receiving the preamble of another frame and the SIR of + * the new incoming frame is above a fixed margin, then + * the current frame is dropped and the receiver locks + * onto the new incoming frame. + */ +class SimpleFrameCaptureModel : public FrameCaptureModel +{ +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + + SimpleFrameCaptureModel (); + ~SimpleFrameCaptureModel (); + + /** + * Sets the frame capture margin (dB). + * + * \param margin the frame capture margin in dB + */ + void SetMargin (double margin); + /** + * Return the frame capture margin (dB). + * + * \return the frame capture margin in dB + */ + double GetMargin (void) const; + + /** + * This method returns whether the reception should be switched to a + * new incoming frame. + * + * \param currentEvent the event of the current frame + * \param newEvent the event of the new incoming frame + * + * \return true if the reception should be switched to a new incoming frame, + * false otherwise + */ + bool CaptureNewFrame (Ptr currentEvent, Ptr newEvent) const; + + +private: + double m_margin; +}; + +} //namespace ns3 + +#endif /* SIMPLE_FRAME_CAPTURE_MODEL_H */ + diff --git a/src/wifi/model/wifi-phy-state-helper.cc b/src/wifi/model/wifi-phy-state-helper.cc index 7d5d2967be8..2edef4a85ed 100644 --- a/src/wifi/model/wifi-phy-state-helper.cc +++ b/src/wifi/model/wifi-phy-state-helper.cc @@ -221,6 +221,7 @@ WifiPhyStateHelper::GetState (void) const void WifiPhyStateHelper::NotifyTxStart (Time duration, double txPowerDbm) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyTxStart (duration, txPowerDbm); @@ -230,6 +231,7 @@ WifiPhyStateHelper::NotifyTxStart (Time duration, double txPowerDbm) void WifiPhyStateHelper::NotifyRxStart (Time duration) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyRxStart (duration); @@ -239,6 +241,7 @@ WifiPhyStateHelper::NotifyRxStart (Time duration) void WifiPhyStateHelper::NotifyRxEndOk (void) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyRxEndOk (); @@ -248,6 +251,7 @@ WifiPhyStateHelper::NotifyRxEndOk (void) void WifiPhyStateHelper::NotifyRxEndError (void) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyRxEndError (); @@ -257,6 +261,7 @@ WifiPhyStateHelper::NotifyRxEndError (void) void WifiPhyStateHelper::NotifyMaybeCcaBusyStart (Time duration) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyMaybeCcaBusyStart (duration); @@ -266,6 +271,7 @@ WifiPhyStateHelper::NotifyMaybeCcaBusyStart (Time duration) void WifiPhyStateHelper::NotifySwitchingStart (Time duration) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifySwitchingStart (duration); @@ -275,6 +281,7 @@ WifiPhyStateHelper::NotifySwitchingStart (Time duration) void WifiPhyStateHelper::NotifySleep (void) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifySleep (); @@ -284,6 +291,7 @@ WifiPhyStateHelper::NotifySleep (void) void WifiPhyStateHelper::NotifyWakeup (void) { + NS_LOG_FUNCTION (this); for (Listeners::const_iterator i = m_listeners.begin (); i != m_listeners.end (); i++) { (*i)->NotifyWakeup (); @@ -293,6 +301,7 @@ WifiPhyStateHelper::NotifyWakeup (void) void WifiPhyStateHelper::LogPreviousIdleAndCcaBusyStates (void) { + NS_LOG_FUNCTION (this); Time now = Simulator::Now (); Time idleStart = Max (m_endCcaBusy, m_endRx); idleStart = Max (idleStart, m_endTx); @@ -314,6 +323,7 @@ void WifiPhyStateHelper::SwitchToTx (Time txDuration, Ptr packet, double txPowerDbm, WifiTxVector txVector) { + NS_LOG_FUNCTION (this << txDuration << packet << txPowerDbm << txVector); m_txTrace (packet, txVector.GetMode (), txVector.GetPreambleType (), txVector.GetTxPowerLevel ()); Time now = Simulator::Now (); switch (GetState ()) @@ -352,6 +362,7 @@ WifiPhyStateHelper::SwitchToTx (Time txDuration, Ptr packet, doubl void WifiPhyStateHelper::SwitchToRx (Time rxDuration) { + NS_LOG_FUNCTION (this << rxDuration); NS_ASSERT (IsStateIdle () || IsStateCcaBusy ()); NS_ASSERT (!m_rxing); Time now = Simulator::Now (); @@ -385,6 +396,7 @@ WifiPhyStateHelper::SwitchToRx (Time rxDuration) void WifiPhyStateHelper::SwitchToChannelSwitching (Time switchingDuration) { + NS_LOG_FUNCTION (this << switchingDuration); Time now = Simulator::Now (); switch (GetState ()) { @@ -430,6 +442,7 @@ WifiPhyStateHelper::SwitchToChannelSwitching (Time switchingDuration) void WifiPhyStateHelper::SwitchFromRxEndOk (Ptr packet, double snr, WifiTxVector txVector) { + NS_LOG_FUNCTION (this << packet << snr << txVector); m_rxOkTrace (packet, snr, txVector.GetMode (), txVector.GetPreambleType ()); NotifyRxEndOk (); DoSwitchFromRx (); @@ -443,6 +456,7 @@ WifiPhyStateHelper::SwitchFromRxEndOk (Ptr packet, double snr, WifiTxVec void WifiPhyStateHelper::SwitchFromRxEndError (Ptr packet, double snr) { + NS_LOG_FUNCTION (this << packet << snr); m_rxErrorTrace (packet, snr); NotifyRxEndError (); DoSwitchFromRx (); @@ -455,6 +469,7 @@ WifiPhyStateHelper::SwitchFromRxEndError (Ptr packet, double snr) void WifiPhyStateHelper::DoSwitchFromRx (void) { + NS_LOG_FUNCTION (this); NS_ASSERT (IsStateRx ()); NS_ASSERT (m_rxing); @@ -469,6 +484,7 @@ WifiPhyStateHelper::DoSwitchFromRx (void) void WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration) { + NS_LOG_FUNCTION (this << duration); NotifyMaybeCcaBusyStart (duration); Time now = Simulator::Now (); switch (GetState ()) @@ -497,6 +513,7 @@ WifiPhyStateHelper::SwitchMaybeToCcaBusy (Time duration) void WifiPhyStateHelper::SwitchToSleep (void) { + NS_LOG_FUNCTION (this); Time now = Simulator::Now (); switch (GetState ()) { @@ -527,6 +544,7 @@ WifiPhyStateHelper::SwitchToSleep (void) void WifiPhyStateHelper::SwitchFromSleep (Time duration) { + NS_LOG_FUNCTION (this << duration); NS_ASSERT (IsStateSleep ()); Time now = Simulator::Now (); m_stateLogger (m_startSleep, now - m_startSleep, WifiPhy::SLEEP); @@ -541,4 +559,15 @@ WifiPhyStateHelper::SwitchFromSleep (Time duration) } } +void +WifiPhyStateHelper::SwitchFromRxAbort (void) +{ + NS_LOG_FUNCTION (this); + NS_ASSERT (IsStateRx ()); + NS_ASSERT (m_rxing); + m_endRx = Simulator::Now (); + DoSwitchFromRx (); + NS_ASSERT (!IsStateRx ()); +} + } //namespace ns3 diff --git a/src/wifi/model/wifi-phy-state-helper.h b/src/wifi/model/wifi-phy-state-helper.h index b43c5b3c2d3..0faadf8fd0f 100644 --- a/src/wifi/model/wifi-phy-state-helper.h +++ b/src/wifi/model/wifi-phy-state-helper.h @@ -185,6 +185,10 @@ class WifiPhyStateHelper : public Object * \param duration the duration of CCA busy state */ void SwitchFromSleep (Time duration); + /** + * Abort current reception + */ + void SwitchFromRxAbort (void); /** * TracedCallback signature for state changes. diff --git a/src/wifi/model/wifi-phy.cc b/src/wifi/model/wifi-phy.cc index 52df0662f57..65acebf6647 100644 --- a/src/wifi/model/wifi-phy.cc +++ b/src/wifi/model/wifi-phy.cc @@ -30,6 +30,7 @@ #include "wifi-phy-tag.h" #include "ampdu-tag.h" #include "wifi-utils.h" +#include "frame-capture-model.h" namespace ns3 { @@ -314,6 +315,12 @@ WifiPhy::GetTypeId (void) MakeBooleanAccessor (&WifiPhy::GetShortPlcpPreambleSupported, &WifiPhy::SetShortPlcpPreambleSupported), MakeBooleanChecker ()) + .AddAttribute ("FrameCaptureModel", + "Ptr to an object that implements the frame capture model", + PointerValue (0), //StringValue ("ns3::SimpleFrameCaptureModel"), + MakePointerAccessor (&WifiPhy::GetFrameCaptureModel, + &WifiPhy::SetFrameCaptureModel), + MakePointerChecker ()) .AddTraceSource ("PhyTxBegin", "Trace source indicating a packet " "has begun transmitting over the channel medium", @@ -378,7 +385,8 @@ WifiPhy::WifiPhy () m_channelNumber (0), m_initialChannelNumber (0), m_totalAmpduSize (0), - m_totalAmpduNumSymbols (0) + m_totalAmpduNumSymbols (0), + m_currentEvent (0) { NS_LOG_FUNCTION (this); NS_UNUSED (m_numberOfTransmitters); @@ -702,6 +710,18 @@ WifiPhy::GetErrorRateModel (void) const return m_interference.GetErrorRateModel (); } +void +WifiPhy::SetFrameCaptureModel (Ptr model) +{ + m_frameCaptureModel = model; +} + +Ptr +WifiPhy::GetFrameCaptureModel (void) const +{ + return m_frameCaptureModel; +} + double WifiPhy::GetPowerDbm (uint8_t power) const { @@ -2356,7 +2376,6 @@ WifiPhy::StartReceivePreambleAndHeader (Ptr packet, double rxPowerW, Tim //This function should be later split to check separately whether plcp preamble and plcp header can be successfully received. //Note: plcp preamble reception is not yet modeled. NS_LOG_FUNCTION (this << packet << WToDbm (rxPowerW) << rxDuration); - AmpduTag ampduTag; Time endRx = Simulator::Now () + rxDuration; WifiPhyTag tag; @@ -2380,15 +2399,13 @@ WifiPhy::StartReceivePreambleAndHeader (Ptr packet, double rxPowerW, Tim NS_FATAL_ERROR ("Reception ends in failure because of an unsupported number of spatial streams"); } - WifiPreamble preamble = txVector.GetPreambleType (); - MpduType mpdutype = tag.GetMpduType (); - Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector); - Ptr event; - event = m_interference.Add (txVector, + event = m_interference.Add (packet, + txVector, rxDuration, rxPowerW); + MpduType mpdutype = tag.GetMpduType (); switch (m_state->GetState ()) { case WifiPhy::SWITCHING: @@ -2407,18 +2424,31 @@ WifiPhy::StartReceivePreambleAndHeader (Ptr packet, double rxPowerW, Tim { //that packet will be noise _after_ the completion of the //channel switching. - goto maybeCcaBusy; + MaybeCcaBusyDuration (); + return; } break; case WifiPhy::RX: - NS_LOG_DEBUG ("drop packet because already in Rx (power=" << - rxPowerW << "W)"); - NotifyRxDrop (packet); - if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ()) + NS_ASSERT (m_currentEvent != 0); + if (m_frameCaptureModel != 0 && + m_frameCaptureModel->CaptureNewFrame(m_currentEvent, event)) + { + AbortCurrentReception (); + NS_LOG_DEBUG ("Switch to new packet"); + StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event); + } + else { - //that packet will be noise _after_ the reception of the - //currently-received packet. - goto maybeCcaBusy; + NS_LOG_DEBUG ("drop packet because already in Rx (power=" << + rxPowerW << "W)"); + NotifyRxDrop (packet); + if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ()) + { + //that packet will be noise _after_ the reception of the + //currently-received packet. + MaybeCcaBusyDuration (); + return; + } } break; case WifiPhy::TX: @@ -2429,77 +2459,13 @@ WifiPhy::StartReceivePreambleAndHeader (Ptr packet, double rxPowerW, Tim { //that packet will be noise _after_ the transmission of the //currently-transmitted packet. - goto maybeCcaBusy; + MaybeCcaBusyDuration (); + return; } break; case WifiPhy::CCA_BUSY: case WifiPhy::IDLE: - if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration) - { - if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false)) - { - m_plcpSuccess = false; - m_mpdusNum = 0; - NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received"); - NotifyRxDrop (packet); - goto maybeCcaBusy; - } - else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0) - { - //received the first MPDU in an MPDU - m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); - m_rxMpduReferenceNumber++; - } - else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0) - { - //received the other MPDUs that are part of the A-MPDU - if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1)) - { - NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ()); - m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); - } - else - { - m_mpdusNum--; - } - } - else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0) - { - NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost"); - m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); - } - else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 ) - { - NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum); - m_mpdusNum = 0; - } - - NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)"); - //sync to signal - m_state->SwitchToRx (rxDuration); - NS_ASSERT (m_endPlcpRxEvent.IsExpired ()); - NotifyRxBegin (packet); - m_interference.NotifyRxStart (); - - if (preamble != WIFI_PREAMBLE_NONE) - { - NS_ASSERT (m_endPlcpRxEvent.IsExpired ()); - m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this, - packet, txVector, mpdutype, event); - } - - NS_ASSERT (m_endRxEvent.IsExpired ()); - m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this, - packet, preamble, mpdutype, event); - } - else - { - NS_LOG_DEBUG ("drop packet because signal power too Small (" << - rxPowerW << "<" << GetEdThresholdW () << ")"); - NotifyRxDrop (packet); - m_plcpSuccess = false; - goto maybeCcaBusy; - } + StartRx (packet, txVector, mpdutype, rxPowerW, rxDuration, event); break; case WifiPhy::SLEEP: NS_LOG_DEBUG ("drop packet because in sleep mode"); @@ -2507,10 +2473,11 @@ WifiPhy::StartReceivePreambleAndHeader (Ptr packet, double rxPowerW, Tim m_plcpSuccess = false; break; } +} - return; - -maybeCcaBusy: +void +WifiPhy::MaybeCcaBusyDuration () +{ //We are here because we have received the first bit of a packet and we are //not going to be able to synchronize on it //In this model, CCA becomes busy when the aggregation of all signals as @@ -2571,6 +2538,7 @@ WifiPhy::EndReceive (Ptr packet, WifiPreamble preamble, MpduType mpdutyp InterferenceHelper::SnrPer snrPer; snrPer = m_interference.CalculatePlcpPayloadSnrPer (event); m_interference.NotifyRxEnd (); + m_currentEvent = 0; if (m_plcpSuccess == true) { @@ -3661,6 +3629,100 @@ WifiPhy::SwitchMaybeToCcaBusy (void) } } +void +WifiPhy::AbortCurrentReception () +{ + NS_LOG_FUNCTION (this); + if (m_endPlcpRxEvent.IsRunning ()) + { + m_endPlcpRxEvent.Cancel (); + } + if (m_endRxEvent.IsRunning ()) + { + m_endRxEvent.Cancel (); + } + NotifyRxDrop (m_currentEvent->GetPacket ()); + m_interference.NotifyRxEnd (); + m_state->SwitchFromRxAbort (); + m_currentEvent = 0; +} + +void +WifiPhy::StartRx (Ptr packet, WifiTxVector txVector, MpduType mpdutype, double rxPowerW, Time rxDuration, Ptr event) +{ + NS_LOG_FUNCTION (this << packet << txVector << (uint16_t)mpdutype << rxPowerW << rxDuration); + if (rxPowerW > GetEdThresholdW ()) //checked here, no need to check in the payload reception (current implementation assumes constant rx power over the packet duration) + { + AmpduTag ampduTag; + WifiPreamble preamble = txVector.GetPreambleType (); + if (preamble == WIFI_PREAMBLE_NONE && (m_mpdusNum == 0 || m_plcpSuccess == false)) + { + m_plcpSuccess = false; + m_mpdusNum = 0; + NS_LOG_DEBUG ("drop packet because no PLCP preamble/header has been received"); + NotifyRxDrop (packet); + MaybeCcaBusyDuration (); + return; + } + else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum == 0) + { + //received the first MPDU in an MPDU + m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); + m_rxMpduReferenceNumber++; + } + else if (preamble == WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0) + { + //received the other MPDUs that are part of the A-MPDU + if (ampduTag.GetRemainingNbOfMpdus () < (m_mpdusNum - 1)) + { + NS_LOG_DEBUG ("Missing MPDU from the A-MPDU " << m_mpdusNum - ampduTag.GetRemainingNbOfMpdus ()); + m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); + } + else + { + m_mpdusNum--; + } + } + else if (preamble != WIFI_PREAMBLE_NONE && packet->PeekPacketTag (ampduTag) && m_mpdusNum > 0) + { + NS_LOG_DEBUG ("New A-MPDU started while " << m_mpdusNum << " MPDUs from previous are lost"); + m_mpdusNum = ampduTag.GetRemainingNbOfMpdus (); + } + else if (preamble != WIFI_PREAMBLE_NONE && m_mpdusNum > 0 ) + { + NS_LOG_DEBUG ("Didn't receive the last MPDUs from an A-MPDU " << m_mpdusNum); + m_mpdusNum = 0; + } + + NS_LOG_DEBUG ("sync to signal (power=" << rxPowerW << "W)"); + m_currentEvent = event; + m_state->SwitchToRx (rxDuration); + NS_ASSERT (m_endPlcpRxEvent.IsExpired ()); + NotifyRxBegin (packet); + m_interference.NotifyRxStart (); + + if (preamble != WIFI_PREAMBLE_NONE) + { + NS_ASSERT (m_endPlcpRxEvent.IsExpired ()); + Time preambleAndHeaderDuration = CalculatePlcpPreambleAndHeaderDuration (txVector); + m_endPlcpRxEvent = Simulator::Schedule (preambleAndHeaderDuration, &WifiPhy::StartReceivePacket, this, + packet, txVector, mpdutype, event); + } + + NS_ASSERT (m_endRxEvent.IsExpired ()); + m_endRxEvent = Simulator::Schedule (rxDuration, &WifiPhy::EndReceive, this, + packet, preamble, mpdutype, event); + } + else + { + NS_LOG_DEBUG ("drop packet because signal power too Small (" << + rxPowerW << "<" << GetEdThresholdW () << ")"); + NotifyRxDrop (packet); + m_plcpSuccess = false; + MaybeCcaBusyDuration (); + } +} + int64_t WifiPhy::AssignStreams (int64_t stream) { diff --git a/src/wifi/model/wifi-phy.h b/src/wifi/model/wifi-phy.h index 383ab83a341..3dea8d3edc1 100644 --- a/src/wifi/model/wifi-phy.h +++ b/src/wifi/model/wifi-phy.h @@ -25,13 +25,13 @@ #include #include "ns3/callback.h" #include "ns3/event-id.h" -#include "ns3/packet.h" #include "ns3/mobility-model.h" #include "ns3/random-variable-stream.h" #include "ns3/channel.h" #include "wifi-phy-standard.h" #include "interference-helper.h" #include "ns3/node.h" +#include "ns3/string.h" namespace ns3 { @@ -44,6 +44,11 @@ namespace ns3 { */ class WifiPhyStateHelper; +/** + * FrameCaptureModel class + */ +class FrameCaptureModel; + /** * This enumeration defines the type of an MPDU. */ @@ -371,7 +376,7 @@ class WifiPhy : public Object * * \return the total amount of time this PHY will stay busy for the transmission of the PLCP preamble and PLCP header. */ - Time CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector); + static Time CalculatePlcpPreambleAndHeaderDuration (WifiTxVector txVector); /** * \param txVector the transmission parameters used for this packet @@ -1445,6 +1450,7 @@ class WifiPhy : public Object * \return the reception gain in dB */ double GetRxGain (void) const; + /** * Sets the device this PHY is associated with. * @@ -1602,6 +1608,19 @@ class WifiPhy : public Object */ Ptr GetErrorRateModel (void) const; + /** + * Sets the frame capture model. + * + * \param rate the frame capture model + */ + void SetFrameCaptureModel (Ptr rate); + /** + * Return the frame capture model this PHY is using. + * + * \return the frame capture model this PHY is using + */ + Ptr GetFrameCaptureModel (void) const; + /** * \return the channel width */ @@ -1771,6 +1790,34 @@ class WifiPhy : public Object * \return the FrequencyWidthPair found */ FrequencyWidthPair GetFrequencyWidthForChannelNumberStandard (uint8_t channelNumber, WifiPhyStandard standard) const; + + /** + * Due to newly arrived signal, the current reception cannot be continued and has to be aborted + * + */ + void AbortCurrentReception (void); + + /** + * Eventually switch to CCA busy + */ + void MaybeCcaBusyDuration (void); + + /** + * Starting receiving the packet after having detected the medium is idle or after a reception switch. + * + * \param packet the arriving packet + * \param txVector the TXVECTOR of the arriving packet + * \param mpdutype the type of the MPDU as defined in WifiPhy::MpduType. + * \param rxPowerW the receive power in W + * \param rxDuration the duration needed for the reception of the packet + * \param event the corresponding event of the first time the packet arrives + */ + void StartRx (Ptr packet, + WifiTxVector txVector, + MpduType mpdutype, + double rxPowerW, + Time rxDuration, + Ptr event); /** * The trace source fired when a packet begins the transmission process on @@ -1931,6 +1978,9 @@ class WifiPhy : public Object Ptr m_device; //!< Pointer to the device Ptr m_mobility; //!< Pointer to the mobility model + + Ptr m_currentEvent; //!< Hold the current event + Ptr m_frameCaptureModel; //!< Frame capture model }; /** diff --git a/src/wifi/test/examples-to-run.py b/src/wifi/test/examples-to-run.py index ee0c3d00cc4..55987376c01 100644 --- a/src/wifi/test/examples-to-run.py +++ b/src/wifi/test/examples-to-run.py @@ -343,6 +343,8 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), + ("test-interference-helper --enableCapture=0 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=0", "True", "True"), + ("test-interference-helper --enableCapture=1 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=1", "True", "True"), ] # A list of Python examples to run in order to ensure that they remain diff --git a/src/wifi/wscript b/src/wifi/wscript index 7542aa36c91..a8ddd1df05f 100644 --- a/src/wifi/wscript +++ b/src/wifi/wscript @@ -83,6 +83,8 @@ def build(bld): 'model/dsss-parameter-set.cc', 'model/edca-parameter-set.cc', 'model/he-capabilities.cc', + 'model/frame-capture-model.cc', + 'model/simple-frame-capture-model.cc', 'helper/wifi-radio-energy-model-helper.cc', 'helper/vht-wifi-mac-helper.cc', 'helper/ht-wifi-mac-helper.cc', @@ -190,6 +192,8 @@ def build(bld): 'model/dsss-parameter-set.h', 'model/edca-parameter-set.h', 'model/he-capabilities.h', + 'model/frame-capture-model.h', + 'model/simple-frame-capture-model.h', 'helper/wifi-radio-energy-model-helper.h', 'helper/vht-wifi-mac-helper.h', 'helper/ht-wifi-mac-helper.h', From 766b6c5efbf007c7f6b5640479f416b1d9a4ff11 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 7 May 2017 10:13:41 -0700 Subject: [PATCH 031/551] internet: Fix and update documentation --- src/internet/doc/routing-overview.rst | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/internet/doc/routing-overview.rst b/src/internet/doc/routing-overview.rst index 744a020e6f1..f5644e6374f 100644 --- a/src/internet/doc/routing-overview.rst +++ b/src/internet/doc/routing-overview.rst @@ -215,25 +215,22 @@ is finally used to populate the routes themselves. Unicast routing *************** -There are presently eigth unicast routing protocols defined for IPv4 and three for -IPv6: +The following unicast routing protocols are defined for IPv4 and IPv6: -* class Ipv4StaticRouting (covering both unicast and multicast) -* IPv4 Optimized Link State Routing (OLSR) (a MANET protocol defined in - :rfc:`3626`) -* IPv4 Ad Hoc On Demand Distance Vector (AODV) (a MANET protocol defined in - :rfc:`3561`) -* IPv4 Destination Sequenced Distance Vector (DSDV) (a MANET protocol) -* IPv4 Dynamic Source Routing (DSR) (a MANET protocol) -* class Ipv4ListRouting (used to store a prioritized list of routing protocols) +* classes Ipv4ListRouting and Ipv6ListRouting (used to store a prioritized list of routing protocols) +* classes Ipv4StaticRouting and Ipv6StaticRouting (covering both unicast and multicast) * class Ipv4GlobalRouting (used to store routes computed by the global route manager, if that is used) * class Ipv4NixVectorRouting (a more efficient version of global routing that stores source routes in a packet header field) * class Rip - the IPv4 RIPv2 protocol (:rfc:`2453`) -* class Ipv6ListRouting (used to store a prioritized list of routing protocols) -* class Ipv6StaticRouting * class RipNg - the IPv6 RIPng protocol (:rfc:`2080`) +* IPv4 Optimized Link State Routing (OLSR) (a MANET protocol defined in + :rfc:`3626`) +* IPv4 Ad Hoc On Demand Distance Vector (AODV) (a MANET protocol defined in + :rfc:`3561`) +* IPv4 Destination Sequenced Distance Vector (DSDV) (a MANET protocol) +* IPv4 Dynamic Source Routing (DSR) (a MANET protocol) In the future, this architecture should also allow someone to implement a Linux-like implementation with routing cache, or a Click modular router, but From 96ef935b26a2bfbf3779e07c1d1a25d94ffe7537 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Sun, 7 May 2017 20:07:34 +0200 Subject: [PATCH 032/551] wifi: (fixes #2621) Fix mismatch between log message and action --- src/wifi/model/edca-txop-n.cc | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index 6c7dd1c6c6d..daef99e4416 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -416,12 +416,7 @@ void EdcaTxopN::NotifyInternalCollision (void) else { NS_LOG_DEBUG ("Dequeueing and discarding head of queue"); - Ptr item = m_queue->Peek (); - if (item) - { - packet = item->GetPacket (); - header = item->GetHeader (); - } + m_queue->Remove (); } m_dcf->ResetCw (); } From 7644e597526a67ed182ff46b2b9b566eed5acf51 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Sun, 7 May 2017 20:07:56 +0200 Subject: [PATCH 033/551] wifi: Prevent Peek() from returning a stale item --- src/wifi/model/wifi-mac-queue.cc | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index 9d5f68e10bb..5ceae0da5b7 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -274,7 +274,18 @@ Ptr WifiMacQueue::Peek (void) const { NS_LOG_FUNCTION (this); - return DoPeek (Head ()); + + for (auto it = Head (); it != Tail (); it++) + { + // skip packets that stayed in the queue for too long. They will be + // actually removed from the queue by the next call to a non-const method + if (Simulator::Now () <= (*it)->GetTimeStamp () + m_maxDelay) + { + return DoPeek (it); + } + } + NS_LOG_DEBUG ("The queue is empty"); + return 0; } template<> From a5433ee26c03a7dae7189ff1b5205f4348d238ac Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sun, 7 May 2017 11:21:08 -0700 Subject: [PATCH 034/551] internet: Fix documentation typo --- src/internet/doc/routing-overview.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/internet/doc/routing-overview.rst b/src/internet/doc/routing-overview.rst index f5644e6374f..219441875f5 100644 --- a/src/internet/doc/routing-overview.rst +++ b/src/internet/doc/routing-overview.rst @@ -253,8 +253,8 @@ a single table, approaches where more information than destination IP address (e.g., source routing) is used to determine the next hop, and on-demand routing approaches where packets must be cached. -Ipv[4,6]4ListRouting::AddRoutingProtocol -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Ipv[4,6]ListRouting::AddRoutingProtocol +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Classes Ipv4ListRouting and Ipv6ListRouting provides a pure virtual function declaration for the method that allows one to add a routing protocol:: From ed87722432a30e519c2895247b0e248844b5cc5e Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Tue, 9 May 2017 07:43:45 -0700 Subject: [PATCH 035/551] dsr: Correct Doxygen warnings --- src/dsr/examples/dsr.cc | 4 +- src/dsr/helper/dsr-helper.h | 18 +- src/dsr/helper/dsr-main-helper.h | 22 +- src/dsr/model/dsr-errorbuff.cc | 8 +- src/dsr/model/dsr-errorbuff.h | 90 ++++++- src/dsr/model/dsr-fs-header.h | 2 +- src/dsr/model/dsr-gratuitous-reply-table.cc | 2 +- src/dsr/model/dsr-gratuitous-reply-table.h | 26 +- src/dsr/model/dsr-maintain-buff.cc | 8 +- src/dsr/model/dsr-maintain-buff.h | 257 ++++++++++++++---- src/dsr/model/dsr-network-queue.cc | 2 +- src/dsr/model/dsr-network-queue.h | 72 ++++- src/dsr/model/dsr-option-header.cc | 6 +- src/dsr/model/dsr-option-header.h | 21 +- src/dsr/model/dsr-options.cc | 240 ++++++++--------- src/dsr/model/dsr-options.h | 34 ++- src/dsr/model/dsr-passive-buff.cc | 10 +- src/dsr/model/dsr-passive-buff.h | 103 ++++++- src/dsr/model/dsr-rcache.cc | 21 +- src/dsr/model/dsr-rcache.h | 271 +++++++++++++++++-- src/dsr/model/dsr-routing.cc | 280 ++++++++++---------- src/dsr/model/dsr-routing.h | 83 +++++- src/dsr/model/dsr-rreq-table.h | 7 +- src/dsr/model/dsr-rsendbuff.cc | 7 +- src/dsr/model/dsr-rsendbuff.h | 37 ++- src/dsr/test/dsr-test-suite.cc | 97 ++++++- 26 files changed, 1305 insertions(+), 423 deletions(-) diff --git a/src/dsr/examples/dsr.cc b/src/dsr/examples/dsr.cc index 907de21390a..9a42ba721b6 100644 --- a/src/dsr/examples/dsr.cc +++ b/src/dsr/examples/dsr.cc @@ -155,8 +155,8 @@ main (int argc, char *argv[]) std::ostringstream pauseConstantRandomVariableStream; pauseConstantRandomVariableStream << "ns3::ConstantRandomVariable[Constant=" - << pauseTime - << "]"; + << pauseTime + << "]"; adhocMobility.SetMobilityModel ("ns3::RandomWaypointMobilityModel", // "Speed", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=nodeSpeed]"), diff --git a/src/dsr/helper/dsr-helper.h b/src/dsr/helper/dsr-helper.h index bb4015936ae..f6ec94486f0 100644 --- a/src/dsr/helper/dsr-helper.h +++ b/src/dsr/helper/dsr-helper.h @@ -41,6 +41,14 @@ #include "ns3/icmpv4-l4-protocol.h" namespace ns3 { + +/** + * \ingroup dsr + * + * \brief DSR helper class to manage creation of DSR routing instance and + * to insert it on a node as a sublayer between transport and + * IP layers. + */ class DsrHelper { public: @@ -67,15 +75,21 @@ class DsrHelper * \returns a newly-created L4 protocol */ Ptr Create (Ptr node) const; + /** + * Set attribute values for future instances of DSR that this helper creates + * \param name the node on which the routing protocol will run + * \param value newly-created L4 protocol + */ void Set (std::string name, const AttributeValue &value); private: /** * \brief Assignment operator declared private and not implemented to disallow * assignment and prevent the compiler from happily inserting its own. + * \param o source object + * \return DsrHelper object */ DsrHelper & operator = (const DsrHelper &o); - ObjectFactory m_agentFactory; - NodeContainer m_nodes; + ObjectFactory m_agentFactory; ///< DSR factory }; } // namespace ns3 diff --git a/src/dsr/helper/dsr-main-helper.h b/src/dsr/helper/dsr-main-helper.h index f46924dbfe0..a58db7ab302 100644 --- a/src/dsr/helper/dsr-main-helper.h +++ b/src/dsr/helper/dsr-main-helper.h @@ -39,7 +39,10 @@ #include "ns3/dsr-helper.h" namespace ns3 { + /** + * \ingroup dsr + * * \brief Helper class that adds DSR routing to nodes. */ class DsrMainHelper @@ -56,17 +59,32 @@ class DsrMainHelper * (Copy Constructor). */ DsrMainHelper (const DsrMainHelper &); + /** + * Install routing to the nodes + * \param dsrHelper The DSR helper class + * \param nodes the collection of nodes + */ void Install (DsrHelper &dsrHelper, NodeContainer nodes); + /** + * Set the helper class + * \param dsrHelper the DSR helper class + */ void SetDsrHelper (DsrHelper &dsrHelper); private: + /** + * Install routing to a node + * \param node the node to install DSR routing + */ void Install (Ptr node); /** * \brief Assignment operator declared private and not implemented to disallow * assignment and prevent the compiler from happily inserting its own. - */ + * \param o source object to assign + * \return DsrHelper object + */ DsrMainHelper &operator = (const DsrMainHelper &o); - const DsrHelper *m_dsrHelper; + const DsrHelper *m_dsrHelper; ///< helper class }; } // namespace ns3 diff --git a/src/dsr/model/dsr-errorbuff.cc b/src/dsr/model/dsr-errorbuff.cc index e04b1ace6f8..b947a090f6a 100644 --- a/src/dsr/model/dsr-errorbuff.cc +++ b/src/dsr/model/dsr-errorbuff.cc @@ -39,7 +39,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrErrorBuffer"); - + namespace dsr { uint32_t @@ -143,8 +143,14 @@ DsrErrorBuffer::Find (Ipv4Address dst) return false; } +/// IsExpired structure struct IsExpired { + /** + * \brief comparison operator + * \param e entry to compare + * \return true if entry expired + */ bool operator() (DsrErrorBuffEntry const & e) const { diff --git a/src/dsr/model/dsr-errorbuff.h b/src/dsr/model/dsr-errorbuff.h index 5db0157205e..31d81ac2f77 100644 --- a/src/dsr/model/dsr-errorbuff.h +++ b/src/dsr/model/dsr-errorbuff.h @@ -56,7 +56,7 @@ class DsrErrorBuffEntry * \param p protocol number */ DsrErrorBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (), - Ipv4Address n = Ipv4Address (), Time exp = Simulator::Now (), uint8_t p = 0) + Ipv4Address n = Ipv4Address (), Time exp = Simulator::Now (), uint8_t p = 0) : m_packet (pa), m_dst (d), m_source (s), @@ -74,52 +74,100 @@ class DsrErrorBuffEntry { return ((m_packet == o.m_packet) && (m_source == o.m_source) && (m_nextHop == o.m_nextHop) && (m_dst == o.m_dst) && (m_expire == o.m_expire)); } - + // Fields + /** + * Get packet from entry + * \returns the packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set packet for entry + * \param p the packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get destination address + * \returns the destination IPv4 address + */ Ipv4Address GetDestination () const { return m_dst; } + /** + * Set destination address + * \param d the destination IPv4 address + */ void SetDestination (Ipv4Address d) { m_dst = d; } + /** + * Get source address + * \returns the source IPv4 address + */ Ipv4Address GetSource () const { return m_source; } + /** + * Set source address + * \param s the source IPv4 address + */ void SetSource (Ipv4Address s) { m_source = s; } + /** + * Get next hop + * \returns the next hop address + */ Ipv4Address GetNextHop () const { return m_nextHop; } + /** + * Set next hop + * \param n the next hop IPv4 address + */ void SetNextHop (Ipv4Address n) { m_nextHop = n; } + /** + * Set expire time + * \param exp the expire time + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expire time + * \returns the expire time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); } + /** + * Set protocol number + * \param p the protocol number + */ void SetProtocol (uint8_t p) { m_protocol = p; } + /** + * Get protocol number + * \returns the protocol number + */ uint8_t GetProtocol () const { return m_protocol; @@ -127,15 +175,15 @@ class DsrErrorBuffEntry private: /// Data packet - Ptr m_packet; + Ptr m_packet; ///< the packet /// Destination address - Ipv4Address m_dst; + Ipv4Address m_dst; ///< destination address /// Source address - Ipv4Address m_source; + Ipv4Address m_source; ///< source address /// Nexthop address - Ipv4Address m_nextHop; + Ipv4Address m_nextHop; ///< next hop /// Expire time for queue entry - Time m_expire; + Time m_expire; ///< expiration time /// The protocol number uint8_t m_protocol; }; @@ -154,7 +202,12 @@ class DsrErrorBuffer DsrErrorBuffer () { } - /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + /** + * Push entry in queue, if there is no entry with the same packet and destination address in queue. + * + * \param entry error buffer entry + * \return true if entry added + */ bool Enqueue (DsrErrorBuffEntry & entry); /// Return first found (the earliest) entry for given destination bool Dequeue (Ipv4Address dst, DsrErrorBuffEntry & entry); @@ -166,23 +219,42 @@ class DsrErrorBuffer uint32_t GetSize (); // Fields + /** + * Get maximum queue length + * \returns the maximum queue length + */ uint32_t GetMaxQueueLen () const { return m_maxLen; } + /** + * Set maximum queue length + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } + /** + * Get error buffer timeout + * \returns the error buffer timeout + */ Time GetErrorBufferTimeout () const { return m_errorBufferTimeout; } + /** + * Set error buffer timeout + * \param t the error buffer timeout + */ void SetErrorBufferTimeout (Time t) { m_errorBufferTimeout = t; } - + /** + * Get error buffer entry + * \returns the DSR error buffer + */ std::vector & GetBuffer () { return m_errorBuffer; diff --git a/src/dsr/model/dsr-fs-header.h b/src/dsr/model/dsr-fs-header.h index b1420dc306c..9dfd8f1c495 100644 --- a/src/dsr/model/dsr-fs-header.h +++ b/src/dsr/model/dsr-fs-header.h @@ -198,7 +198,7 @@ class DsrFsHeader : public Header }; /** - * \class OptionField + * \class DsrOptionField * \brief Option field for an DsrFsHeader * Enables adding options to an DsrFsHeader * diff --git a/src/dsr/model/dsr-gratuitous-reply-table.cc b/src/dsr/model/dsr-gratuitous-reply-table.cc index 3ee648938b3..38a1b3dcfe7 100644 --- a/src/dsr/model/dsr-gratuitous-reply-table.cc +++ b/src/dsr/model/dsr-gratuitous-reply-table.cc @@ -36,7 +36,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrGraReplyTable"); - + namespace dsr { NS_OBJECT_ENSURE_REGISTERED (DsrGraReply); diff --git a/src/dsr/model/dsr-gratuitous-reply-table.h b/src/dsr/model/dsr-gratuitous-reply-table.h index 437d638957a..bd36e8914cd 100644 --- a/src/dsr/model/dsr-gratuitous-reply-table.h +++ b/src/dsr/model/dsr-gratuitous-reply-table.h @@ -40,17 +40,24 @@ namespace ns3 { namespace dsr { -/* +/** * The gratuitous table entries, it maintains the already sent gratuitous route reply entries. * When the node "promiscuously" received a packet destined for other nodes, and inferred a shorter * route for the data packet, it will construct a route reply and send back to the source */ struct GraReplyEntry { - Ipv4Address m_replyTo; - Ipv4Address m_hearFrom; - Time m_gratReplyHoldoff; + Ipv4Address m_replyTo; ///< reply to address + Ipv4Address m_hearFrom; ///< heard from address + Time m_gratReplyHoldoff; ///< gratuitous reply holdoff time + /** + * Constructor + * + * \param t IPv4 address to reply to + * \param f IPv4 address to hear from + * \param h gratitious hold off time + */ GraReplyEntry (Ipv4Address t, Ipv4Address f, Time h) : m_replyTo (t), m_hearFrom (f), @@ -65,7 +72,10 @@ struct GraReplyEntry class DsrGraReply : public Object { public: - + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrGraReply (); @@ -102,6 +112,12 @@ class DsrGraReply : public Object /// Check if the entry is expired or not struct IsExpired { + /** + * Check if the entry is expired + * + * \param b GraReplyEntry entry + * \return true if expired, false otherwise + */ bool operator() (const struct GraReplyEntry & b) const { return (b.m_gratReplyHoldoff < Simulator::Now ()); diff --git a/src/dsr/model/dsr-maintain-buff.cc b/src/dsr/model/dsr-maintain-buff.cc index 881b3880478..d13ebf3777c 100644 --- a/src/dsr/model/dsr-maintain-buff.cc +++ b/src/dsr/model/dsr-maintain-buff.cc @@ -39,7 +39,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrMaintainBuffer"); - + namespace dsr { uint32_t @@ -209,8 +209,14 @@ DsrMaintainBuffer::LinkEqual (DsrMaintainBuffEntry & entry) return false; } +/// IsExpired structure struct IsExpired { + /** + * \brief comparison operator + * \param e maintain buffer entry + * \return true if the entry is expired + */ bool operator() (DsrMaintainBuffEntry const & e) const { diff --git a/src/dsr/model/dsr-maintain-buff.h b/src/dsr/model/dsr-maintain-buff.h index c2548fddecb..a68e5f27733 100644 --- a/src/dsr/model/dsr-maintain-buff.h +++ b/src/dsr/model/dsr-maintain-buff.h @@ -46,82 +46,162 @@ namespace dsr { */ struct LinkKey { - Ipv4Address m_source; - Ipv4Address m_destination; - Ipv4Address m_ourAdd; - Ipv4Address m_nextHop; + Ipv4Address m_source; ///< source address + Ipv4Address m_destination; ///< destination address + Ipv4Address m_ourAdd; ///< local address + Ipv4Address m_nextHop; ///< next hop address /** * Compare maintain Buffer entries - * \param o + * \param o object to compare * \return true if equal - */ + */ bool operator < (const LinkKey & o) const { - if (m_source < o.m_source) return true; - if (o.m_source < m_source) return false; - if (m_destination < o.m_destination) return true; - if (o.m_destination < m_destination) return false; - if (m_ourAdd < o.m_ourAdd) return true; - if (o.m_ourAdd < m_ourAdd) return false; - if (m_nextHop < o.m_nextHop) return true; - if (o.m_nextHop < m_nextHop) return false; - return false; + if (m_source < o.m_source) + { + return true; + } + if (o.m_source < m_source) + { + return false; + } + if (m_destination < o.m_destination) + { + return true; + } + if (o.m_destination < m_destination) + { + return false; + } + if (m_ourAdd < o.m_ourAdd) + { + return true; + } + if (o.m_ourAdd < m_ourAdd) + { + return false; + } + if (m_nextHop < o.m_nextHop) + { + return true; + } + if (o.m_nextHop < m_nextHop) + { + return false; + } + return false; } }; +/// NetworkKey structure struct NetworkKey { - uint16_t m_ackId; - Ipv4Address m_ourAdd; - Ipv4Address m_nextHop; - Ipv4Address m_source; - Ipv4Address m_destination; + uint16_t m_ackId; ///< acknowledge ID + Ipv4Address m_ourAdd; ///< local address + Ipv4Address m_nextHop; ///< next hop + Ipv4Address m_source; ///< source address + Ipv4Address m_destination; ///< destination address /** * Compare maintain Buffer entries - * \param o + * \param o object to compare * \return true if equal */ bool operator < (const NetworkKey & o) const { - if (m_ackId < o.m_ackId) return true; - if (o.m_ackId < m_ackId) return false; - if (m_source < o.m_source) return true; - if (o.m_source < m_source) return false; - if (m_destination < o.m_destination) return true; - if (o.m_destination < m_destination) return false; - if (m_ourAdd < o.m_ourAdd) return true; - if (o.m_ourAdd < m_ourAdd) return false; - if (m_nextHop < o.m_nextHop) return true; - if (o.m_nextHop < m_nextHop) return false; - return false; + if (m_ackId < o.m_ackId) + { + return true; + } + if (o.m_ackId < m_ackId) + { + return false; + } + if (m_source < o.m_source) + { + return true; + } + if (o.m_source < m_source) + { + return false; + } + if (m_destination < o.m_destination) + { + return true; + } + if (o.m_destination < m_destination) + { + return false; + } + if (m_ourAdd < o.m_ourAdd) + { + return true; + } + if (o.m_ourAdd < m_ourAdd) + { + return false; + } + if (m_nextHop < o.m_nextHop) + { + return true; + } + if (o.m_nextHop < m_nextHop) + { + return false; + } + return false; } }; +/// PassiveKey structure struct PassiveKey { - uint16_t m_ackId; - Ipv4Address m_source; - Ipv4Address m_destination; - uint8_t m_segsLeft; + uint16_t m_ackId; ///< acknowledge ID + Ipv4Address m_source; ///< source address + Ipv4Address m_destination; ///< destination address + uint8_t m_segsLeft; ///< segments left /** * Compare maintain Buffer entries - * \param o + * \param o is the object to compare * \return true if equal */ bool operator < (const PassiveKey & o) const { - if (m_ackId < o.m_ackId) return true; - if (o.m_ackId < m_ackId) return false; - if (m_source < o.m_source) return true; - if (o.m_source < m_source) return false; - if (m_destination < o.m_destination) return true; - if (o.m_destination < m_destination) return false; - if (m_segsLeft < o.m_segsLeft) return true; - if (o.m_segsLeft < m_segsLeft) return false; - return false; + if (m_ackId < o.m_ackId) + { + return true; + } + if (o.m_ackId < m_ackId) + { + return false; + } + if (m_source < o.m_source) + { + return true; + } + if (o.m_source < m_source) + { + return false; + } + if (m_destination < o.m_destination) + { + return true; + } + if (o.m_destination < m_destination) + { + return false; + } + if (m_segsLeft < o.m_segsLeft) + { + return true; + } + if (o.m_segsLeft < m_segsLeft) + { + return false; + } + return false; } }; @@ -145,8 +225,8 @@ class DsrMaintainBuffEntry * \param exp expiration time */ DsrMaintainBuffEntry (Ptr pa = 0, Ipv4Address us = Ipv4Address (), - Ipv4Address n = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address dst = Ipv4Address (), - uint16_t ackId = 0, uint8_t segs = 0, Time exp = Simulator::Now ()) + Ipv4Address n = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address dst = Ipv4Address (), + uint16_t ackId = 0, uint8_t segs = 0, Time exp = Simulator::Now ()) : m_packet (pa), m_ourAdd (us), m_nextHop (n), @@ -159,66 +239,130 @@ class DsrMaintainBuffEntry } // Fields + /** + * Get packet + * \returns the current packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set packet + * \param p the current packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get local address of entry + * \returns the local IP address + */ Ipv4Address GetOurAdd () const { return m_ourAdd; } + /** + * Set local address of entry + * \param us the local IP address + */ void SetOurAdd (Ipv4Address us) { m_ourAdd = us; } + /** + * Get next hop of entry + * \returns the IP address for the next hop + */ Ipv4Address GetNextHop () const { return m_nextHop; } + /** + * Set next hop of entry + * \param n the next hop IP address + */ void SetNextHop (Ipv4Address n) { m_nextHop = n; } + /** + * Get destination address + * \returns the destination IP address + */ Ipv4Address GetDst () const { return m_dst; } + /** + * Set destination address + * \param n the destination IP address + */ void SetDst (Ipv4Address n) { m_dst = n; } + /** + * Get source address + * \returns the source IP address + */ Ipv4Address GetSrc () const { return m_src; } + /** + * Set source address + * \param s the source IP address + */ void SetSrc (Ipv4Address s) { m_src = s; } + /** + * Get acknowledge ID + * \returns the acknowledge ID + */ uint16_t GetAckId () const { return m_ackId; } + /** + * Set acknowledge ID + * \param ackId the acknowledge ID + */ void SetAckId (uint16_t ackId) { m_ackId = ackId; } + /** + * Get segments left + * \returns the number of segments left + */ uint8_t GetSegsLeft () const { return m_segsLeft; } + /** + * Set segments left + * \param segs the number of segments left + */ void SetSegsLeft (uint8_t segs) { m_segsLeft = segs; } + /** + * Set expiration time + * \param exp the expire time + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expiration time + * \returns the expiration time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); @@ -268,18 +412,34 @@ class DsrMaintainBuffer uint32_t GetSize (); // Fields + /** + * Get maximum queue length + * \returns the maximum queue length + */ uint32_t GetMaxQueueLen () const { return m_maxLen; } + /** + * Set maximum queue length + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } + /** + * Get maintain buffer timeout + * \returns the maintain buffer timeout + */ Time GetMaintainBufferTimeout () const { return m_maintainBufferTimeout; } + /** + * Set maintain buffer timeout + * \param t the maintain buffer timeoout + */ void SetMaintainBufferTimeout (Time t) { m_maintainBufferTimeout = t; @@ -296,6 +456,7 @@ class DsrMaintainBuffer private: /// The vector of maintain buffer entries std::vector m_maintainBuffer; + /// The vector of network keys std::vector m_allNetworkKey; /// Remove all expired entries void Purge (); diff --git a/src/dsr/model/dsr-network-queue.cc b/src/dsr/model/dsr-network-queue.cc index 24e2af75088..f15be58d85e 100644 --- a/src/dsr/model/dsr-network-queue.cc +++ b/src/dsr/model/dsr-network-queue.cc @@ -41,7 +41,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrNetworkQueue"); - + namespace dsr { NS_OBJECT_ENSURE_REGISTERED (DsrNetworkQueue); diff --git a/src/dsr/model/dsr-network-queue.h b/src/dsr/model/dsr-network-queue.h index 9c347e264ad..4a162b7cc9f 100644 --- a/src/dsr/model/dsr-network-queue.h +++ b/src/dsr/model/dsr-network-queue.h @@ -73,7 +73,7 @@ class DsrNetworkQueueEntry } /** * Compare send buffer entries - * \param o + * \param o entry to compare * \return true if equal */ bool operator== (DsrNetworkQueueEntry const & o) const @@ -83,42 +83,82 @@ class DsrNetworkQueueEntry } // Fields + /** + * Get packet function + * \returns the current packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set packet function + * \param p the current packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get IP route function + * \returns the IP route + */ Ptr GetIpv4Route () const { return m_ipv4Route; } + /** + * Set IP route function + * \param route + */ void SetIpv4Route (Ptr route) { m_ipv4Route = route; } + /** + * Get source address function + * \returns the source IP address + */ Ipv4Address GetSourceAddress () const { return m_srcAddr; } + /** + * Set source address function + * \param addr the source IP address + */ void SetSourceAddress (Ipv4Address addr) { m_srcAddr = addr; } + /** + * Get next hop address function + * \returns the next hop IP address + */ Ipv4Address GetNextHopAddress () const { return m_nextHopAddr; } + /** + * Set next hop address function + * \param addr the next hop IP address + */ void SetNextHopAddress (Ipv4Address addr) { m_nextHopAddr = addr; } + /** + * Get inserted time stamp function + * \returns the inserted time stamp + */ Time GetInsertedTimeStamp (void) const { return tstamp; } + /** + * Set inserted tiem stamp function + * \param time tje inserted timestamp + */ void SetInsertedTimeStamp (Time time) { tstamp = time; @@ -126,10 +166,10 @@ class DsrNetworkQueueEntry private: /// Data packet - Ptr m_packet; - Ipv4Address m_srcAddr; - Ipv4Address m_nextHopAddr; - Time tstamp; + Ptr m_packet; ///< the packet + Ipv4Address m_srcAddr; ///< source address + Ipv4Address m_nextHopAddr; ///< next hop address + Time tstamp; ///< timestamp /// Ipv4Route Ptr m_ipv4Route; }; @@ -137,8 +177,12 @@ class DsrNetworkQueueEntry class DsrNetworkQueue : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); - + DsrNetworkQueue (); /** * Construct a DsrNetworkQueue with the given @@ -150,7 +194,18 @@ class DsrNetworkQueue : public Object DsrNetworkQueue (uint32_t maxLen, Time maxDelay); ~DsrNetworkQueue (); + /** + * Find the packet entry with a given next hop + * \param nextHop the IP address of the next hop + * \param entry the DSR queue entry + * \returns true if found + */ bool FindPacketWithNexthop (Ipv4Address nextHop, DsrNetworkQueueEntry & entry); + /** + * Try to find an entry with a particular next hop, and return true if found + * \param nextHop the next hop IP address + * \returns true if found + */ bool Find (Ipv4Address nextHop); /** * Push entry in queue, if there is no entry with the same @@ -205,6 +260,11 @@ class DsrNetworkQueue : public Object */ void Flush (void); + /** + * Return the current queue entry + * + * \return the current queue entry + */ std::vector & GetQueue () { return m_dsrNetworkQueue; diff --git a/src/dsr/model/dsr-option-header.cc b/src/dsr/model/dsr-option-header.cc index f02f86ea7ad..21a0449be07 100644 --- a/src/dsr/model/dsr-option-header.cc +++ b/src/dsr/model/dsr-option-header.cc @@ -800,8 +800,7 @@ TypeId DsrOptionRerrUnreachHeader::GetInstanceTypeId () const } DsrOptionRerrUnreachHeader::DsrOptionRerrUnreachHeader () - : - m_salvage (0) + : m_salvage (0) { SetType (3); SetLength (18); @@ -929,8 +928,7 @@ TypeId DsrOptionRerrUnsupportHeader::GetInstanceTypeId () const } DsrOptionRerrUnsupportHeader::DsrOptionRerrUnsupportHeader () - : - m_salvage (0) + : m_salvage (0) { SetType (3); SetLength (14); diff --git a/src/dsr/model/dsr-option-header.h b/src/dsr/model/dsr-option-header.h index 00beced257e..1f616089e92 100644 --- a/src/dsr/model/dsr-option-header.h +++ b/src/dsr/model/dsr-option-header.h @@ -380,11 +380,11 @@ class DsrOptionRreqHeader : public DsrOptionHeader * \brief Identifier of the packet. */ uint16_t m_identification; - /* + /** * Ipv4 address of target node */ Ipv4Address m_target; - /* + /** * Ipv4 address to write when desearizing the packet */ Ipv4Address m_address; @@ -481,8 +481,9 @@ class DsrOptionRrepHeader : public DsrOptionHeader * \return the vector of ipv4 address */ std::vector GetNodesAddress () const; - /* + /** * \brief Get the target node Ip address + * \param ipv4Address target address * \return the target address */ Ipv4Address GetTargetAddress (std::vector ipv4Address) const; @@ -527,7 +528,7 @@ class DsrOptionRrepHeader : public DsrOptionHeader virtual Alignment GetAlignment () const; private: - /* + /** * The Ip address to write to when deserialize the packet */ Ipv4Address m_address; @@ -587,12 +588,12 @@ class DsrOptionSRHeader : public DsrOptionHeader * \brief Destructor. */ virtual ~DsrOptionSRHeader (); - /* + /** * \brief Set the number of segments left to send * \param segmentsLeft The segments left */ void SetSegmentsLeft (uint8_t segmentsLeft); - /* + /** * \brief Get the number of segments left to send * \return The segments left */ @@ -612,7 +613,7 @@ class DsrOptionSRHeader : public DsrOptionHeader * \return the vector of ipv4 address */ std::vector GetNodesAddress () const; - /* + /** * \brief Get the node list size which is the number of ip address of the route * \return the node list size */ @@ -629,12 +630,12 @@ class DsrOptionSRHeader : public DsrOptionHeader * \return the router IPv4 Address */ Ipv4Address GetNodeAddress (uint8_t index) const; - /* + /** * \brief Set the salvage value for a packet * \param salvage The salvage value of the packet */ void SetSalvage (uint8_t salvage); - /* + /** * \brief Get the salvage value for a packet * \return The salvage value of the packet */ @@ -672,7 +673,7 @@ class DsrOptionSRHeader : public DsrOptionHeader * * \param [in] header The DsrOptionsSRHeader */ - typedef void (* TracedCallback) (const DsrOptionSRHeader & header); + typedef void (*TracedCallback)(const DsrOptionSRHeader & header); private: /** diff --git a/src/dsr/model/dsr-options.cc b/src/dsr/model/dsr-options.cc index 4f1d5f51894..48c40d1eb90 100644 --- a/src/dsr/model/dsr-options.cc +++ b/src/dsr/model/dsr-options.cc @@ -63,7 +63,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrOptions"); - + namespace dsr { NS_OBJECT_ENSURE_REGISTERED (DsrOptions); @@ -688,7 +688,7 @@ uint8_t DsrOptionRreq::Process (Ptr packet, Ptr dsrP, Ipv4Addres if (numberAddress > 0) { DsrRouteCacheEntry toSource (/*IP_VECTOR=*/ m_finalRoute, /*dst=*/ - dst, /*expire time=*/ ActiveRouteTimeout); + dst, /*expire time=*/ ActiveRouteTimeout); if (dsr->IsLinkCache ()) { addRoute = dsr->AddRoute_Link (m_finalRoute, ipv4Address); @@ -763,126 +763,126 @@ uint8_t DsrOptionRreq::Process (Ptr packet, Ptr dsrP, Ipv4Addres */ else if (isRouteInCache && !areThereDuplicates) { - m_finalRoute.clear (); // Clear the final route vector - /** - * push back the intermediate node address from the source to this node - */ - for (std::vector::iterator i = saveRoute.begin (); i != saveRoute.end (); ++i) + m_finalRoute.clear (); // Clear the final route vector + /** + * push back the intermediate node address from the source to this node + */ + for (std::vector::iterator i = saveRoute.begin (); i != saveRoute.end (); ++i) + { + m_finalRoute.push_back (*i); + } + /** + * push back the route vector we found in our route cache to destination, including this node's address + */ + for (std::vector::iterator j = ip.begin (); j != ip.end (); ++j) + { + m_finalRoute.push_back (*j); + } + /* + * Create the route entry to the rreq originator and save it to route cache, also need to reverse the route + */ + bool addRoute = false; + std::vector reverseRoute (m_finalRoute); + + if (ReverseRoutes (reverseRoute)) + { + saveRoute.push_back (ipv4Address); + ReverseRoutes (saveRoute); + Ipv4Address dst = saveRoute.back (); + NS_LOG_DEBUG ("This is the route save in route cache"); + PrintVector (saveRoute); + + DsrRouteCacheEntry toSource (/*IP_VECTOR=*/ saveRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout); + NS_ASSERT (saveRoute.front () == ipv4Address); + // Add the route entry in the route cache + if (dsr->IsLinkCache ()) { - m_finalRoute.push_back (*i); + addRoute = dsr->AddRoute_Link (saveRoute, ipv4Address); } - /** - * push back the route vector we found in our route cache to destination, including this node's address - */ - for (std::vector::iterator j = ip.begin (); j != ip.end (); ++j) + else { - m_finalRoute.push_back (*j); + addRoute = dsr->AddRoute (toSource); } - /* - * Create the route entry to the rreq originator and save it to route cache, also need to reverse the route - */ - bool addRoute = false; - std::vector reverseRoute (m_finalRoute); - if (ReverseRoutes (reverseRoute)) + if (addRoute) { - saveRoute.push_back (ipv4Address); - ReverseRoutes (saveRoute); - Ipv4Address dst = saveRoute.back (); - NS_LOG_DEBUG ("This is the route save in route cache"); + NS_LOG_LOGIC ("We have added the route and search send buffer for packet with destination " << dst); + /* + * Found a route the dst, construct the source route option header + */ + DsrOptionSRHeader sourceRoute; PrintVector (saveRoute); - DsrRouteCacheEntry toSource (/*IP_VECTOR=*/ saveRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout); - NS_ASSERT (saveRoute.front () == ipv4Address); - // Add the route entry in the route cache - if (dsr->IsLinkCache ()) - { - addRoute = dsr->AddRoute_Link (saveRoute, ipv4Address); - } - else - { - addRoute = dsr->AddRoute (toSource); - } + sourceRoute.SetNodesAddress (saveRoute); + // if (dsr->IsLinkCache ()) + // { + // dsr->UseExtends (saveRoute); + // } + sourceRoute.SetSegmentsLeft ((saveRoute.size () - 2)); + uint8_t salvage = 0; + sourceRoute.SetSalvage (salvage); + Ipv4Address nextHop = SearchNextHop (ipv4Address, saveRoute); // Get the next hop address + NS_LOG_DEBUG ("The nextHop address " << nextHop); - if (addRoute) - { - NS_LOG_LOGIC ("We have added the route and search send buffer for packet with destination " << dst); - /* - * Found a route the dst, construct the source route option header - */ - DsrOptionSRHeader sourceRoute; - PrintVector (saveRoute); - - sourceRoute.SetNodesAddress (saveRoute); - // if (dsr->IsLinkCache ()) - // { - // dsr->UseExtends (saveRoute); - // } - sourceRoute.SetSegmentsLeft ((saveRoute.size () - 2)); - uint8_t salvage = 0; - sourceRoute.SetSalvage (salvage); - Ipv4Address nextHop = SearchNextHop (ipv4Address, saveRoute); // Get the next hop address - NS_LOG_DEBUG ("The nextHop address " << nextHop); - - if (nextHop == "0.0.0.0") - { - dsr->PacketNewRoute (dsrP, ipv4Address, dst, protocol); - return 0; - } - SetRoute (nextHop, ipv4Address); - /* - * Schedule the packet retry - */ - dsr->SendPacketFromBuffer (sourceRoute, nextHop, protocol); - // Cancel the route request timer for destination - dsr->CancelRreqTimer (dst, true); - } - else + if (nextHop == "0.0.0.0") { - NS_LOG_DEBUG ("The route is failed to add in cache"); + dsr->PacketNewRoute (dsrP, ipv4Address, dst, protocol); return 0; } + SetRoute (nextHop, ipv4Address); + /* + * Schedule the packet retry + */ + dsr->SendPacketFromBuffer (sourceRoute, nextHop, protocol); + // Cancel the route request timer for destination + dsr->CancelRreqTimer (dst, true); } else { - NS_LOG_DEBUG ("Unable to reverse the route"); + NS_LOG_DEBUG ("The route is failed to add in cache"); return 0; } + } + else + { + NS_LOG_DEBUG ("Unable to reverse the route"); + return 0; + } - /* - * Need to first pin down the next hop address before removing duplicates - */ - Ipv4Address nextHop = ReverseSearchNextHop (ipv4Address, m_finalRoute); - /* - * First remove the duplicate ip address to automatically shorten the route, and then reversely - * search the next hop address - */ - // Set the route - SetRoute (nextHop, ipv4Address); - - uint16_t hops = m_finalRoute.size (); - DsrOptionRrepHeader rrep; - rrep.SetNodesAddress (m_finalRoute); // Set the node addresses in the route reply header - // Get the real source of the reply - Ipv4Address realSource = m_finalRoute.back (); - PrintVector (m_finalRoute); - NS_LOG_DEBUG ("This is the full route from " << realSource << " to " << m_finalRoute.front ()); - /* - * This part add dsr header to the packet and send route reply packet - */ - DsrRoutingHeader dsrRoutingHeader; - dsrRoutingHeader.SetNextHeader (protocol); - dsrRoutingHeader.SetMessageType (1); - dsrRoutingHeader.SetSourceId (GetIDfromIP (realSource)); - dsrRoutingHeader.SetDestId (255); + /* + * Need to first pin down the next hop address before removing duplicates + */ + Ipv4Address nextHop = ReverseSearchNextHop (ipv4Address, m_finalRoute); + /* + * First remove the duplicate ip address to automatically shorten the route, and then reversely + * search the next hop address + */ + // Set the route + SetRoute (nextHop, ipv4Address); - uint8_t length = rrep.GetLength (); // Get the length of the rrep header excluding the type header - dsrRoutingHeader.SetPayloadLength (length + 2); - dsrRoutingHeader.AddDsrOption (rrep); - Ptr newPacket = Create (); - newPacket->AddHeader (dsrRoutingHeader); - dsr->ScheduleCachedReply (newPacket, ipv4Address, nextHop, m_ipv4Route, hops); - isPromisc = false; + uint16_t hops = m_finalRoute.size (); + DsrOptionRrepHeader rrep; + rrep.SetNodesAddress (m_finalRoute); // Set the node addresses in the route reply header + // Get the real source of the reply + Ipv4Address realSource = m_finalRoute.back (); + PrintVector (m_finalRoute); + NS_LOG_DEBUG ("This is the full route from " << realSource << " to " << m_finalRoute.front ()); + /* + * This part add dsr header to the packet and send route reply packet + */ + DsrRoutingHeader dsrRoutingHeader; + dsrRoutingHeader.SetNextHeader (protocol); + dsrRoutingHeader.SetMessageType (1); + dsrRoutingHeader.SetSourceId (GetIDfromIP (realSource)); + dsrRoutingHeader.SetDestId (255); + + uint8_t length = rrep.GetLength (); // Get the length of the rrep header excluding the type header + dsrRoutingHeader.SetPayloadLength (length + 2); + dsrRoutingHeader.AddDsrOption (rrep); + Ptr newPacket = Create (); + newPacket->AddHeader (dsrRoutingHeader); + dsr->ScheduleCachedReply (newPacket, ipv4Address, nextHop, m_ipv4Route, hops); + isPromisc = false; return rreq.GetSerializedSize (); } /* @@ -1315,24 +1315,24 @@ uint8_t DsrOptionSR::Process (Ptr packet, Ptr dsrP, Ipv4Address Ipv4Address ackAddress = srcAddress; if (!nodeList.empty ()) { - if (segsLeft > numberAddress) // The segmentsLeft field should not be larger than the total number of ip addresses - { - NS_LOG_LOGIC ("Malformed header. Drop!"); - m_dropTrace (packet); - return 0; - } - // -fstrict-overflow sensitive, see bug 1868 - if (numberAddress - segsLeft < 2) // The index is invalid - { - NS_LOG_LOGIC ("Malformed header. Drop!"); - m_dropTrace (packet); - return 0; - } - ackAddress = nodeList[numberAddress - segsLeft - 2]; + if (segsLeft > numberAddress) // The segmentsLeft field should not be larger than the total number of ip addresses + { + NS_LOG_LOGIC ("Malformed header. Drop!"); + m_dropTrace (packet); + return 0; + } + // -fstrict-overflow sensitive, see bug 1868 + if (numberAddress - segsLeft < 2) // The index is invalid + { + NS_LOG_LOGIC ("Malformed header. Drop!"); + m_dropTrace (packet); + return 0; + } + ackAddress = nodeList[numberAddress - segsLeft - 2]; } - m_ipv4Route = SetRoute (ackAddress, ipv4Address); - NS_LOG_DEBUG ("Send back ACK to the earlier hop " << ackAddress << " from us " << ipv4Address); - dsr->SendAck (ackId, ackAddress, source, destination, protocol, m_ipv4Route); + m_ipv4Route = SetRoute (ackAddress, ipv4Address); + NS_LOG_DEBUG ("Send back ACK to the earlier hop " << ackAddress << " from us " << ipv4Address); + dsr->SendAck (ackId, ackAddress, source, destination, protocol, m_ipv4Route); } /* * After send back ACK, check if the segments left value has turned to 0 or not, if yes, update the route entry diff --git a/src/dsr/model/dsr-options.h b/src/dsr/model/dsr-options.h index cc3b578f2d8..917e17f9f5b 100644 --- a/src/dsr/model/dsr-options.h +++ b/src/dsr/model/dsr-options.h @@ -267,7 +267,7 @@ class DsrOptions : public Object TracedCallback m_rxPacketTrace; private: - Ptr m_node; + Ptr m_node; ///< the node }; /** @@ -282,6 +282,10 @@ class DsrOptionPad1 : public DsrOptions */ static const uint8_t OPT_NUMBER = 224; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrOptionPad1 (); @@ -303,6 +307,10 @@ class DsrOptionPadn : public DsrOptions */ static const uint8_t OPT_NUMBER = 0; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrOptionPadn (); @@ -324,6 +332,10 @@ class DsrOptionRreq : public DsrOptions */ static const uint8_t OPT_NUMBER = 1; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -365,6 +377,10 @@ class DsrOptionRrep : public DsrOptions */ static const uint8_t OPT_NUMBER = 2; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -401,6 +417,10 @@ class DsrOptionSR : public DsrOptions */ static const uint8_t OPT_NUMBER = 96; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -433,6 +453,10 @@ class DsrOptionRerr : public DsrOptions */ static const uint8_t OPT_NUMBER = 3; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -480,6 +504,10 @@ class DsrOptionAckReq : public DsrOptions */ static const uint8_t OPT_NUMBER = 160; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. @@ -516,6 +544,10 @@ class DsrOptionAck : public DsrOptions */ static const uint8_t OPT_NUMBER = 32; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /** * \brief Get the instance type ID. diff --git a/src/dsr/model/dsr-passive-buff.cc b/src/dsr/model/dsr-passive-buff.cc index e965b1b1040..aeb50568177 100644 --- a/src/dsr/model/dsr-passive-buff.cc +++ b/src/dsr/model/dsr-passive-buff.cc @@ -39,7 +39,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrPassiveBuffer"); - + namespace dsr { NS_OBJECT_ENSURE_REGISTERED (DsrPassiveBuffer); @@ -163,8 +163,14 @@ DsrPassiveBuffer::Find (Ipv4Address dst) return false; } +/// IsExpired structure struct IsExpired { + /** + * Check for an expired entry + * \param e passive buffer entry + * \return true if equal + */ bool operator() (DsrPassiveBuffEntry const & e) const { @@ -191,7 +197,7 @@ DsrPassiveBuffer::Purge () } } m_passiveBuffer.erase (std::remove_if (m_passiveBuffer.begin (), m_passiveBuffer.end (), pred), - m_passiveBuffer.end ()); + m_passiveBuffer.end ()); } void diff --git a/src/dsr/model/dsr-passive-buff.h b/src/dsr/model/dsr-passive-buff.h index cdb67c2a3db..3e509099dfc 100644 --- a/src/dsr/model/dsr-passive-buff.h +++ b/src/dsr/model/dsr-passive-buff.h @@ -59,8 +59,8 @@ class DsrPassiveBuffEntry * \param p protocol number */ DsrPassiveBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (), - Ipv4Address n = Ipv4Address (), uint16_t i = 0, uint16_t f = 0, uint8_t seg = 0, Time exp = Simulator::Now (), - uint8_t p = 0) + Ipv4Address n = Ipv4Address (), uint16_t i = 0, uint16_t f = 0, uint8_t seg = 0, Time exp = Simulator::Now (), + uint8_t p = 0) : m_packet (pa), m_dst (d), m_source (s), @@ -74,6 +74,7 @@ class DsrPassiveBuffEntry } /** * Compare send buffer entries + * \param o passive buffer entry to compare * \return true if equal */ bool operator== (DsrPassiveBuffEntry const & o) const @@ -82,74 +83,146 @@ class DsrPassiveBuffEntry } // Fields + /** + * Get packet function + * \returns the current packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set packet function + * \param p the current packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get destination address function + * \returns the destination IP address + */ Ipv4Address GetDestination () const { return m_dst; } + /** + * Set destination address function + * \param d the destination IP address + */ void SetDestination (Ipv4Address d) { m_dst = d; } + /** + * Get source address function + * \returns the source IP address + */ Ipv4Address GetSource () const { return m_source; } + /** + * Set surce address function + * \param s the source IP address + */ void SetSource (Ipv4Address s) { m_source = s; } + /** + * Get next hop address function + * \returns the next hop IP address + */ Ipv4Address GetNextHop () const { return m_nextHop; } + /** + * Set next hop address function + * \param n the next hop address + */ void SetNextHop (Ipv4Address n) { m_nextHop = n; } + /** + * Get identification function + * \returns the identification + */ uint16_t GetIdentification () const { return m_identification; } + /** + * Set identification function + * \param i the identification + */ void SetIdentification (uint16_t i) { m_identification = i; } + /** + * Get fragment offset function + * \returns the fragment offset + */ uint16_t GetFragmentOffset () const { return m_fragmentOffset; } + /** + * Set fragment offset function + * \param f the fragment offset + */ void SetFragmentOffset (uint16_t f) { m_fragmentOffset = f; } + /** + * Get segments left function + * \returns the number of segments left + */ uint8_t GetSegsLeft () const { return m_segsLeft; } + /** + * Set segments left + * \param seg the number of segments left + */ void SetSegsLeft (uint8_t seg) { m_segsLeft = seg; } + /** + * Set expire time + * \param exp the expire time + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expire time + * \returns the expire time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); } + /** + * Set protocol function + * \param p the protocol + */ void SetProtocol (uint8_t p) { m_protocol = p; } + /** + * Get protocol + * \returns the protocol number + */ uint8_t GetProtocol () const { return m_protocol; @@ -164,9 +237,11 @@ class DsrPassiveBuffEntry Ipv4Address m_source; /// Nexthop address Ipv4Address m_nextHop; - /// + /// Identification uint16_t m_identification; + /// Fragment offset uint16_t m_fragmentOffset; + /// Segments left uint8_t m_segsLeft; /// Expire time for queue entry Time m_expire; @@ -176,13 +251,17 @@ class DsrPassiveBuffEntry /** * \ingroup dsr + * \class DsrPassiveBuffer * \brief DSR passive buffer */ /************************************************************************************************************************/ class DsrPassiveBuffer : public Object { public: - + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrPassiveBuffer (); @@ -200,18 +279,34 @@ class DsrPassiveBuffer : public Object uint32_t GetSize (); // Fields + /** + * Get maximum queue length + * \returns the maximum queue length + */ uint32_t GetMaxQueueLen () const { return m_maxLen; } + /** + * Set maximum queue length + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } + /** + * Get passive buffer timeout + * \returns the passive buffer tiemout + */ Time GetPassiveBufferTimeout () const { return m_passiveBufferTimeout; } + /** + * Set passive buffer timeout + * \param t the passive buffer timeout + */ void SetPassiveBufferTimeout (Time t) { m_passiveBufferTimeout = t; diff --git a/src/dsr/model/dsr-rcache.cc b/src/dsr/model/dsr-rcache.cc index e06697461e6..dcc2fb656d0 100644 --- a/src/dsr/model/dsr-rcache.cc +++ b/src/dsr/model/dsr-rcache.cc @@ -50,7 +50,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrRouteCache"); - + namespace dsr { bool CompareRoutesBoth (const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b) @@ -318,11 +318,11 @@ DsrRouteCache::RebuildBestRouteTable (Ipv4Address source) { NS_LOG_FUNCTION (this << source); /** - * \brief The followings are initialize-single-source + * \brief The following are initialize-single-source */ // @d shortest-path estimate std::map d; - // @pre preceeding node + // @pre preceding node std::map pre; for (std::map >::iterator i = m_netGraph.begin (); i != m_netGraph.end (); ++i) { @@ -339,7 +339,7 @@ DsrRouteCache::RebuildBestRouteTable (Ipv4Address source) } d[source] = 0; /** - * \brief The followings are core of dijskra algorithm + * \brief The followingis the core of Dijkstra algorithm */ // the node set which shortest distance has been calculated, if true calculated std::map s; @@ -788,9 +788,9 @@ DsrRouteCache::DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unr NS_LOG_DEBUG ("Erase the route"); m_linkCache.erase (link1); /// \todo get rid of this one - NS_LOG_DEBUG ("The link cache size " << m_linkCache.size()); + NS_LOG_DEBUG ("The link cache size " << m_linkCache.size ()); m_linkCache.erase (link2); - NS_LOG_DEBUG ("The link cache size " << m_linkCache.size()); + NS_LOG_DEBUG ("The link cache size " << m_linkCache.size ()); std::map::iterator i = m_nodeCache.find (errorSrc); if (i == m_nodeCache.end ()) @@ -1143,7 +1143,7 @@ void DsrRouteCache::AddNeighbor (std::vector nodeList, Ipv4Address ownAddress, Time expire) { NS_LOG_LOGIC ("Add neighbor number " << nodeList.size ()); - for (std::vector::iterator j = nodeList.begin (); j != nodeList.end ();) + for (std::vector::iterator j = nodeList.begin (); j != nodeList.end (); ) { Ipv4Address addr = *j; if (addr == ownAddress) @@ -1161,8 +1161,15 @@ DsrRouteCache::AddNeighbor (std::vector nodeList, Ipv4Address ownAd } } +/// CloseNeighbor structure struct CloseNeighbor { + /** + * Check if the entry is expired + * + * \param nb DsrRouteCache::Neighbor entry + * \return true if expired or closed, false otherwise + */ bool operator() (const DsrRouteCache::Neighbor & nb) const { return ((nb.m_expireTime < Simulator::Now ()) || nb.close); diff --git a/src/dsr/model/dsr-rcache.h b/src/dsr/model/dsr-rcache.h index 310581db9bf..2349f78fec1 100644 --- a/src/dsr/model/dsr-rcache.h +++ b/src/dsr/model/dsr-rcache.h @@ -85,8 +85,14 @@ namespace dsr { */ struct Link { - Ipv4Address m_low; - Ipv4Address m_high; + Ipv4Address m_low; ///< low IP address + Ipv4Address m_high; ///< high IP address + /** + * Constructor + * + * \param ip1 first IP address + * \param ip2 second IP address + */ Link (Ipv4Address ip1, Ipv4Address ip2) { if (ip1 < ip2) @@ -100,6 +106,11 @@ struct Link m_high = ip1; } } +/** + * \brief less than comparison operator + * \param L link to compare + * \return true if less than + */ bool operator < (Link const& L) const { if (m_low < L.m_low) @@ -115,9 +126,15 @@ struct Link return false; } } + /// Print function void Print () const; }; + +/** + * \class DsrLinkStab + * \brief DsrLinkStab class (DSR link stability) + */ class DsrLinkStab { public: @@ -131,17 +148,23 @@ class DsrLinkStab virtual ~DsrLinkStab (); /** - * \brief set/get the link stability + * \brief set the link stability + * \param linkStab duration of the link stability */ void SetLinkStability (Time linkStab) { m_linkStability = linkStab + Simulator::Now (); } + /** + * \brief get the link stability + * \returns remaining duration of the link stability + */ Time GetLinkStability () const { return m_linkStability - Simulator::Now (); } + /// Print function void Print () const; private: @@ -152,31 +175,58 @@ class DsrLinkStab Time m_linkStability; }; +/** + * \class DsrNodeStab + * \brief DsrNodeStab class (DSR node stability) + */ class DsrNodeStab { public: - + /** + * Constructor + * + * \param nodeStab duration of stable node time + */ DsrNodeStab (Time nodeStab = Simulator::Now ()); virtual ~DsrNodeStab (); + /** + * Set node stability + * \param nodeStab duration of the node stability + */ void SetNodeStability (Time nodeStab) { m_nodeStability = nodeStab + Simulator::Now (); } + /** + * Get node stability + * \returns the remaining time for node stability + */ Time GetNodeStability () const { return m_nodeStability - Simulator::Now (); } private: - Time m_nodeStability; + Time m_nodeStability; ///< the node stability }; +/** + * \class DsrRouteCacheEntry + * \brief DsrRouteCacheEntry class for entries in the route cache + */ class DsrRouteCacheEntry { public: typedef std::vector IP_VECTOR; ///< Define the vector to hold Ip address typedef std::vector::iterator Iterator; ///< Define the iterator + /** + * Constructor + * + * \param ip IP_VECTOR + * \param dst destination IPv4 address + * \param exp expiration time + */ DsrRouteCacheEntry (IP_VECTOR const & ip = IP_VECTOR (), Ipv4Address dst = Ipv4Address (), Time exp = Simulator::Now ()); virtual ~DsrRouteCacheEntry (); @@ -184,42 +234,82 @@ class DsrRouteCacheEntry void Invalidate (Time badLinkLifetime); // Fields + /** + * Set unidirectional flag + * \param u the unidirectional flag + */ void SetUnidirectional (bool u) { m_blackListState = u; } + /** + * Get unidirectional flag + * \returns the unidirectional flag + */ bool IsUnidirectional () const { return m_blackListState; } + /** + * Set blacklist timeout + * \param t the blacklist timeout + */ void SetBlacklistTimeout (Time t) { m_blackListTimeout = t; } + /** + * Get blacklist timeout + * \returns the blacklist timeout + */ Time GetBlacklistTimeout () const { return m_blackListTimeout; } + /** + * Get destination address + * \returns the destination IP address + */ Ipv4Address GetDestination () const { return m_dst; } + /** + * Set destination address + * \param d the destination IP address + */ void SetDestination (Ipv4Address d) { m_dst = d; } + /** + * Get the IP vector + * \returns the IP vector + */ IP_VECTOR GetVector () const { return m_path; } + /** + * Sets the IP vector + * \param v the IP vector + */ void SetVector (IP_VECTOR v) { m_path = v; } + /** + * Set expire time + * \param exp the expire time + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expire time + * \returns the expire time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); @@ -231,6 +321,7 @@ class DsrRouteCacheEntry void Print (std::ostream & os) const; /** * \brief Compare the route cache entry + * \param o entry to compare * \return true if equal */ bool operator== (DsrRouteCacheEntry const & o) const @@ -265,7 +356,6 @@ class DsrRouteCacheEntry // \} private: - Timer m_ackTimer; ///< RREP_ACK timer Ipv4Address m_dst; ///< The destination Ip address IP_VECTOR m_path; ///< brief The IP address constructed route @@ -285,7 +375,10 @@ class DsrRouteCacheEntry class DsrRouteCache : public Object { public: - + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrRouteCache (); @@ -301,82 +394,162 @@ class DsrRouteCache : public Object typedef std::list routeVector; // Fields + /** + * Get subroute indicator + * \returns true if a subroute exists + */ bool GetSubRoute () const { return m_subRoute; } + /** + * Set subroute indicator + * \param subRoute the subroute indicator + */ void SetSubRoute (bool subRoute) { m_subRoute = subRoute; } + /** + * Get the max queue length + * \returns the maximum queue length + */ uint32_t GetMaxCacheLen () const { return m_maxCacheLen; } + /** + * Set the max queue length + * \param len the maximum queue length + */ void SetMaxCacheLen (uint32_t len) { m_maxCacheLen = len; } + /** + * Get cache timeout value + * \returns the cache timeout time + */ Time GetCacheTimeout () const { return RouteCacheTimeout; } + /** + * Set cache timeout value + * \param t the cache timeout time + */ void SetCacheTimeout (Time t) { RouteCacheTimeout = t; } + /** + * Get max entries for each destination + * \returns the maximum entries for each destination + */ uint32_t GetMaxEntriesEachDst () const { return m_maxEntriesEachDst; } + /** + * Set max entries for each destination + * \param entries the maximum entries for each destination + */ void SetMaxEntriesEachDst (uint32_t entries) { m_maxEntriesEachDst = entries; } + /** + * Get bad link lifetime function + * \returns the bad link lifetime + */ Time GetBadLinkLifetime () const { return m_badLinkLifetime; } + /** + * Set bad link lifetime function + * \param t the bad link lifetime + */ void SetBadLinkLifetime (Time t) { m_badLinkLifetime = t; } + /** + * Get stability decrease factor + * \returns the stability decrease factor + */ uint64_t GetStabilityDecrFactor () const { return m_stabilityDecrFactor; } + /** + * Set stability decrease factor + * \param decrFactor the stability decrease factor + */ void SetStabilityDecrFactor (uint64_t decrFactor) { m_stabilityDecrFactor = decrFactor; } + /** + * Get stability increase factor + * \returns the stability increase factor + */ uint64_t GetStabilityIncrFactor () const { return m_stabilityIncrFactor; } + /** + * Set stability increase factor + * \param incrFactor the stability increase factor + */ void SetStabilityIncrFactor (uint64_t incrFactor) { m_stabilityIncrFactor = incrFactor; } + /** + * Get initial stability + * \returns the initial stability + */ Time GetInitStability () const { return m_initStability; } + /** + * Set initial stability + * \param initStability the initial stability + */ void SetInitStability (Time initStability) { m_initStability = initStability; } + /** + * Get minimum lifetime + * \returns the minimum lifetime + */ Time GetMinLifeTime () const { return m_minLifeTime; } + /** + * Set minimum lifetime + * \param minLifeTime the minimum lifetime + */ void SetMinLifeTime (Time minLifeTime) { m_minLifeTime = minLifeTime; } + /** + * Get use extends + * \returns the use extends time + */ Time GetUseExtends () const { return m_useExtends; } + /** + * Set use extends + * \param useExtends the use extends time + */ void SetUseExtends (Time useExtends) { m_useExtends = useExtends; @@ -391,7 +564,7 @@ class DsrRouteCache : public Object /** * \brief Add route cache entry if it doesn't yet exist in route cache * \param rt route cache entry - * \return true in success + * \return true on success */ bool AddRoute (DsrRouteCacheEntry & rt); /** @@ -415,11 +588,13 @@ class DsrRouteCache : public Object * \brief Find the same route in the route cache * \param rt entry with destination address dst, if exists * \param rtVector the route vector + * \return true if same */ bool FindSameRoute (DsrRouteCacheEntry & rt, std::list & rtVector); /** * \brief Delete the route with certain destination address * \param dst the destination address of the routes that should be deleted + * \return true if the route was deleted */ bool DeleteRoute (Ipv4Address dst); /** @@ -444,25 +619,32 @@ class DsrRouteCache : public Object //------------------------------------------------------------------------------------------ /** * \brief Check for duplicate ids and save new entries if the id is not present in the table + * \param nextHop to check for in cache + * \return ack ID */ uint16_t CheckUniqueAckId (Ipv4Address nextHop); /** * \brief Get the ack table size + * \return ack size */ uint16_t GetAckSize (); // -------------------------------------------------------------------------------------------- - /** - * The following code handles link-layer acks - */ - /// Neighbor description + /// Structure to manage neighbor state struct Neighbor { - Ipv4Address m_neighborAddress; - Mac48Address m_hardwareAddress; - Time m_expireTime; - bool close; - + Ipv4Address m_neighborAddress; ///< neightbor address + Mac48Address m_hardwareAddress; ///< neighbor MAC address + Time m_expireTime; ///< route expire time + bool close; ///< is route active + + /** + * Constructor + * + * \param ip IP address of neighbor + * \param mac MAC address of neighbor + * \param t expiration time + */ Neighbor (Ipv4Address ip, Mac48Address mac, Time t) : m_neighborAddress (ip), m_hardwareAddress (mac), @@ -471,22 +653,33 @@ class DsrRouteCache : public Object { } - Neighbor () {} // For Python bindings + Neighbor () + { + } // For Python bindings }; /** * \brief Return expire time for neighbor node with address addr, if exists, else return 0. + * \param addr IP address + * \return expire time */ Time GetExpireTime (Ipv4Address addr); /** - * \brief Check that node with address addr is neighbor + * \brief Check that node with address addr is neighbor + * \param addr IP address + * \return true if neighbor */ bool IsNeighbor (Ipv4Address addr); /** * \brief Update expire time for entry with address addr, if it exists, else add new entry + * \param nodeList list of addresses + * \param expire expiration time */ void UpdateNeighbor (std::vector nodeList, Time expire); /** * \brief Add to the neighbor list + * \param nodeList neighbor list + * \param ownAddress local address + * \param expire expiration time */ void AddNeighbor (std::vector nodeList, Ipv4Address ownAddress, Time expire); /** @@ -509,7 +702,7 @@ class DsrRouteCache : public Object */ void AddArpCache (Ptr); /** - * \brief Don't use given ARP cache any more (interface is down) + * \brief Don't use the provided ARP cache any more (interface is down) */ void DelArpCache (Ptr); /** @@ -520,7 +713,7 @@ class DsrRouteCache : public Object { return m_txErrorCallback; } - + /// Handle link failure callback void SetCallback (Callback cb) { @@ -533,6 +726,9 @@ class DsrRouteCache : public Object } private: + /** + * \brief assignment operator + */ DsrRouteCache & operator= (DsrRouteCache const &); DsrRouteCacheEntry::IP_VECTOR m_vector; ///< The route vector to save the ip addresses for intermediate nodes. uint32_t m_maxCacheLen; ///< The maximum number of packets that we allow a routing protocol to buffer. @@ -541,11 +737,11 @@ class DsrRouteCache : public Object /** * Define the parameters for link cache type */ - uint32_t m_stabilityDecrFactor; - uint32_t m_stabilityIncrFactor; - Time m_initStability; - Time m_minLifeTime; - Time m_useExtends; + uint32_t m_stabilityDecrFactor; ///< stability decrease factor + uint32_t m_stabilityIncrFactor; ///< stability increase factor + Time m_initStability; ///< initial stability + Time m_minLifeTime; ///< minimum lifetime + Time m_useExtends; ///< use extend /** * Define the route cache data structure */ @@ -581,16 +777,19 @@ class DsrRouteCache : public Object * \brief used by LookupRoute when LinkCache * \param id the ip address we are looking for * \param rt the route cache entry to store the found one + * \return true if route rute found */ bool LookupRoute_Link (Ipv4Address id, DsrRouteCacheEntry & rt); /** * \brief increase the stability of the node * \param node the ip address of the node we want to increase stability + * \return true if success */ bool IncStability (Ipv4Address node); /** * \brief decrease the stability of the node * \param node the ip address of the node we want to decrease stability + * \return true if success */ bool DecStability (Ipv4Address node); @@ -601,19 +800,35 @@ class DsrRouteCache : public Object * \param type The type of the cache */ void SetCacheType (std::string type); + /** + * \brief is link cached + * \return true if the link is cached + */ bool IsLinkCache (); + /** + * \brief dd route link to cache + * \param nodelist vector of nodes + * \param node ip address of node to add + * \return true if the link is cached + */ bool AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address node); /** - * \brief USE MAXWEIGHT TO REPRESENT MAX; USE BROADCAST ADDRESS TO REPRESENT NULL PRECEEDING ADDRESS - * \param source The source address the routes based on + * \brief Rebuild the best route table + * \note Use MAXWEIGHT to represeant maximum weight, use the IPv4 broadcast + * address of 255.255.255.255 to represent a null preceding address + * \param source The source address used for computing the routes */ void RebuildBestRouteTable (Ipv4Address source); + /** + * \brief Purge from the cache if the stability time expired + */ void PurgeLinkNode (); /** * When a link from the Route Cache is used in routing a packet originated or salvaged * by that node, the stability metric for each of the two endpoint nodes of that link is incremented by the * amount of time since that link was last used. When a link is used in a route chosen for a packet originated or * salvaged by this node, the link's lifetime is set to be at least UseExtends into the future + * \param rt cache entry */ void UseExtends (DsrRouteCacheEntry::IP_VECTOR rt); /** diff --git a/src/dsr/model/dsr-routing.cc b/src/dsr/model/dsr-routing.cc index 7fc4c2e70bc..eb9fef549ce 100644 --- a/src/dsr/model/dsr-routing.cc +++ b/src/dsr/model/dsr-routing.cc @@ -79,7 +79,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrRouting"); - + namespace dsr { NS_OBJECT_ENSURE_REGISTERED (DsrRouting); @@ -534,14 +534,14 @@ std::vector DsrRouting::GetElementsFromContext (std::string context) { std::vector elements; - size_t pos1=0, pos2; + size_t pos1 = 0, pos2; while (pos1 != context.npos) - { - pos1 = context.find ("/",pos1); - pos2 = context.find ("/",pos1+1); - elements.push_back (context.substr (pos1+1,pos2-(pos1+1))); - pos1 = pos2; - } + { + pos1 = context.find ("/",pos1); + pos2 = context.find ("/",pos1 + 1); + elements.push_back (context.substr (pos1 + 1,pos2 - (pos1 + 1))); + pos1 = pos2; + } return elements; } @@ -927,16 +927,16 @@ void DsrRouting::CheckSendBuffer () //m_downTarget (newPacket, m_mainAddress, nextHop, GetProtocolNumber (), m_ipv4Route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); - - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); + + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } } else @@ -1051,7 +1051,7 @@ bool DsrRouting::PromiscReceive (Ptr device, Ptr packet // Remove the ipv4 header here Ptr pktMinusIpHdr = packet->Copy (); Ipv4Header ipv4Header; - pktMinusIpHdr->RemoveHeader(ipv4Header); + pktMinusIpHdr->RemoveHeader (ipv4Header); if (ipv4Header.GetProtocol () != DsrRouting::PROT_NUMBER) { @@ -1287,38 +1287,38 @@ DsrRouting::SendUnreachError (Ipv4Address unreachNode, Ipv4Address destination, if (!findRoute) { if (destination == m_mainAddress) - { - NS_LOG_INFO ("We are the error source, send request to original dst " << originalDst); - // Send error request message if we are the source node - SendErrorRequest (rerrUnreachHeader, protocol); - } - else - { - NS_LOG_INFO (Simulator::Now ().GetSeconds () - << "s " << m_mainAddress << " there is no route for this packet, queue the packet"); - - dsrRoutingHeader.SetPayloadLength (rerrLength + 2); - dsrRoutingHeader.AddDsrOption (rerrUnreachHeader); - newPacket->AddHeader (dsrRoutingHeader); - Ptr p = newPacket->Copy (); - // Save the error packet in the error buffer - DsrErrorBuffEntry newEntry (p, destination, m_mainAddress, unreachNode, m_sendBufferTimeout, protocol); - bool result = m_errorBuffer.Enqueue (newEntry); // Enqueue the packet in send buffer - if (result) - { - NS_LOG_INFO (Simulator::Now ().GetSeconds () - << "s Add packet PID: " << p->GetUid () << " to queue. Packet: " << *p); - NS_LOG_LOGIC ("Send RREQ to" << destination); - if ((m_addressReqTimer.find (destination) == m_addressReqTimer.end ()) && (m_nonPropReqTimer.find (destination) == m_nonPropReqTimer.end ())) - { - NS_LOG_DEBUG ("When there is no existing route request for " << destination << ", initialize one"); - /* - * Call the send request function, it will update the request table entry and ttl there - */ - SendInitialRequest (m_mainAddress, destination, protocol); - } - } - } + { + NS_LOG_INFO ("We are the error source, send request to original dst " << originalDst); + // Send error request message if we are the source node + SendErrorRequest (rerrUnreachHeader, protocol); + } + else + { + NS_LOG_INFO (Simulator::Now ().GetSeconds () + << "s " << m_mainAddress << " there is no route for this packet, queue the packet"); + + dsrRoutingHeader.SetPayloadLength (rerrLength + 2); + dsrRoutingHeader.AddDsrOption (rerrUnreachHeader); + newPacket->AddHeader (dsrRoutingHeader); + Ptr p = newPacket->Copy (); + // Save the error packet in the error buffer + DsrErrorBuffEntry newEntry (p, destination, m_mainAddress, unreachNode, m_sendBufferTimeout, protocol); + bool result = m_errorBuffer.Enqueue (newEntry); // Enqueue the packet in send buffer + if (result) + { + NS_LOG_INFO (Simulator::Now ().GetSeconds () + << "s Add packet PID: " << p->GetUid () << " to queue. Packet: " << *p); + NS_LOG_LOGIC ("Send RREQ to" << destination); + if ((m_addressReqTimer.find (destination) == m_addressReqTimer.end ()) && (m_nonPropReqTimer.find (destination) == m_nonPropReqTimer.end ())) + { + NS_LOG_DEBUG ("When there is no existing route request for " << destination << ", initialize one"); + /* + * Call the send request function, it will update the request table entry and ttl there + */ + SendInitialRequest (m_mainAddress, destination, protocol); + } + } + } } else { @@ -1359,16 +1359,16 @@ DsrRouting::SendUnreachError (Ipv4Address unreachNode, Ipv4Address destination, //m_downTarget (newPacket, m_mainAddress, nextHop, GetProtocolNumber (), m_ipv4Route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); + DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } } @@ -1404,16 +1404,16 @@ DsrRouting::ForwardErrPacket (DsrOptionRerrUnreachHeader &rerr, //m_downTarget (packet, m_mainAddress, nextHop, GetProtocolNumber (), route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (packet, m_mainAddress, nextHop, Simulator::Now (), route); + DsrNetworkQueueEntry newEntry (packet, m_mainAddress, nextHop, Simulator::Now (), route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } void @@ -1615,17 +1615,17 @@ DsrRouting::SendPacket (Ptr packet, Ipv4Address source, Ipv4Address next //m_downTarget (packet, source, nextHop, GetProtocolNumber (), m_ipv4Route); - /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), m_ipv4Route); + /// \todo New DsrNetworkQueueEntry + DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), m_ipv4Route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } void @@ -1836,7 +1836,7 @@ DsrRouting::SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute, Ipv4Addr } } - NS_LOG_DEBUG ("send buffer size here and the destination " << m_sendBuffer.GetSize() << " " << destination); + NS_LOG_DEBUG ("send buffer size here and the destination " << m_sendBuffer.GetSize () << " " << destination); if (m_sendBuffer.GetSize () != 0 && m_sendBuffer.Find (destination)) { NS_LOG_LOGIC ("Schedule sending the next packet in send buffer"); @@ -1928,16 +1928,16 @@ DsrRouting::SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute, Ipv4Addr //m_downTarget (newPacket, m_mainAddress, nextHop, GetProtocolNumber (), m_ipv4Route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); - - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + DsrNetworkQueueEntry newEntry (newPacket, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); + + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } } @@ -1957,7 +1957,7 @@ DsrRouting::SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute, Ipv4Addr bool DsrRouting::PassiveEntryCheck (Ptr packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft, - uint16_t fragmentOffset, uint16_t identification, bool saveEntry) + uint16_t fragmentOffset, uint16_t identification, bool saveEntry) { NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)segsLeft); @@ -1972,7 +1972,7 @@ DsrRouting::PassiveEntryCheck (Ptr packet, Ipv4Address source, Ipv4Addre newEntry.SetSegsLeft (segsLeft); // We try to make sure the segments left is larger for 1 - NS_LOG_DEBUG ("The passive buffer size " << m_passiveBuffer->GetSize()); + NS_LOG_DEBUG ("The passive buffer size " << m_passiveBuffer->GetSize ()); if (m_passiveBuffer->AllEqual (newEntry) && (!saveEntry)) { @@ -2000,7 +2000,7 @@ DsrRouting::PassiveEntryCheck (Ptr packet, Ipv4Address source, Ipv4Addre bool DsrRouting::CancelPassiveTimer (Ptr packet, Ipv4Address source, Ipv4Address destination, - uint8_t segsLeft) + uint8_t segsLeft) { NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)segsLeft); @@ -2042,7 +2042,7 @@ DsrRouting::CallCancelPacketTimer (uint16_t ackId, Ipv4Header const& ipv4Header, CancelNetworkPacketTimer (newEntry); // Only need to cancel network packet timer } -void +void DsrRouting::CancelPacketAllTimer (DsrMaintainBuffEntry & mb) { NS_LOG_FUNCTION (this); @@ -2094,7 +2094,7 @@ DsrRouting::CancelLinkPacketTimer (DsrMaintainBuffEntry & mb) // Erase the maintenance entry // yet this does not check the segments left value here - NS_LOG_DEBUG ("The link buffer size " << m_maintainBuffer.GetSize()); + NS_LOG_DEBUG ("The link buffer size " << m_maintainBuffer.GetSize ()); if (m_maintainBuffer.LinkEqual (mb)) { NS_LOG_INFO ("Link acknowledgment received, remove same maintenance buffer entry"); @@ -2234,12 +2234,12 @@ DsrRouting::CancelPacketTimerNextHop (Ipv4Address nextHop, uint8_t protocol) errorDst = source; } /// TODO if the errorDst is not seen before - if (std::find(previousErrorDst.begin(), previousErrorDst.end(), destination)==previousErrorDst.end()) - { - NS_LOG_DEBUG ("have not seen this dst before " << errorDst << " in " << previousErrorDst.size()); - SendUnreachError (nextHop, errorDst, destination, salvage, protocol); - previousErrorDst.push_back(errorDst); - } + if (std::find (previousErrorDst.begin (), previousErrorDst.end (), destination) == previousErrorDst.end ()) + { + NS_LOG_DEBUG ("have not seen this dst before " << errorDst << " in " << previousErrorDst.size ()); + SendUnreachError (nextHop, errorDst, destination, salvage, protocol); + previousErrorDst.push_back (errorDst); + } /* * Cancel the packet timer and then salvage the data packet @@ -2259,7 +2259,7 @@ DsrRouting::CancelPacketTimerNextHop (Ipv4Address nextHop, uint8_t protocol) { NS_LOG_INFO ("Maintenance buffer entry not found"); } - /// TODO need to think about whether we need the network queue entry or not + /// TODO need to think about whether we need the network queue entry or not } void @@ -2336,16 +2336,16 @@ DsrRouting::SalvagePacket (Ptr packet, Ipv4Address source, Ipv4Add //m_downTarget (p, m_mainAddress, nextHop, GetProtocolNumber (), m_ipv4Route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (p, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); + DsrNetworkQueueEntry newEntry (p, m_mainAddress, nextHop, Simulator::Now (), m_ipv4Route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } /* * Mark the next hop address in blacklist @@ -2458,7 +2458,7 @@ DsrRouting::ScheduleNetworkPacketRetry (DsrMaintainBuffEntry & mb, networkKey.m_destination = newEntry.GetDst (); m_addressForwardCnt[networkKey] = 0; - if (! m_maintainBuffer.Enqueue (newEntry)) + if (!m_maintainBuffer.Enqueue (newEntry)) { NS_LOG_ERROR ("Failed to enqueue packet retry"); } @@ -3105,15 +3105,15 @@ DsrRouting::SendRequest (Ptr packet, //m_downTarget (packet, source, m_broadcast, GetProtocolNumber (), 0); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (packet, source, m_broadcast, Simulator::Now (), 0); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + DsrNetworkQueueEntry newEntry (packet, source, m_broadcast, Simulator::Now (), 0); + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } void @@ -3211,15 +3211,15 @@ DsrRouting::SendReply (Ptr packet, //m_downTarget (packet, source, nextHop, GetProtocolNumber (), route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + DsrNetworkQueueEntry newEntry (packet, source, nextHop, Simulator::Now (), route); + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } void @@ -3288,15 +3288,15 @@ DsrRouting::SendAck (uint16_t ackId, //m_downTarget (packet, m_mainAddress, destination, GetProtocolNumber (), route); /// \todo New DsrNetworkQueueEntry - DsrNetworkQueueEntry newEntry (packet, m_mainAddress, destination, Simulator::Now (), route); - if (dsrNetworkQueue->Enqueue (newEntry)) - { - Scheduler (priority); - } - else - { - NS_LOG_INFO ("Packet dropped as dsr network queue is full"); - } + DsrNetworkQueueEntry newEntry (packet, m_mainAddress, destination, Simulator::Now (), route); + if (dsrNetworkQueue->Enqueue (newEntry)) + { + Scheduler (priority); + } + else + { + NS_LOG_INFO ("Packet dropped as dsr network queue is full"); + } } enum IpL4Protocol::RxStatus @@ -3345,7 +3345,7 @@ DsrRouting::Receive (Ptr p, uint8_t segmentsLeft = 0; optionType = *(data); - NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet id " << p->GetUid()); + NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet id " << p->GetUid ()); dsrOption = GetOption (optionType); // Get the relative dsr option and demux to the process function Ipv4Address promiscSource; /// this is just here for the sake of passing in the promisc source if (optionType == 1) // This is the request option diff --git a/src/dsr/model/dsr-routing.h b/src/dsr/model/dsr-routing.h index dee49b06316..f6f9ce9d77c 100644 --- a/src/dsr/model/dsr-routing.h +++ b/src/dsr/model/dsr-routing.h @@ -227,6 +227,10 @@ class DsrRouting : public IpL4Protocol void CheckSendBuffer (); /** * \brief When route vector corrupted, originate a new packet, normally not happening. + * \param packet to route + * \param source address + * \param destination address + * \param protocol number */ void PacketNewRoute (Ptr packet, Ipv4Address source, @@ -248,9 +252,19 @@ class DsrRouting : public IpL4Protocol uint32_t GetPriority (DsrMessageType messageType); /** * \brief This function is responsible for sending error packets in case of break link to next hop + * \param unreachNode unreachable node + * \param destination address + * \param originalDst address + * \param salvage packet flag + * \param protocol number */ void SendUnreachError (Ipv4Address unreachNode, Ipv4Address destination, Ipv4Address originalDst, uint8_t salvage, uint8_t protocol); /** * \brief This function is responsible for forwarding error packets along the route + * \param rerr unreachable header + * \param sourceRoute source routing header + * \param nextHop IP address of next hop + * \param protocol number + * \param route IP route */ void ForwardErrPacket (DsrOptionRerrUnreachHeader &rerr, DsrOptionSRHeader &sourceRoute, @@ -259,23 +273,38 @@ class DsrRouting : public IpL4Protocol Ptr route); /** * \brief This function is called by higher layer protocol when sending packets + * \param packet to send + * \param source IP address + * \param destination IP address + * \param protocol number + * \param route IP route */ void Send (Ptr packet, Ipv4Address source, Ipv4Address destination, uint8_t protocol, Ptr route); /** * \brief This function is called to add ack request header for network acknowledgement + * \param packet for ack req + * \param nextHop IP address of the next hop + * \return ack ID */ uint16_t AddAckReqHeader (Ptr &packet, Ipv4Address nextHop); /** * \brief This function is called by when really sending out the packet + * \param packet to send + * \param source IP address + * \param nextHop IP address + * \param protocol number */ void SendPacket (Ptr packet, Ipv4Address source, Ipv4Address nextHop, uint8_t protocol); /** * \brief This function is called to schedule sending packets from the network queue + * \param priority for sending */ void Scheduler (uint32_t priority); /** * \brief This function is called to schedule sending packets from the network queue by priority + * \param priority schedule + * \param continueWithFirst use all priorities */ void PriorityScheduler (uint32_t priority, bool continueWithFirst); /** @@ -284,51 +313,83 @@ class DsrRouting : public IpL4Protocol void IncreaseRetransTimer (); /** * \brief This function is called to send packets down stack + * \param newEntry queue entry + * \return true if success */ bool SendRealDown (DsrNetworkQueueEntry & newEntry); /** * \brief This function is responsible for sending out data packets when have route, if no route found, it will * cache the packet and send out route requests + * \param sourceRoute source route + * \param nextHop next hop IP address + * \param protocol number */ void SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute, Ipv4Address nextHop, uint8_t protocol); /** * \brief Find the same passive entry + * \param packet to process + * \param source IP address + * \param destination IP address + * \param segsLeft segments left + * \param fragmentOffset + * \param identification + * \param saveEntry + * \return true if passive buffer entry */ bool PassiveEntryCheck (Ptr packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft, uint16_t fragmentOffset, uint16_t identification, bool saveEntry); /** * \brief Cancel all the packet timers + * \param mb maintain buffer entry */ void CancelPacketAllTimer (DsrMaintainBuffEntry & mb); /** * \brief Cancel the passive timer + * \param packet to process + * \param source IP address + * \param destination IP address + * \param segsLeft segments left + * \return */ bool CancelPassiveTimer (Ptr packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft); /** * \brief Call the cancel packet retransmission timer function + * \param ackId acknowledge ID + * \param ipv4Header header + * \param realSrc source IP address + * \param realDst destination IP address */ void CallCancelPacketTimer (uint16_t ackId, Ipv4Header const& ipv4Header, Ipv4Address realSrc, Ipv4Address realDst); /** * \brief Cancel the network packet retransmission timer for a specific maintenance entry + * \param mb maintian byffer entry */ void CancelNetworkPacketTimer (DsrMaintainBuffEntry & mb); /** * \brief Cancel the passive packet retransmission timer for a specific maintenance entry + * \param mb maintian byffer entry */ void CancelPassivePacketTimer (DsrMaintainBuffEntry & mb); /** * \brief Cancel the link packet retransmission timer for a specific maintenance entry + * \param mb maintian byffer entry */ void CancelLinkPacketTimer (DsrMaintainBuffEntry & mb); /** * \brief Cancel the packet retransmission timer for a all maintenance entries with nextHop address + * \param nextHop next hop IP address + * \param protocol number */ void CancelPacketTimerNextHop (Ipv4Address nextHop, uint8_t protocol); /** * \brief Salvage the packet which has been transmitted for 3 times + * \param packet to process + * \param source IP address + * \param dst destination IP address + * \param protocol number */ void SalvagePacket (Ptr packet, Ipv4Address source, Ipv4Address dst, uint8_t protocol); /** @@ -447,6 +508,7 @@ class DsrRouting : public IpL4Protocol * \param source IPv4 address of the source (i.e. request originator) * \param destination IPv4 address of the destination * \param route Route + * \param hops number of hops */ void ScheduleCachedReply (Ptr packet, Ipv4Address source, @@ -548,14 +610,14 @@ class DsrRouting : public IpL4Protocol */ void RouteRequestTimerExpire (Ptr packet, std::vector address, uint32_t requestId, uint8_t protocol); - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * \return the number of stream indices assigned by this model - */ + /** + * Assign a fixed random variable stream number to the random variables + * used by this model. Return the number of streams (possibly zero) that + * have been assigned. + * + * \param stream first stream index to use + * \return the number of stream indices assigned by this model + */ int64_t AssignStreams (int64_t stream); protected: @@ -571,11 +633,10 @@ class DsrRouting : public IpL4Protocol /** * The trace for drop, receive and send data packets */ - TracedCallback > m_dropTrace; - TracedCallback m_txPacketTrace; + TracedCallback > m_dropTrace; ///< packet drop trace callback + TracedCallback m_txPacketTrace; ///< packet trace callback private: - void Start (); /** * \brief Send the route error message when the link breaks to the next hop. diff --git a/src/dsr/model/dsr-rreq-table.h b/src/dsr/model/dsr-rreq-table.h index adb2e7cb441..1001593434d 100644 --- a/src/dsr/model/dsr-rreq-table.h +++ b/src/dsr/model/dsr-rreq-table.h @@ -105,7 +105,7 @@ class DsrReceivedRreqEntry bool operator== (DsrReceivedRreqEntry const & o) const { return ((m_destination == o.m_destination) && (m_identification == o.m_identification) - ); + ); } /** @@ -199,7 +199,10 @@ class DsrReceivedRreqEntry class DsrRreqTable : public Object { public: - + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); DsrRreqTable (); diff --git a/src/dsr/model/dsr-rsendbuff.cc b/src/dsr/model/dsr-rsendbuff.cc index d716ea3746a..d5ff752bae1 100644 --- a/src/dsr/model/dsr-rsendbuff.cc +++ b/src/dsr/model/dsr-rsendbuff.cc @@ -39,7 +39,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsrSendBuffer"); - + namespace dsr { uint32_t @@ -140,6 +140,11 @@ DsrSendBuffer::Find (Ipv4Address dst) struct IsExpired { + /** + * comparison operator + * \param e entry to compare + * \return true if expired + */ bool operator() (DsrSendBuffEntry const & e) const { diff --git a/src/dsr/model/dsr-rsendbuff.h b/src/dsr/model/dsr-rsendbuff.h index 2979ec18965..70fdf02b2d6 100644 --- a/src/dsr/model/dsr-rsendbuff.h +++ b/src/dsr/model/dsr-rsendbuff.h @@ -54,7 +54,7 @@ class DsrSendBuffEntry * \param p protocol number */ DsrSendBuffEntry (Ptr pa = 0, Ipv4Address d = Ipv4Address (), - Time exp = Simulator::Now (), uint8_t p = 0) + Time exp = Simulator::Now (), uint8_t p = 0) : m_packet (pa), m_dst (d), m_expire (exp + Simulator::Now ()), @@ -70,36 +70,68 @@ class DsrSendBuffEntry { return ((m_packet == o.m_packet) && (m_dst == o.m_dst) && (m_expire == o.m_expire)); } - + // Fields + /** + * Get pointer to entry's packet + * \returns the current packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set pointer to entry's packet + * \param p the current packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get destination address of entry + * \returns the destination IPv4 address + */ Ipv4Address GetDestination () const { return m_dst; } + /** + * Set destination address of entry + * \param d the destination IP address + */ void SetDestination (Ipv4Address d) { m_dst = d; } + /** + * Set expire time for entry + * \param exp the expire time + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expire time for entry + * \returns the expire time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); } + /** + * Set protocol value + * \param p the protocol + */ void SetProtocol (uint8_t p) { m_protocol = p; } + /** + * Get protocol value + * \returns the protocol + */ uint8_t GetProtocol () const { return m_protocol; @@ -217,7 +249,6 @@ class DsrSendBuffer } private: - std::vector m_sendBuffer; ///< The send buffer to cache unsent packet void Purge (); ///< Remove all expired entries void Drop (DsrSendBuffEntry en, std::string reason); ///< Notify that packet is dropped from queue by timeout diff --git a/src/dsr/test/dsr-test-suite.cc b/src/dsr/test/dsr-test-suite.cc index 83b15ca25fa..55b81017834 100644 --- a/src/dsr/test/dsr-test-suite.cc +++ b/src/dsr/test/dsr-test-suite.cc @@ -53,7 +53,19 @@ using namespace ns3; using namespace dsr; // ----------------------------------------------------------------------------- -// / Unit test for DSR Fixed Size Header +/** + * \ingroup dsr-test + * \defgroup dsr-test DSR routing module tests + */ + + +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrFsHeaderTest + * \brief Unit test for DSR Fixed Size Header + */ class DsrFsHeaderTest : public TestCase { public: @@ -85,7 +97,13 @@ DsrFsHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (*(data + 8), rreqHeader.GetType (), "expect the rreqHeader after fixed size header"); } // ----------------------------------------------------------------------------- -// / Unit test for RREQ +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrRreqHeaderTest + * \brief Unit test for RREQ + */ class DsrRreqHeaderTest : public TestCase { public: @@ -130,7 +148,13 @@ DsrRreqHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 20, "Total RREP is 20 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for RREP +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrRrepHeaderTest + * \brief Unit test for RREP + */ class DsrRrepHeaderTest : public TestCase { public: @@ -171,7 +195,13 @@ DsrRrepHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 16, "Total RREP is 16 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for Source Route +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrSRHeaderTest + * \brief Unit test for Source Route + */ class DsrSRHeaderTest : public TestCase { public: @@ -216,7 +246,13 @@ DsrSRHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 16, "Total RREP is 16 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for RERR +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrRerrHeaderTest + * \brief Unit test for RERR + */ class DsrRerrHeaderTest : public TestCase { public: @@ -255,7 +291,13 @@ DsrRerrHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 20, "Total RREP is 20 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for ACK-REQ +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrAckReqHeaderTest + * \brief Unit test for ACK-REQ + */ class DsrAckReqHeaderTest : public TestCase { public: @@ -291,7 +333,13 @@ DsrAckReqHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 4, "Total RREP is 4 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for ACK +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrAckHeaderTest + * \brief Unit test for ACK + */ class DsrAckHeaderTest : public TestCase { public: @@ -331,7 +379,13 @@ DsrAckHeaderTest::DoRun () NS_TEST_EXPECT_MSG_EQ (bytes, 12, "Total RREP is 12 bytes long"); } // ----------------------------------------------------------------------------- -// / Unit test for DSR route cache entry +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrCacheEntryTest + * \brief Unit test for DSR route cache entry + */ class DsrCacheEntryTest : public TestCase { public: @@ -384,7 +438,13 @@ DsrCacheEntryTest::DoRun () NS_TEST_EXPECT_MSG_EQ (rcache->DeleteRoute (Ipv4Address ("1.1.1.1")), false, "trivial"); } // ----------------------------------------------------------------------------- -// / Unit test for Send Buffer +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrSendBuffTest + * \brief Unit test for Send Buffer + */ class DsrSendBuffTest : public TestCase { public: @@ -392,10 +452,12 @@ class DsrSendBuffTest : public TestCase ~DsrSendBuffTest (); virtual void DoRun (void); + /// Check size limit function void CheckSizeLimit (); + /// Check timeout function void CheckTimeout (); - dsr::DsrSendBuffer q; + dsr::DsrSendBuffer q; ///< send buffer }; DsrSendBuffTest::DsrSendBuffTest () : TestCase ("DSR SendBuff"), @@ -478,7 +540,13 @@ DsrSendBuffTest::CheckTimeout () NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 0, "Must be empty now"); } // ----------------------------------------------------------------------------- -// / Unit test for DSR routing table entry +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrRreqTableTest + * \brief Unit test for DSR routing table entry + */ class DsrRreqTableTest : public TestCase { public: @@ -503,6 +571,13 @@ DsrRreqTableTest::DoRun () NS_TEST_EXPECT_MSG_EQ (rt.m_reqNo, 2, "trivial"); } // ----------------------------------------------------------------------------- +/** + * \ingroup dsr-test + * \ingroup tests + * + * \class DsrTestSuite + * \brief DSR test suite + */ class DsrTestSuite : public TestSuite { public: From e663d7035738e813649a6849cfcf14387b758d1d Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Wed, 10 May 2017 00:06:51 +0200 Subject: [PATCH 036/551] various doxygen fixes --- doc/doxygen.conf | 1 + .../test/udp-client-server-test.cc | 21 +++++++-- src/flow-monitor/model/ipv4-flow-classifier.h | 4 ++ src/flow-monitor/model/ipv6-flow-classifier.h | 4 ++ .../test/tcp-advertised-window-test.cc | 6 ++- src/netanim/test/netanim-test.cc | 3 +- src/olsr/helper/olsr-helper.h | 1 + src/olsr/model/olsr-routing-protocol.h | 13 +++++- src/olsr/test/bug780-test.h | 15 +++++-- src/olsr/test/hello-regression-test.h | 15 +++++-- src/olsr/test/olsr-header-test-suite.cc | 45 ++++++++++++++++++- .../test/olsr-routing-protocol-test-suite.cc | 27 +++++++++-- src/olsr/test/regression-test-suite.cc | 11 ++++- src/olsr/test/tc-regression-test.h | 18 ++++++-- 14 files changed, 157 insertions(+), 27 deletions(-) diff --git a/doc/doxygen.conf b/doc/doxygen.conf index 20ecfba8ae9..ce07d8b88a7 100644 --- a/doc/doxygen.conf +++ b/doc/doxygen.conf @@ -2079,6 +2079,7 @@ PREDEFINED = NS3_ASSERT_ENABLE \ NS_LOG_COMPONENT_DEFINE()=1 \ NS_LOG_COMPONENT_DEFINE_MASK()=1 \ NS_OBJECT_ENSURE_REGISTERED()=1 \ + NS_OBJECT_TEMPLATE_CLASS_DEFINE()=1 \ NS3_BUILD_PROFILE_DEBUG \ NS3_BUILD_PROFILE_RELEASE \ NS3_BUILD_PROFILE_OPTIMIZED diff --git a/src/applications/test/udp-client-server-test.cc b/src/applications/test/udp-client-server-test.cc index b38f0bd6c33..0816339b5aa 100644 --- a/src/applications/test/udp-client-server-test.cc +++ b/src/applications/test/udp-client-server-test.cc @@ -38,10 +38,17 @@ using namespace ns3; /** - * Test that all the udp packets generated by an udpClient application are - * correctly received by an udpServer application + * \ingroup applications + * \defgroup applications-test applications module tests */ +/** + * \ingroup applications-test + * \ingroup tests + * + * Test that all the UDP packets generated by an UdpClient application are + * correctly received by an UdpServer application + */ class UdpClientServerTestCase : public TestCase { public: @@ -331,6 +338,14 @@ void UdpEchoClientSetFillTestCase::DoRun (void) Simulator::Destroy (); } + + +/** + * \ingroup applications-test + * \ingroup tests + * + * \brief UDP client and server TestSuite + */ class UdpClientServerTestSuite : public TestSuite { public: @@ -346,4 +361,4 @@ UdpClientServerTestSuite::UdpClientServerTestSuite () AddTestCase (new UdpEchoClientSetFillTestCase, TestCase::QUICK); } -static UdpClientServerTestSuite udpClientServerTestSuite; +static UdpClientServerTestSuite udpClientServerTestSuite; //!< Static variable for test initialization diff --git a/src/flow-monitor/model/ipv4-flow-classifier.h b/src/flow-monitor/model/ipv4-flow-classifier.h index ada9542d1e5..dbc64198e34 100644 --- a/src/flow-monitor/model/ipv4-flow-classifier.h +++ b/src/flow-monitor/model/ipv4-flow-classifier.h @@ -73,6 +73,10 @@ class Ipv4FlowClassifier : public FlowClassifier class SortByCount { public: + /// Comparator function + /// \param left left operand + /// \param right right operand + /// \return true if left DSCP is greater than right DSCP bool operator() (std::pair left, std::pair right); }; diff --git a/src/flow-monitor/model/ipv6-flow-classifier.h b/src/flow-monitor/model/ipv6-flow-classifier.h index 658c9006b1f..d6b2aacc9e1 100644 --- a/src/flow-monitor/model/ipv6-flow-classifier.h +++ b/src/flow-monitor/model/ipv6-flow-classifier.h @@ -74,6 +74,10 @@ class Ipv6FlowClassifier : public FlowClassifier class SortByCount { public: + /// Comparator function + /// \param left left operand + /// \param right right operand + /// \return true if left DSCP is greater than right DSCP bool operator() (std::pair left, std::pair right); }; diff --git a/src/internet/test/tcp-advertised-window-test.cc b/src/internet/test/tcp-advertised-window-test.cc index d119a379348..81a4a805d4f 100644 --- a/src/internet/test/tcp-advertised-window-test.cc +++ b/src/internet/test/tcp-advertised-window-test.cc @@ -37,7 +37,8 @@ class TcpSocketAdvertisedWindowProxy : public TcpSocketMsgBase { public: /** - * \brief Get type id + * \brief Get the type ID. + * \return the object TypeId */ static TypeId GetTypeId (void); @@ -211,7 +212,8 @@ class TcpDropRatioErrorModel : public TcpGeneralErrorModel { public: /** - * \brief Get type id + * \brief Get the type ID. + * \return the object TypeId */ static TypeId GetTypeId (void); /** diff --git a/src/netanim/test/netanim-test.cc b/src/netanim/test/netanim-test.cc index 443d5c3b424..d296a34d9e6 100644 --- a/src/netanim/test/netanim-test.cc +++ b/src/netanim/test/netanim-test.cc @@ -49,6 +49,7 @@ class AbstractAnimationInterfaceTestCase : public TestCase public: /** * \brief Constructor. + * \param name testcase name */ AbstractAnimationInterfaceTestCase (std::string name); /** @@ -70,7 +71,7 @@ class AbstractAnimationInterfaceTestCase : public TestCase private: - /// Prepare nework function + /// Prepare network function virtual void PrepareNetwork () = 0; /// Check logic function diff --git a/src/olsr/helper/olsr-helper.h b/src/olsr/helper/olsr-helper.h index 1e82f83437d..0c267396489 100644 --- a/src/olsr/helper/olsr-helper.h +++ b/src/olsr/helper/olsr-helper.h @@ -101,6 +101,7 @@ class OlsrHelper : public Ipv4RoutingHelper /** * \brief Assignment operator declared private and not implemented to disallow * assignment and prevent the compiler from happily inserting its own. + * \return nothing */ OlsrHelper &operator = (const OlsrHelper &); ObjectFactory m_agentFactory; //!< Object factory diff --git a/src/olsr/model/olsr-routing-protocol.h b/src/olsr/model/olsr-routing-protocol.h index 0fb21286b52..92b726447a6 100644 --- a/src/olsr/model/olsr-routing-protocol.h +++ b/src/olsr/model/olsr-routing-protocol.h @@ -80,6 +80,9 @@ class RoutingProtocol; class RoutingProtocol : public Ipv4RoutingProtocol { public: + /** + * Declared friend to enable unit tests. + */ friend class ::OlsrMprTestCase; /** @@ -106,7 +109,8 @@ class RoutingProtocol : public Ipv4RoutingProtocol void Dump (void); /** - * Return the list of routing table entries discovered by OLSR + * Get the touting table entries. + * \return the list of routing table entries discovered by OLSR */ std::vector GetRoutingTableEntries () const; @@ -747,7 +751,12 @@ class RoutingProtocol : public Ipv4RoutingProtocol const olsr::MessageHeader::Hello &hello); int Degree (NeighborTuple const &tuple); - /// Check that address is one of my interfaces + + /** + * Check that address is one of my interfaces. + * \param a the address to check. + * \return true if the address is own by the node. + */ bool IsMyOwnAddress (const Ipv4Address & a) const; Ipv4Address m_mainAddress; //!< the node main address. diff --git a/src/olsr/test/bug780-test.h b/src/olsr/test/bug780-test.h index 1f9d2d3062e..d379a9e67d8 100644 --- a/src/olsr/test/bug780-test.h +++ b/src/olsr/test/bug780-test.h @@ -25,7 +25,13 @@ namespace ns3 { namespace olsr { -/** See \bugid{780} */ + +/** + * \ingroup olsr-test + * \ingroup tests + * + * See \bugid{780} + */ class Bug780Test : public TestCase { public: @@ -36,12 +42,13 @@ class Bug780Test : public TestCase const Time m_time; /// Create & configure test network void CreateNodes (); - /// Go void DoRun (); /// Send one ping void SendPing (); - /// Receive echo reply - /// \param socket the socket + /** + * Receive echo reply + * \param socket the socket + */ void Receive (Ptr socket); /// Socket Ptr m_socket; diff --git a/src/olsr/test/hello-regression-test.h b/src/olsr/test/hello-regression-test.h index 2f2803d17ea..ce33602ab69 100644 --- a/src/olsr/test/hello-regression-test.h +++ b/src/olsr/test/hello-regression-test.h @@ -30,7 +30,9 @@ namespace ns3 { namespace olsr { /** - * \ingroup olsr + * \ingroup olsr-test + * \ingroup tests + * * \brief Trivial (still useful) test of OLSR operation * * This test creates 2 stations with point-to-point link and runs OLSR without any extra traffic. @@ -57,16 +59,21 @@ class HelloRegressionTest : public TestCase const Time m_time; /// Create & configure test network void CreateNodes (); - /// Go void DoRun (); - /// Receive raw data on node A + /** + * Receive raw data on node A + * \param socket receiving socket + */ void ReceivePktProbeA (Ptr socket); /// Packet counter on node A uint8_t m_countA; /// Receiving socket on node A Ptr m_rxSocketA; - /// Receive raw data on node B + /** + * Receive raw data on node B + * \param socket receiving socket + */ void ReceivePktProbeB (Ptr socket); /// Packet counter on node B uint8_t m_countB; diff --git a/src/olsr/test/olsr-header-test-suite.cc b/src/olsr/test/olsr-header-test-suite.cc index 948b00f00c4..cd3d5a24bc1 100644 --- a/src/olsr/test/olsr-header-test-suite.cc +++ b/src/olsr/test/olsr-header-test-suite.cc @@ -22,8 +22,15 @@ #include "ns3/olsr-header.h" #include "ns3/packet.h" + using namespace ns3; +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check Emf olsr time conversion + */ class OlsrEmfTestCase : public TestCase { public: @@ -48,6 +55,12 @@ OlsrEmfTestCase::DoRun (void) } +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check Mid olsr messages + */ class OlsrMidTestCase : public TestCase { public: @@ -155,6 +168,12 @@ OlsrMidTestCase::DoRun (void) } +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check Hello olsr messages + */ class OlsrHelloTestCase : public TestCase { public: @@ -216,6 +235,12 @@ OlsrHelloTestCase::DoRun (void) } +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check Tc olsr messages + */ class OlsrTcTestCase : public TestCase { public: @@ -255,6 +280,12 @@ OlsrTcTestCase::DoRun (void) } +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check Hna olsr messages + */ class OlsrHnaTestCase : public TestCase { public: @@ -301,11 +332,17 @@ OlsrHnaTestCase::DoRun (void) } -static class OlsrTestSuite : public TestSuite +/** + * \ingroup olsr-test + * \ingroup tests + * + * Check olsr header messages + */ +class OlsrTestSuite : public TestSuite { public: OlsrTestSuite (); -} g_olsrTestSuite; +}; OlsrTestSuite::OlsrTestSuite () : TestSuite ("routing-olsr-header", UNIT) @@ -316,3 +353,7 @@ OlsrTestSuite::OlsrTestSuite () AddTestCase (new OlsrMidTestCase (), TestCase::QUICK); AddTestCase (new OlsrEmfTestCase (), TestCase::QUICK); } + +static OlsrTestSuite g_olsrTestSuite; //!< Static variable for test initialization + + diff --git a/src/olsr/test/olsr-routing-protocol-test-suite.cc b/src/olsr/test/olsr-routing-protocol-test-suite.cc index 029b2095a22..58ecd6bb302 100644 --- a/src/olsr/test/olsr-routing-protocol-test-suite.cc +++ b/src/olsr/test/olsr-routing-protocol-test-suite.cc @@ -24,6 +24,12 @@ #include "ns3/olsr-routing-protocol.h" #include "ns3/ipv4-header.h" +/** + * \ingroup olsr + * \defgroup olsr-test olsr module tests + */ + + /********** Willingness **********/ /// Willingness for forwarding packets from other nodes: never. @@ -40,13 +46,18 @@ using namespace ns3; using namespace olsr; -/// Testcase for MPR computation mechanism + +/** + * \ingroup olsr-test + * \ingroup tests + * + * Testcase for MPR computation mechanism + */ class OlsrMprTestCase : public TestCase { public: OlsrMprTestCase (); ~OlsrMprTestCase (); - /// \brief Run test case virtual void DoRun (void); }; @@ -167,14 +178,22 @@ OlsrMprTestCase::DoRun () NS_TEST_EXPECT_MSG_EQ ((mpr.find ("10.0.0.9") == mpr.end ()), true, "Node 1 must NOT select node 8 as MPR"); } -static class OlsrProtocolTestSuite : public TestSuite +/** + * \ingroup olsr-test + * \ingroup tests + * + * OLSR protocol test suite + */ +class OlsrProtocolTestSuite : public TestSuite { public: OlsrProtocolTestSuite (); -} g_olsrProtocolTestSuite; +}; OlsrProtocolTestSuite::OlsrProtocolTestSuite () : TestSuite ("routing-olsr", UNIT) { AddTestCase (new OlsrMprTestCase (), TestCase::QUICK); } + +static OlsrProtocolTestSuite g_olsrProtocolTestSuite; //!< Static variable for test initialization diff --git a/src/olsr/test/regression-test-suite.cc b/src/olsr/test/regression-test-suite.cc index fe009c797f3..720e2b877aa 100644 --- a/src/olsr/test/regression-test-suite.cc +++ b/src/olsr/test/regression-test-suite.cc @@ -25,6 +25,12 @@ using namespace ns3; using namespace olsr; +/** + * \ingroup olsr-test + * \ingroup tests + * + * Various olsr regression tests + */ class RegressionTestSuite : public TestSuite { public: @@ -35,4 +41,7 @@ class RegressionTestSuite : public TestSuite AddTestCase (new TcRegressionTest, TestCase::QUICK); AddTestCase (new Bug780Test, TestCase::QUICK); } -} g_olsrRegressionTestSuite; +}; + +static RegressionTestSuite g_olsrRegressionTestSuite; //!< Static variable for test initialization + diff --git a/src/olsr/test/tc-regression-test.h b/src/olsr/test/tc-regression-test.h index 35dd0979329..72dfe340b44 100644 --- a/src/olsr/test/tc-regression-test.h +++ b/src/olsr/test/tc-regression-test.h @@ -31,6 +31,8 @@ namespace ns3 { namespace olsr { /** * \ingroup olsr + * \ingroup tests + * * \brief Less trivial test of OLSR Topology Control message generation * * This test simulates 3 Wi-Fi stations with chain topology and runs OLSR without any extra traffic. @@ -82,24 +84,32 @@ class TcRegressionTest : public TestCase const Time m_time; /// Create & configure test network void CreateNodes (); - /// Go void DoRun (); - /// Receive raw data on node A + /** + * Receive raw data on node A + * \param socket receiving socket + */ void ReceivePktProbeA (Ptr socket); /// Packet counter on node A uint8_t m_countA; /// Receiving socket on node A Ptr m_rxSocketA; - /// Receive raw data on node B + /** + * Receive raw data on node B + * \param socket receiving socket + */ void ReceivePktProbeB (Ptr socket); /// Packet counter on node B uint8_t m_countB; /// Receiving socket on node B Ptr m_rxSocketB; - /// Receive raw data on node C + /** + * Receive raw data on node C + * \param socket receiving socket + */ void ReceivePktProbeC (Ptr socket); /// Packet counter on node C uint8_t m_countC; From 8dc24d2c1f54f47051aba514273fbb52d663e53f Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Wed, 10 May 2017 02:17:58 +0200 Subject: [PATCH 037/551] minor doxygen updates --- src/core/model/simple-ref-count.h | 3 +++ src/olsr/test/tc-regression-test.h | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/core/model/simple-ref-count.h b/src/core/model/simple-ref-count.h index 6739a7b5d42..7715ae3a44b 100644 --- a/src/core/model/simple-ref-count.h +++ b/src/core/model/simple-ref-count.h @@ -80,12 +80,15 @@ class SimpleRefCount : public PARENT {} /** * Copy constructor + * \param o The object to be copied */ SimpleRefCount (const SimpleRefCount &o) : m_count (1) {} /** * Assignment + * \param o The object to be copied + * \return A reference to the new object */ SimpleRefCount &operator = (const SimpleRefCount &o) { diff --git a/src/olsr/test/tc-regression-test.h b/src/olsr/test/tc-regression-test.h index 72dfe340b44..a50c7a67543 100644 --- a/src/olsr/test/tc-regression-test.h +++ b/src/olsr/test/tc-regression-test.h @@ -30,7 +30,7 @@ namespace ns3 { namespace olsr { /** - * \ingroup olsr + * \ingroup olsr-test * \ingroup tests * * \brief Less trivial test of OLSR Topology Control message generation From 625e117ce09576150ed441fc56be77639f68b2e4 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Wed, 10 May 2017 07:06:03 -0700 Subject: [PATCH 038/551] visualizer: Fix indentation problems from changeset 12843 --- src/visualizer/visualizer/core.py | 6 +- src/visualizer/visualizer/ipython_view.py | 80 +++++++++++------------ 2 files changed, 43 insertions(+), 43 deletions(-) diff --git a/src/visualizer/visualizer/core.py b/src/visualizer/visualizer/core.py index 2e413cfaacd..7a6b29a5a77 100644 --- a/src/visualizer/visualizer/core.py +++ b/src/visualizer/visualizer/core.py @@ -664,9 +664,9 @@ class ShowTransmissionsMode(object): ## @var __slots__ # enumeration __slots__ = [] - ShowTransmissionsMode.ALL = ShowTransmissionsMode() - ShowTransmissionsMode.NONE = ShowTransmissionsMode() - ShowTransmissionsMode.SELECTED = ShowTransmissionsMode() +ShowTransmissionsMode.ALL = ShowTransmissionsMode() +ShowTransmissionsMode.NONE = ShowTransmissionsMode() +ShowTransmissionsMode.SELECTED = ShowTransmissionsMode() ## Visualizer class Visualizer(gobject.GObject): diff --git a/src/visualizer/visualizer/ipython_view.py b/src/visualizer/visualizer/ipython_view.py index 70b2a0649fe..b5d4d1a7f6c 100644 --- a/src/visualizer/visualizer/ipython_view.py +++ b/src/visualizer/visualizer/ipython_view.py @@ -32,46 +32,46 @@ ## IterableIPShell class class IterableIPShell: - ## @var IP - # IP - ## @var iter_more - # iterate more - ## @var history_level - # history level - ## @var complete_sep - # separators - ## @var prompt - # prompt - ## @var header - # header - ## @var config - # config - ## @var user_ns - # user_ns - ## @var old_stdout - # saved stdout - ## @var old_stderr - # saved stderr - ## @var system - # system - ## @var cfg - # configuration - ## @var colors - # colors - ## @var raw_input_original - # original raw input - ## @var stdin - # cin - ## @var stdout - # cout - ## @var stderr - # cerr - ## @var raw_input - # raw input - ## @var excepthook - # exception hook - ## Constructor - def __init__(self,argv=None,user_ns=None,user_global_ns=None, + ## @var IP + # IP + ## @var iter_more + # iterate more + ## @var history_level + # history level + ## @var complete_sep + # separators + ## @var prompt + # prompt + ## @var header + # header + ## @var config + # config + ## @var user_ns + # user_ns + ## @var old_stdout + # saved stdout + ## @var old_stderr + # saved stderr + ## @var system + # system + ## @var cfg + # configuration + ## @var colors + # colors + ## @var raw_input_original + # original raw input + ## @var stdin + # cin + ## @var stdout + # cout + ## @var stderr + # cerr + ## @var raw_input + # raw input + ## @var excepthook + # exception hook + ## Constructor + def __init__(self,argv=None,user_ns=None,user_global_ns=None, cin=None, cout=None,cerr=None, input_func=None): """! Initializer From bca75201d968ef07ad3e5fc5e402285684b2a8ae Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 10:42:41 -0700 Subject: [PATCH 039/551] wifi: Doxygen fixes --- src/wifi/helper/ht-wifi-mac-helper.h | 4 +--- src/wifi/helper/nqos-wifi-mac-helper.h | 5 ++--- src/wifi/helper/qos-wifi-mac-helper.h | 5 ++--- src/wifi/helper/vht-wifi-mac-helper.h | 5 ++--- src/wifi/helper/wifi-helper.h | 4 ++-- src/wifi/model/interference-helper.h | 2 +- src/wifi/model/simple-frame-capture-model.h | 2 +- src/wifi/model/wifi-mac-queue.h | 2 -- 8 files changed, 11 insertions(+), 18 deletions(-) diff --git a/src/wifi/helper/ht-wifi-mac-helper.h b/src/wifi/helper/ht-wifi-mac-helper.h index 2823f66619e..7a5c94ed6e8 100644 --- a/src/wifi/helper/ht-wifi-mac-helper.h +++ b/src/wifi/helper/ht-wifi-mac-helper.h @@ -27,9 +27,6 @@ #include "qos-wifi-mac-helper.h" #include -/** - * (Deprecated) ns3::HtWifiMacHelper declaration. - */ namespace ns3 { @@ -38,6 +35,7 @@ namespace ns3 { * * This class can create MACs of type ns3::ApWifiMac, ns3::StaWifiMac, * and, ns3::AdhocWifiMac, with QosSupported and HTSupported attributes set to True. + * \deprecated This class deprecated and replaced by ns3::WifiMacHelper */ class HtWifiMacHelper : public QosWifiMacHelper { diff --git a/src/wifi/helper/nqos-wifi-mac-helper.h b/src/wifi/helper/nqos-wifi-mac-helper.h index 3b4c1165108..71044a53a5a 100644 --- a/src/wifi/helper/nqos-wifi-mac-helper.h +++ b/src/wifi/helper/nqos-wifi-mac-helper.h @@ -23,9 +23,6 @@ #include "wifi-helper.h" -/** - * (Deprecated) ns3::NonQosWifiMacHelper declaration. - */ namespace ns3 { @@ -34,6 +31,8 @@ namespace ns3 { * * This class can create MACs of type ns3::ApWifiMac, ns3::StaWifiMac, * and, ns3::AdhocWifiMac, with QosSupported attribute set to False. + * + * \deprecated This class deprecated and replaced by ns3::WifiMacHelper */ class NqosWifiMacHelper : public WifiMacHelper { diff --git a/src/wifi/helper/qos-wifi-mac-helper.h b/src/wifi/helper/qos-wifi-mac-helper.h index b4750d27562..bf61b42aef8 100644 --- a/src/wifi/helper/qos-wifi-mac-helper.h +++ b/src/wifi/helper/qos-wifi-mac-helper.h @@ -26,9 +26,6 @@ #include -/** - * (Deprecated) ns3::QosWifiMacHelper declaration. - */ namespace ns3 { @@ -37,6 +34,8 @@ namespace ns3 { * * This class can create MACs of type ns3::ApWifiMac, ns3::StaWifiMac, * and, ns3::AdhocWifiMac, with QosSupported attribute set to True. + * + * \deprecated This class deprecated and replaced by ns3::WifiMacHelper */ class QosWifiMacHelper : public WifiMacHelper { diff --git a/src/wifi/helper/vht-wifi-mac-helper.h b/src/wifi/helper/vht-wifi-mac-helper.h index 59a365ca7ee..b6a5b955d3c 100644 --- a/src/wifi/helper/vht-wifi-mac-helper.h +++ b/src/wifi/helper/vht-wifi-mac-helper.h @@ -27,9 +27,6 @@ #include "qos-wifi-mac-helper.h" #include -/** - * (Deprecated) ns3::VhtWifiMacHelper declaration. - */ namespace ns3 { @@ -38,6 +35,8 @@ namespace ns3 { * * This class can create MACs of type ns3::ApWifiMac, ns3::StaWifiMac, * and, ns3::AdhocWifiMac, with QosSupported, HTSupported and VHTSupported attributes set to True + * + * \deprecated This class deprecated and replaced by ns3::WifiMacHelper */ class VhtWifiMacHelper : public QosWifiMacHelper { diff --git a/src/wifi/helper/wifi-helper.h b/src/wifi/helper/wifi-helper.h index 74f88df9b92..1e672dd7eb6 100644 --- a/src/wifi/helper/wifi-helper.h +++ b/src/wifi/helper/wifi-helper.h @@ -277,8 +277,8 @@ class WifiHelper * \returns a device container which contains all the devices created by this method. */ NetDeviceContainer - virtual Install (const WifiPhyHelper &phyHelper, - const WifiMacHelper &macHelper, + virtual Install (const WifiPhyHelper &phy, + const WifiMacHelper &mac, NodeContainer::Iterator first, NodeContainer::Iterator last) const; /** diff --git a/src/wifi/model/interference-helper.h b/src/wifi/model/interference-helper.h index bec3b1407a1..319f0e267ab 100644 --- a/src/wifi/model/interference-helper.h +++ b/src/wifi/model/interference-helper.h @@ -253,7 +253,7 @@ class InterferenceHelper private: Time m_time; ///< time double m_delta; ///< delta - Ptr m_event; + Ptr m_event; ///< event }; /** * typedef for a vector of NiChanges diff --git a/src/wifi/model/simple-frame-capture-model.h b/src/wifi/model/simple-frame-capture-model.h index b3baabac96b..d8c0abd9dfc 100644 --- a/src/wifi/model/simple-frame-capture-model.h +++ b/src/wifi/model/simple-frame-capture-model.h @@ -73,7 +73,7 @@ class SimpleFrameCaptureModel : public FrameCaptureModel private: - double m_margin; + double m_margin; ///< margin for determining if a new frame }; } //namespace ns3 diff --git a/src/wifi/model/wifi-mac-queue.h b/src/wifi/model/wifi-mac-queue.h index 3fbf8d27e2a..9815826f768 100644 --- a/src/wifi/model/wifi-mac-queue.h +++ b/src/wifi/model/wifi-mac-queue.h @@ -250,8 +250,6 @@ class WifiQueue : public Queue /** * Return first available packet for transmission. The packet is not removed from queue. * - * \param hdr the header of the dequeued packet - * \param tStamp * \param blockedPackets * * \return packet From 84cbc0a0cfb4eed9fd7c947497fa27c874a0c2a3 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 10:43:36 -0700 Subject: [PATCH 040/551] olsr: Doxygen fixes --- src/olsr/model/olsr-repositories.h | 3 --- src/olsr/model/olsr-state.h | 1 - 2 files changed, 4 deletions(-) diff --git a/src/olsr/model/olsr-repositories.h b/src/olsr/model/olsr-repositories.h index 282c5425684..aa47c5db6ca 100644 --- a/src/olsr/model/olsr-repositories.h +++ b/src/olsr/model/olsr-repositories.h @@ -20,9 +20,6 @@ * Gustavo J. A. M. Carneiro */ -/// -/// \brief Here are defined all data structures needed by an OLSR node. -/// #ifndef OLSR_REPOSITORIES_H #define OLSR_REPOSITORIES_H diff --git a/src/olsr/model/olsr-state.h b/src/olsr/model/olsr-state.h index eda6af53986..ce6f079ad2c 100644 --- a/src/olsr/model/olsr-state.h +++ b/src/olsr/model/olsr-state.h @@ -20,7 +20,6 @@ * Gustavo J. A. M. Carneiro */ -/// \brief This header file declares and defines internal state of an OLSR node. #ifndef OLSR_STATE_H #define OLSR_STATE_H From 85d28fa21778b2a13c7825dd38b0fcfb3f961505 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 10:45:43 -0700 Subject: [PATCH 041/551] dsr: Fix doxygen typo --- src/dsr/model/dsr-rcache.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dsr/model/dsr-rcache.cc b/src/dsr/model/dsr-rcache.cc index dcc2fb656d0..559815f2404 100644 --- a/src/dsr/model/dsr-rcache.cc +++ b/src/dsr/model/dsr-rcache.cc @@ -339,7 +339,7 @@ DsrRouteCache::RebuildBestRouteTable (Ipv4Address source) } d[source] = 0; /** - * \brief The followingis the core of Dijkstra algorithm + * \brief The following is the core of Dijkstra algorithm */ // the node set which shortest distance has been calculated, if true calculated std::map s; From 204bf069949515ca6858cfbc6a9c0e741426cc81 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 10:53:33 -0700 Subject: [PATCH 042/551] lte: Doxygen fixes --- src/lte/test/lte-ffr-simple.h | 2 +- src/lte/test/lte-test-deactivate-bearer.h | 20 ++++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/lte/test/lte-ffr-simple.h b/src/lte/test/lte-ffr-simple.h index 52d17d1abc5..4ae6a1e2894 100644 --- a/src/lte/test/lte-ffr-simple.h +++ b/src/lte/test/lte-ffr-simple.h @@ -155,7 +155,7 @@ class LteFfrSimple : public LteFfrAlgorithm // Uplink Power Control uint32_t m_tpc; ///< transmission power control to be used uint32_t m_tpcNum; ///< number of TPC configurations - bool m_accumulatedMode; ///whether to use the TPC accumulated mode + bool m_accumulatedMode; ///< whether to use the TPC accumulated mode }; // end of class LteFfrSimple diff --git a/src/lte/test/lte-test-deactivate-bearer.h b/src/lte/test/lte-test-deactivate-bearer.h index 12e466a5dec..119b03239b3 100644 --- a/src/lte/test/lte-test-deactivate-bearer.h +++ b/src/lte/test/lte-test-deactivate-bearer.h @@ -1,5 +1,5 @@ -/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ - +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ + #ifndef LENA_TEST_DEACTIVATE_BEARER_H #define LENA_TEST_DEACTIVATE_BEARER_H @@ -13,12 +13,12 @@ namespace ns3 { * \ingroup lte-test * \ingroup tests * - * \brief Test case that for testing the deactivation of the bearer - * functionality. The test consist in deactivating the bearer and checking - * if some traffic will apear afterwards on the given bearer. If some traffic - * is detected the test will fail. Firs the de-activation is performed by - * using Simulator::Schedule() method which will initiate bearer de-activation - * after deActivateTime that is specified as the test parameter. Additinally, + * \brief Test case that for testing the deactivation of the bearer + * functionality. The test consist in deactivating the bearer and checking + * if some traffic will apear afterwards on the given bearer. If some traffic + * is detected the test will fail. Firs the de-activation is performed by + * using Simulator::Schedule() method which will initiate bearer de-activation + * after deActivateTime that is specified as the test parameter. Additionally, * test instantiate de-activation in sequence. */ @@ -32,8 +32,8 @@ class LenaDeactivateBearerTestCase : public TestCase * \param estThrPssDl estimated throughput PSS DL * \param packetSize packet size in bytes * \param interval interval time in ms - * \param whether the errorModelEnabled error model is enabled - * \param whether to useIdealRrc use ideal RRC + * \param errorModelEnabled whether the error model is enabled + * \param useIdealRrc whether to use ideal RRC */ LenaDeactivateBearerTestCase (std::vector dist, std::vector estThrPssDl, std::vector packetSize, uint16_t interval, bool errorModelEnabled, bool useIdealRrc); virtual ~LenaDeactivateBearerTestCase (); From 4e6e202437476b47ef76e6817e3c194375308c0d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 11 May 2017 10:56:36 -0700 Subject: [PATCH 043/551] netanim: Convert file to unix format --- src/netanim/model/animation-interface.cc | 5814 +++++++++++----------- 1 file changed, 2907 insertions(+), 2907 deletions(-) diff --git a/src/netanim/model/animation-interface.cc b/src/netanim/model/animation-interface.cc index 29ae830e7cd..7ed3a393afd 100644 --- a/src/netanim/model/animation-interface.cc +++ b/src/netanim/model/animation-interface.cc @@ -1,2907 +1,2907 @@ -/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ -/* - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation; - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Author: George F. Riley - * Modified by: John Abraham - * Contributions: Eugene Kalishenko (Open Source and Linux Laboratory http://dev.osll.ru/) - * Tommaso Pecorella - * Pavel Vasilyev - */ - -// Interface between ns-3 and the network animator - - - -#include -#ifndef WIN32 -#include -#endif -#include -#include -#include -#include -#include - -// ns3 includes -#include "ns3/animation-interface.h" -#include "ns3/channel.h" -#include "ns3/config.h" -#include "ns3/node.h" -#include "ns3/mobility-model.h" -#include "ns3/packet.h" -#include "ns3/simulator.h" -#include "ns3/wifi-mac-header.h" -#include "ns3/wimax-mac-header.h" -#include "ns3/wifi-net-device.h" -#include "ns3/wifi-mac.h" -#include "ns3/lr-wpan-mac-header.h" -#include "ns3/lr-wpan-net-device.h" -#include "ns3/constant-position-mobility-model.h" -#include "ns3/lte-ue-phy.h" -#include "ns3/lte-enb-phy.h" -#include "ns3/uan-net-device.h" -#include "ns3/uan-mac.h" -#include "ns3/double.h" -#include "ns3/ipv4.h" -#include "ns3/ipv6.h" -#include "ns3/ipv4-routing-protocol.h" -#include "ns3/energy-source-container.h" -#include "animation-interface.h" - -namespace ns3 { - -NS_LOG_COMPONENT_DEFINE ("AnimationInterface"); - -// Globals - -static bool initialized = false; //!< Initialization flag - - -// Public methods - -AnimationInterface::AnimationInterface (const std::string fn) - : m_f (0), - m_routingF (0), - m_mobilityPollInterval (Seconds (0.25)), - m_outputFileName (fn), - gAnimUid (0), - m_writeCallback (0), - m_started (false), - m_enablePacketMetadata (false), - m_startTime (Seconds (0)), - m_stopTime (Seconds (3600 * 1000)), - m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE), - m_originalFileName (fn), - m_routingStopTime (Seconds (0)), - m_routingFileName (""), - m_routingPollInterval (Seconds (5)), - m_trackPackets (true) -{ - initialized = true; - StartAnimation (); -} - -AnimationInterface::~AnimationInterface () -{ - StopAnimation (); -} - -void -AnimationInterface::SkipPacketTracing () -{ - m_trackPackets = false; -} - -void -AnimationInterface::EnableWifiPhyCounters (Time startTime, Time stopTime, Time pollInterval) -{ - m_wifiPhyCountersStopTime = stopTime; - m_wifiPhyCountersPollInterval = pollInterval; - m_wifiPhyTxDropCounterId = AddNodeCounter ("WifiPhy TxDrop", AnimationInterface::DOUBLE_COUNTER); - m_wifiPhyRxDropCounterId = AddNodeCounter ("WifiPhy RxDrop", AnimationInterface::DOUBLE_COUNTER); - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - m_nodeWifiPhyTxDrop[n->GetId ()] = 0; - m_nodeWifiPhyRxDrop[n->GetId ()] = 0; - UpdateNodeCounter (m_wifiPhyTxDropCounterId, n->GetId (), 0); - UpdateNodeCounter (m_wifiPhyRxDropCounterId, n->GetId (), 0); - } - Simulator::Schedule (startTime, &AnimationInterface::TrackWifiPhyCounters, this); - -} - -void -AnimationInterface::EnableWifiMacCounters (Time startTime, Time stopTime, Time pollInterval) -{ - m_wifiMacCountersStopTime = stopTime; - m_wifiMacCountersPollInterval = pollInterval; - m_wifiMacTxCounterId = AddNodeCounter ("WifiMac Tx", AnimationInterface::DOUBLE_COUNTER); - m_wifiMacTxDropCounterId = AddNodeCounter ("WifiMac TxDrop", AnimationInterface::DOUBLE_COUNTER); - m_wifiMacRxCounterId = AddNodeCounter ("WifiMac Rx", AnimationInterface::DOUBLE_COUNTER); - m_wifiMacRxDropCounterId = AddNodeCounter ("WifiMac RxDrop", AnimationInterface::DOUBLE_COUNTER); - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - m_nodeWifiMacTx[n->GetId ()] = 0; - m_nodeWifiMacTxDrop[n->GetId ()] = 0; - m_nodeWifiMacRx[n->GetId ()] = 0; - m_nodeWifiMacRxDrop[n->GetId ()] = 0; - UpdateNodeCounter (m_wifiMacTxCounterId, n->GetId (), 0); - UpdateNodeCounter (m_wifiMacTxDropCounterId, n->GetId (), 0); - UpdateNodeCounter (m_wifiMacRxCounterId, n->GetId (), 0); - UpdateNodeCounter (m_wifiMacRxDropCounterId, n->GetId (), 0); - } - Simulator::Schedule (startTime, &AnimationInterface::TrackWifiMacCounters, this); -} - -void -AnimationInterface::EnableQueueCounters (Time startTime, Time stopTime, Time pollInterval) -{ - m_queueCountersStopTime = stopTime; - m_queueCountersPollInterval = pollInterval; - m_queueEnqueueCounterId = AddNodeCounter ("Enqueue", AnimationInterface::DOUBLE_COUNTER); - m_queueDequeueCounterId = AddNodeCounter ("Dequeue", AnimationInterface::DOUBLE_COUNTER); - m_queueDropCounterId = AddNodeCounter ("Queue Drop", AnimationInterface::DOUBLE_COUNTER); - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - m_nodeQueueEnqueue[n->GetId ()] = 0; - m_nodeQueueDequeue[n->GetId ()] = 0; - m_nodeQueueDrop[n->GetId ()] = 0; - UpdateNodeCounter (m_queueEnqueueCounterId, n->GetId (), 0); - UpdateNodeCounter (m_queueDequeueCounterId, n->GetId (), 0); - UpdateNodeCounter (m_queueDropCounterId, n->GetId (), 0); - } - Simulator::Schedule (startTime, &AnimationInterface::TrackQueueCounters, this); -} - -void -AnimationInterface::EnableIpv4L3ProtocolCounters (Time startTime, Time stopTime, Time pollInterval) -{ - m_ipv4L3ProtocolCountersStopTime = stopTime; - m_ipv4L3ProtocolCountersPollInterval = pollInterval; - m_ipv4L3ProtocolTxCounterId = AddNodeCounter ("Ipv4 Tx", AnimationInterface::DOUBLE_COUNTER); - m_ipv4L3ProtocolRxCounterId = AddNodeCounter ("Ipv4 Rx", AnimationInterface::DOUBLE_COUNTER); - m_ipv4L3ProtocolDropCounterId = AddNodeCounter ("Ipv4 Drop", AnimationInterface::DOUBLE_COUNTER); - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - m_nodeIpv4Tx[n->GetId ()] = 0; - m_nodeIpv4Rx[n->GetId ()] = 0; - m_nodeIpv4Drop[n->GetId ()] = 0; - UpdateNodeCounter (m_ipv4L3ProtocolTxCounterId, n->GetId (), 0); - UpdateNodeCounter (m_ipv4L3ProtocolRxCounterId, n->GetId (), 0); - UpdateNodeCounter (m_ipv4L3ProtocolDropCounterId, n->GetId (), 0); - } - Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4L3ProtocolCounters, this); -} - -AnimationInterface & -AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, Time pollInterval) -{ - SetOutputFile (fileName, true); - m_routingStopTime = stopTime; - m_routingPollInterval = pollInterval; - WriteXmlAnim (true); - Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4Route, this); - return *this; -} - -AnimationInterface & -AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, NodeContainer nc, Time pollInterval) -{ - m_routingNc = nc; - return EnableIpv4RouteTracking (fileName, startTime, stopTime, pollInterval); -} - -AnimationInterface & -AnimationInterface::AddSourceDestination (uint32_t fromNodeId, std::string ipv4Address) -{ - Ipv4RouteTrackElement element = { ipv4Address, fromNodeId }; - m_ipv4RouteTrackElements.push_back (element); - return *this; -} - -void -AnimationInterface::SetStartTime (Time t) -{ - m_startTime = t; -} - -void -AnimationInterface::SetStopTime (Time t) -{ - m_stopTime = t; -} - -void -AnimationInterface::SetMaxPktsPerTraceFile (uint64_t maxPacketsPerFile) -{ - m_maxPktsPerFile = maxPacketsPerFile; -} - -uint32_t -AnimationInterface::AddNodeCounter (std::string counterName, CounterType counterType) -{ - m_nodeCounters.push_back (counterName); - uint32_t counterId = m_nodeCounters.size () - 1; // counter ID is zero-indexed - WriteXmlAddNodeCounter (counterId, counterName, counterType); - return counterId; -} - -uint32_t -AnimationInterface::AddResource (std::string resourcePath) -{ - m_resources.push_back (resourcePath); - uint32_t resourceId = m_resources.size () - 1; // resource ID is zero-indexed - WriteXmlAddResource (resourceId, resourcePath); - return resourceId; -} - -void -AnimationInterface::EnablePacketMetadata (bool enable) -{ - m_enablePacketMetadata = enable; - if (enable) - { - Packet::EnablePrinting (); - } -} - -bool -AnimationInterface::IsInitialized () -{ - return initialized; -} - -bool -AnimationInterface::IsStarted () -{ - return m_started; -} - -void -AnimationInterface::SetAnimWriteCallback (AnimWriteCallback cb) -{ - m_writeCallback = cb; -} - -void -AnimationInterface::ResetAnimWriteCallback () -{ - m_writeCallback = 0; -} - -void -AnimationInterface::SetMobilityPollInterval (Time t) -{ - m_mobilityPollInterval = t; -} - - -void -AnimationInterface::SetConstantPosition (Ptr n, double x, double y, double z) -{ - NS_ASSERT (n); - Ptr loc = n->GetObject (); - if (loc == 0) - { - loc = CreateObject (); - n->AggregateObject (loc); - } - Vector hubVec (x, y, z); - loc->SetPosition (hubVec); - NS_LOG_INFO ("Node:" << n->GetId () << " Position set to:(" << x << "," << y << "," << z << ")"); - -} - -void -AnimationInterface::UpdateNodeImage (uint32_t nodeId, uint32_t resourceId) -{ - NS_LOG_INFO ("Setting node image for Node Id:" << nodeId); - if (resourceId > (m_resources.size ()-1)) - { - NS_FATAL_ERROR ("Resource Id:" << resourceId << " not found. Did you use AddResource?"); - } - WriteXmlUpdateNodeImage (nodeId, resourceId); -} - -void -AnimationInterface::UpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counter) -{ - if (nodeCounterId > (m_nodeCounters.size () - 1)) - { - NS_FATAL_ERROR ("NodeCounter Id:" << nodeCounterId << " not found. Did you use AddNodeCounter?"); - } - WriteXmlUpdateNodeCounter (nodeCounterId, nodeId, counter); -} - -void -AnimationInterface::SetBackgroundImage (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity) -{ - if ((opacity < 0) || (opacity > 1)) - { - NS_FATAL_ERROR ("Opacity must be between 0.0 and 1.0"); - } - WriteXmlUpdateBackground (fileName, x, y, scaleX, scaleY, opacity); -} - -void -AnimationInterface::UpdateNodeSize (uint32_t nodeId, double width, double height) -{ - AnimationInterface::NodeSize s = { width, height }; - m_nodeSizes[nodeId] = s; - WriteXmlUpdateNodeSize (nodeId, s.width, s.height); -} - -void -AnimationInterface::UpdateNodeColor (Ptr n, uint8_t r, uint8_t g, uint8_t b) -{ - UpdateNodeColor (n->GetId (), r, g, b); -} - -void -AnimationInterface::UpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b) -{ - NS_ASSERT (NodeList::GetNode (nodeId)); - NS_LOG_INFO ("Setting node color for Node Id:" << nodeId); - Rgb rgb = {r, g, b}; - m_nodeColors[nodeId] = rgb; - WriteXmlUpdateNodeColor (nodeId, r, g, b); -} - -void -AnimationInterface::UpdateLinkDescription (uint32_t fromNode, uint32_t toNode, - std::string linkDescription) -{ - WriteXmlUpdateLink (fromNode, toNode, linkDescription); -} - -void -AnimationInterface::UpdateLinkDescription (Ptr fromNode, Ptr toNode, - std::string linkDescription) -{ - NS_ASSERT (fromNode); - NS_ASSERT (toNode); - WriteXmlUpdateLink (fromNode->GetId (), toNode->GetId (), linkDescription); -} - -void -AnimationInterface::UpdateNodeDescription (Ptr n, std::string descr) -{ - UpdateNodeDescription (n->GetId (), descr); -} - -void -AnimationInterface::UpdateNodeDescription (uint32_t nodeId, std::string descr) -{ - NS_ASSERT (NodeList::GetNode (nodeId)); - m_nodeDescriptions[nodeId] = descr; - WriteXmlUpdateNodeDescription (nodeId); -} - -// Private methods - - -double -AnimationInterface::GetNodeEnergyFraction (Ptr node) const -{ - const EnergyFractionMap::const_iterator fractionIter = m_nodeEnergyFraction.find (node->GetId ()); - NS_ASSERT (fractionIter != m_nodeEnergyFraction.end ()); - return fractionIter->second; -} - -void -AnimationInterface::MobilityCourseChangeTrace (Ptr mobility) -{ - CHECK_STARTED_INTIMEWINDOW; - Ptr n = mobility->GetObject (); - NS_ASSERT (n); - Vector v ; - if (!mobility) - { - v = GetPosition (n); - } - else - { - v = mobility->GetPosition (); - } - UpdatePosition (n, v); - WriteXmlUpdateNodePosition (n->GetId (), v.x, v.y); -} - -bool -AnimationInterface::NodeHasMoved (Ptr n, Vector newLocation) -{ - Vector oldLocation = GetPosition (n); - bool moved = true; - if ((ceil (oldLocation.x) == ceil (newLocation.x)) && - (ceil (oldLocation.y) == ceil (newLocation.y))) - { - moved = false; - } - else - { - moved = true; - } - return moved; -} - -void -AnimationInterface::MobilityAutoCheck () -{ - CHECK_STARTED_INTIMEWINDOW; - std::vector > MovedNodes = GetMovedNodes (); - for (uint32_t i = 0; i < MovedNodes.size (); i++) - { - Ptr n = MovedNodes [i]; - NS_ASSERT (n); - Vector v = GetPosition (n); - WriteXmlUpdateNodePosition (n->GetId () , v.x, v.y); - } - if (!Simulator::IsFinished ()) - { - PurgePendingPackets (AnimationInterface::WIFI); - PurgePendingPackets (AnimationInterface::WIMAX); - PurgePendingPackets (AnimationInterface::LTE); - PurgePendingPackets (AnimationInterface::CSMA); - PurgePendingPackets (AnimationInterface::LRWPAN); - PurgePendingPackets (AnimationInterface::WAVE); - Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this); - } -} - -std::vector > -AnimationInterface::GetMovedNodes () -{ - std::vector < Ptr > movedNodes; - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - NS_ASSERT (n); - Ptr mobility = n->GetObject (); - Vector newLocation; - if (!mobility) - { - newLocation = GetPosition (n); - } - else - { - newLocation = mobility->GetPosition (); - } - if (!NodeHasMoved (n, newLocation)) - { - continue; //Location has not changed - } - else - { - UpdatePosition (n, newLocation); - movedNodes.push_back (n); - } - } - return movedNodes; -} - -int -AnimationInterface::WriteN (const std::string& st, FILE * f) -{ - if (!f) - { - return 0; - } - if (m_writeCallback) - { - m_writeCallback (st.c_str ()); - } - return WriteN (st.c_str (), st.length (), f); -} - -int -AnimationInterface::WriteN (const char* data, uint32_t count, FILE * f) -{ - if (!f) - { - return 0; - } - // Write count bytes to h from data - uint32_t nLeft = count; - const char* p = data; - uint32_t written = 0; - while (nLeft) - { - int n = std::fwrite (p, 1, nLeft, f); - if (n <= 0) - { - return written; - } - written += n; - nLeft -= n; - p += n; - } - return written; -} - -void -AnimationInterface::WriteRoutePath (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements) -{ - NS_LOG_INFO ("Writing Route Path From :" << nodeId << " To: " << destination.c_str ()); - WriteXmlRp (nodeId, destination, rpElements); - /*for (Ipv4RoutePathElements::const_iterator i = rpElements.begin (); - i != rpElements.end (); - ++i) - { - Ipv4RoutePathElement rpElement = *i; - NS_LOG_INFO ("Node:" << rpElement.nodeId << "-->" << rpElement.nextHop.c_str ()); - WriteN (GetXmlRp (rpElement.node, GetIpv4RoutingTable (n)), m_routingF); - - } - */ -} - -void -AnimationInterface::WriteNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType) -{ - WriteXmlNonP2pLinkProperties (id, ipv4Address, channelType); -} - -const std::vector -AnimationInterface::GetElementsFromContext (const std::string& context) const -{ - std::vector elements; - size_t pos1=0, pos2; - while (pos1 != context.npos) - { - pos1 = context.find ("/",pos1); - pos2 = context.find ("/",pos1+1); - elements.push_back (context.substr (pos1+1,pos2-(pos1+1))); - pos1 = pos2; - pos2 = context.npos; - } - return elements; -} - -Ptr -AnimationInterface::GetNodeFromContext (const std::string& context) const -{ - // Use "NodeList/*/ as reference - // where element [1] is the Node Id - - std::vector elements = GetElementsFromContext (context); - Ptr n = NodeList::GetNode (atoi (elements.at (1).c_str ())); - NS_ASSERT (n); - - return n; -} - -Ptr -AnimationInterface::GetNetDeviceFromContext (std::string context) -{ - // Use "NodeList/*/DeviceList/*/ as reference - // where element [1] is the Node Id - // element [2] is the NetDevice Id - - std::vector elements = GetElementsFromContext (context); - Ptr n = GetNodeFromContext (context); - - return n->GetDevice (atoi (elements.at (3).c_str ())); -} - -uint64_t -AnimationInterface::GetAnimUidFromPacket (Ptr p) -{ - AnimByteTag tag; - TypeId tid = tag.GetInstanceTypeId (); - ByteTagIterator i = p->GetByteTagIterator (); - bool found = false; - while (i.HasNext ()) - { - ByteTagIterator::Item item = i.Next (); - if (tid == item.GetTypeId ()) - { - item.GetTag (tag); - found = true; - } - } - if (found) - { - return tag.Get (); - } - else - { - return 0; - } -} - -void -AnimationInterface::AddByteTag (uint64_t animUid, Ptr p) -{ - AnimByteTag tag; - tag.Set (animUid); - p->AddByteTag (tag); -} - -void -AnimationInterface::RemainingEnergyTrace (std::string context, double previousEnergy, double currentEnergy) -{ - CHECK_STARTED_INTIMEWINDOW; - const Ptr node = GetNodeFromContext (context); - const uint32_t nodeId = node->GetId (); - - NS_LOG_INFO ("Remaining energy on one of sources on node " << nodeId << ": " << currentEnergy); - - const Ptr energySource = node->GetObject (); - - NS_ASSERT (energySource); - // Don't call GetEnergyFraction () because of recursion - const double energyFraction = currentEnergy / energySource->GetInitialEnergy (); - - NS_LOG_INFO ("Total energy fraction on node " << nodeId << ": " << energyFraction); - - m_nodeEnergyFraction[nodeId] = energyFraction; - UpdateNodeCounter (m_remainingEnergyCounterId, nodeId, energyFraction); -} - -void -AnimationInterface::WifiPhyTxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiPhyTxDrop[node->GetId ()]; -} - -void -AnimationInterface::WifiPhyRxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiPhyRxDrop[node->GetId ()]; -} - -void -AnimationInterface::WifiMacTxTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiMacTx[node->GetId ()]; -} - -void -AnimationInterface::WifiMacTxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiMacTxDrop[node->GetId ()]; -} - -void -AnimationInterface::WifiMacRxTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiMacRx[node->GetId ()]; -} - -void -AnimationInterface::WifiMacRxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeWifiMacRxDrop[node->GetId ()]; -} - -void -AnimationInterface::LrWpanMacTxTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeLrWpanMacTx[node->GetId ()]; -} - -void -AnimationInterface::LrWpanMacTxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeLrWpanMacTxDrop[node->GetId ()]; -} - -void -AnimationInterface::LrWpanMacRxTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeLrWpanMacRx[node->GetId ()]; -} - -void -AnimationInterface::LrWpanMacRxDropTrace (std::string context, Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeLrWpanMacRxDrop[node->GetId ()]; -} - -void -AnimationInterface::Ipv4TxTrace (std::string context, Ptr p, Ptr ipv4, uint32_t interfaceIndex) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeIpv4Tx[node->GetId ()]; -} - -void -AnimationInterface::Ipv4RxTrace (std::string context, Ptr p, Ptr ipv4, uint32_t interfaceIndex) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeIpv4Rx[node->GetId ()]; -} - -void -AnimationInterface::Ipv4DropTrace (std::string context, - const Ipv4Header & ipv4Header, - Ptr p, - Ipv4L3Protocol::DropReason dropReason, - Ptr ipv4, - uint32_t) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeIpv4Drop[node->GetId ()]; -} - -void -AnimationInterface::EnqueueTrace (std::string context, - Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeQueueEnqueue[node->GetId ()]; -} - -void -AnimationInterface::DequeueTrace (std::string context, - Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeQueueDequeue[node->GetId ()]; -} - -void -AnimationInterface::QueueDropTrace (std::string context, - Ptr p) -{ - const Ptr node = GetNodeFromContext (context); - ++m_nodeQueueDrop[node->GetId ()]; -} - -void -AnimationInterface::DevTxTrace (std::string context, - Ptr p, - Ptr tx, - Ptr rx, - Time txTime, - Time rxTime) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - NS_ASSERT (tx); - NS_ASSERT (rx); - Time now = Simulator::Now (); - double fbTx = now.GetSeconds (); - double lbTx = (now + txTime).GetSeconds (); - double fbRx = (now + rxTime - txTime).GetSeconds (); - double lbRx = (now + rxTime).GetSeconds (); - CheckMaxPktsPerTraceFile (); - WriteXmlP ("p", - tx->GetNode ()->GetId (), - fbTx, - lbTx, - rx->GetNode ()->GetId (), - fbRx, - lbRx, - m_enablePacketMetadata? GetPacketMetadata (p):""); -} - -void -AnimationInterface::GenericWirelessTxTrace (std::string context, Ptr p, ProtocolType protocolType) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - - ++gAnimUid; - NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessTxTrace for packet:" << gAnimUid); - AddByteTag (gAnimUid, p); - AnimPacketInfo pktInfo (ndev, Simulator::Now ()); - AddPendingPacket (protocolType, gAnimUid, pktInfo); - - Ptr netDevice = DynamicCast (ndev); - if (netDevice) - { - Mac48Address nodeAddr = netDevice->GetMac ()->GetAddress (); - std::ostringstream oss; - oss << nodeAddr; - Ptr n = netDevice->GetNode (); - NS_ASSERT (n); - m_macToNodeIdMap[oss.str ()] = n->GetId (); - NS_LOG_INFO ("Added Mac" << oss.str () << " node:" <at (gAnimUid), gAnimUid); -} - -void -AnimationInterface::GenericWirelessRxTrace (std::string context, Ptr p, ProtocolType protocolType) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " for packet:" << animUid); - if (!IsPacketPending (animUid, protocolType)) - { - NS_LOG_WARN (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessRxTrace: unknown Uid"); - return; - } - AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); - pendingPackets->at (animUid).ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - OutputWirelessPacketRxInfo (p, pendingPackets->at (animUid), animUid); -} - -void -AnimationInterface::UanPhyGenTxTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessTxTrace (context, p, AnimationInterface::UAN); -} - -void -AnimationInterface::UanPhyGenRxTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessRxTrace (context, p, AnimationInterface::UAN); -} - -void -AnimationInterface::WifiPhyTxBeginTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessTxTrace (context, p, AnimationInterface::WIFI); -} - -void -AnimationInterface::WifiPhyRxBeginTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO ("Wifi RxBeginTrace for packet:" << animUid); - if (!IsPacketPending (animUid, AnimationInterface::WIFI)) - { - NS_ASSERT (0); - NS_LOG_WARN ("WifiPhyRxBeginTrace: unknown Uid"); - std::ostringstream oss; - WifiMacHeader hdr; - if (!p->PeekHeader (hdr)) - { - NS_LOG_WARN ("WifiMacHeader not present"); - return; - } - oss << hdr.GetAddr2 (); - if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ()) - { - NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping"); - return; - } - Ptr txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]); - UpdatePosition (txNode); - AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]); - AddPendingPacket (AnimationInterface::WIFI, animUid, pktInfo); - NS_LOG_WARN ("WifiPhyRxBegin: unknown Uid, but we are adding a wifi packet"); - } - /// \todo NS_ASSERT (WifiPacketIsPending (animUid) == true); - m_pendingWifiPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - OutputWirelessPacketRxInfo (p, m_pendingWifiPackets[animUid], animUid); -} - -void -AnimationInterface::LrWpanPhyTxBeginTrace (std::string context, - Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - Ptr netDevice = DynamicCast (ndev); - - Ptr n = ndev->GetNode (); - NS_ASSERT (n); - - UpdatePosition (n); - - LrWpanMacHeader hdr; - if (!p->PeekHeader (hdr)) - { - NS_LOG_WARN ("LrWpanMacHeader not present"); - return; - } - - std::ostringstream oss; - if (hdr.GetSrcAddrMode () == 2) - { - Mac16Address nodeAddr = netDevice->GetMac ()->GetShortAddress (); - oss << nodeAddr; - } - else if (hdr.GetSrcAddrMode () == 3) - { - Mac64Address nodeAddr = netDevice->GetMac ()->GetExtendedAddress (); - oss << nodeAddr; - } - else - { - NS_LOG_WARN ("LrWpanMacHeader without source address"); - return; - } - m_macToNodeIdMap[oss.str ()] = n->GetId (); - NS_LOG_INFO ("Added Mac" << oss.str () << " node:" < p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - Ptr n = ndev->GetNode (); - NS_ASSERT (n); - - AnimByteTag tag; - if (!p->FindFirstMatchingByteTag (tag)) - { - return; - } - - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO ("LrWpan RxBeginTrace for packet:" << animUid); - if (!IsPacketPending (animUid, AnimationInterface::LRWPAN)) - { - NS_LOG_WARN ("LrWpanPhyRxBeginTrace: unknown Uid - most probably it's an ACK."); - } - - UpdatePosition (n); - m_pendingLrWpanPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - OutputWirelessPacketRxInfo (p, m_pendingLrWpanPackets[animUid], animUid); -} - -void -AnimationInterface::WavePhyTxBeginTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessTxTrace (context, p, AnimationInterface::WAVE); -} - -void -AnimationInterface::WavePhyRxBeginTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO ("Wave RxBeginTrace for packet:" << animUid); - if (!IsPacketPending (animUid, AnimationInterface::WAVE)) - { - NS_ASSERT (0); - NS_LOG_WARN ("WavePhyRxBeginTrace: unknown Uid"); - std::ostringstream oss; - WifiMacHeader hdr; - if (!p->PeekHeader (hdr)) - { - NS_LOG_WARN ("WaveMacHeader not present"); - return; - } - oss << hdr.GetAddr2 (); - if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ()) - { - NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping"); - return; - } - Ptr txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]); - UpdatePosition (txNode); - AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]); - AddPendingPacket (AnimationInterface::WAVE, animUid, pktInfo); - NS_LOG_WARN ("WavePhyRxBegin: unknown Uid, but we are adding a wave packet"); - } - /// \todo NS_ASSERT (WavePacketIsPending (animUid) == true); - m_pendingWavePackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - OutputWirelessPacketRxInfo (p, m_pendingWavePackets[animUid], animUid); -} - - -void -AnimationInterface::WimaxTxTrace (std::string context, Ptr p, const Mac48Address & m) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessTxTrace (context, p, AnimationInterface::WIMAX); -} - - -void -AnimationInterface::WimaxRxTrace (std::string context, Ptr p, const Mac48Address & m) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessRxTrace (context, p, AnimationInterface::WIMAX); -} - -void -AnimationInterface::LteTxTrace (std::string context, Ptr p, const Mac48Address & m) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessTxTrace (context, p, AnimationInterface::LTE); -} - -void -AnimationInterface::LteRxTrace (std::string context, Ptr p, const Mac48Address & m) -{ - NS_LOG_FUNCTION (this); - return GenericWirelessRxTrace (context, p, AnimationInterface::LTE); -} - -void -AnimationInterface::LteSpectrumPhyTxStart (std::string context, Ptr pb) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - if (!pb) - { - NS_LOG_WARN ("pb == 0. Not yet supported"); - return; - } - context = "/" + context; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - - std::list > pbList = pb->GetPackets (); - for (std::list >::iterator i = pbList.begin (); - i != pbList.end (); - ++i) - { - Ptr p = *i; - ++gAnimUid; - NS_LOG_INFO ("LteSpectrumPhyTxTrace for packet:" << gAnimUid); - AnimPacketInfo pktInfo (ndev, Simulator::Now ()); - AddByteTag (gAnimUid, p); - AddPendingPacket (AnimationInterface::LTE, gAnimUid, pktInfo); - OutputWirelessPacketTxInfo (p, pktInfo, gAnimUid); - } -} - -void -AnimationInterface::LteSpectrumPhyRxStart (std::string context, Ptr pb) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - if (!pb) - { - NS_LOG_WARN ("pb == 0. Not yet supported"); - return; - } - context = "/" + context; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - - std::list > pbList = pb->GetPackets (); - for (std::list >::iterator i = pbList.begin (); - i != pbList.end (); - ++i) - { - Ptr p = *i; - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO ("LteSpectrumPhyRxTrace for packet:" << gAnimUid); - if (!IsPacketPending (animUid, AnimationInterface::LTE)) - { - NS_LOG_WARN ("LteSpectrumPhyRxTrace: unknown Uid"); - return; - } - AnimPacketInfo& pktInfo = m_pendingLtePackets[animUid]; - pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - OutputWirelessPacketRxInfo (p, pktInfo, animUid); - } -} - -void -AnimationInterface::CsmaPhyTxBeginTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - ++gAnimUid; - NS_LOG_INFO ("CsmaPhyTxBeginTrace for packet:" << gAnimUid); - AddByteTag (gAnimUid, p); - UpdatePosition (ndev); - AnimPacketInfo pktInfo (ndev, Simulator::Now ()); - AddPendingPacket (AnimationInterface::CSMA, gAnimUid, pktInfo); - - -} - -void -AnimationInterface::CsmaPhyTxEndTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - NS_LOG_INFO ("CsmaPhyTxEndTrace for packet:" << animUid); - if (!IsPacketPending (animUid, AnimationInterface::CSMA)) - { - NS_LOG_WARN ("CsmaPhyTxEndTrace: unknown Uid"); - NS_FATAL_ERROR ("CsmaPhyTxEndTrace: unknown Uid"); - AnimPacketInfo pktInfo (ndev, Simulator::Now ()); - AddPendingPacket (AnimationInterface::CSMA, animUid, pktInfo); - NS_LOG_WARN ("Unknown Uid, but adding Csma Packet anyway"); - } - /// \todo NS_ASSERT (IsPacketPending (AnimUid) == true); - AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; - pktInfo.m_lbTx = Simulator::Now ().GetSeconds (); -} - -void -AnimationInterface::CsmaPhyRxEndTrace (std::string context, Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - UpdatePosition (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - if (!IsPacketPending (animUid, AnimationInterface::CSMA)) - { - NS_LOG_WARN ("CsmaPhyRxEndTrace: unknown Uid"); - return; - } - /// \todo NS_ASSERT (CsmaPacketIsPending (AnimUid) == true); - AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; - pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); - NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid); - NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid << " complete"); - OutputCsmaPacket (p, pktInfo); -} - -void -AnimationInterface::CsmaMacRxTrace (std::string context, - Ptr p) -{ - NS_LOG_FUNCTION (this); - CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; - Ptr ndev = GetNetDeviceFromContext (context); - NS_ASSERT (ndev); - uint64_t animUid = GetAnimUidFromPacket (p); - if (!IsPacketPending (animUid, AnimationInterface::CSMA)) - { - NS_LOG_WARN ("CsmaMacRxTrace: unknown Uid"); - return; - } - /// \todo NS_ASSERT (CsmaPacketIsPending (AnimUid) == true); - AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; - NS_LOG_INFO ("MacRxTrace for packet:" << animUid << " complete"); - OutputCsmaPacket (p, pktInfo); -} - -void -AnimationInterface::OutputWirelessPacketTxInfo (Ptr p, AnimPacketInfo &pktInfo, uint64_t animUid) -{ - CheckMaxPktsPerTraceFile (); - uint32_t nodeId = 0; - if (pktInfo.m_txnd) - { - nodeId = pktInfo.m_txnd->GetNode ()->GetId (); - } - else - { - nodeId = pktInfo.m_txNodeId; - } - WriteXmlPRef (animUid, nodeId, pktInfo.m_fbTx, m_enablePacketMetadata? GetPacketMetadata (p):""); -} - -void -AnimationInterface::OutputWirelessPacketRxInfo (Ptr p, AnimPacketInfo & pktInfo, uint64_t animUid) -{ - CheckMaxPktsPerTraceFile (); - uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId (); - WriteXmlP (animUid, "wpr", rxId, pktInfo.m_fbRx, pktInfo.m_lbRx); -} - -void -AnimationInterface::OutputCsmaPacket (Ptr p, AnimPacketInfo &pktInfo) -{ - CheckMaxPktsPerTraceFile (); - NS_ASSERT (pktInfo.m_txnd); - uint32_t nodeId = pktInfo.m_txnd->GetNode ()->GetId (); - uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId (); - - WriteXmlP ("p", - nodeId, - pktInfo.m_fbTx, - pktInfo.m_lbTx, - rxId, - pktInfo.m_fbRx, - pktInfo.m_lbRx, - m_enablePacketMetadata? GetPacketMetadata (p):""); -} - -void -AnimationInterface::AddPendingPacket (ProtocolType protocolType, uint64_t animUid, AnimPacketInfo pktInfo) -{ - AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); - NS_ASSERT (pendingPackets); - pendingPackets->insert (AnimUidPacketInfoMap::value_type (animUid, pktInfo)); -} - -bool -AnimationInterface::IsPacketPending (uint64_t animUid, AnimationInterface::ProtocolType protocolType) -{ - AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); - NS_ASSERT (pendingPackets); - return (pendingPackets->find (animUid) != pendingPackets->end ()); -} - -void -AnimationInterface::PurgePendingPackets (AnimationInterface::ProtocolType protocolType) -{ - AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); - NS_ASSERT (pendingPackets); - if (pendingPackets->empty ()) - { - return; - } - std::vector purgeList; - for (AnimUidPacketInfoMap::iterator i = pendingPackets->begin (); - i != pendingPackets->end (); - ++i) - { - - AnimPacketInfo pktInfo = i->second; - double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx); - if (delta > PURGE_INTERVAL) - { - purgeList.push_back (i->first); - } - } - for (std::vector ::iterator i = purgeList.begin (); - i != purgeList.end (); - ++i) - { - pendingPackets->erase (*i); - } -} - -AnimationInterface::AnimUidPacketInfoMap * -AnimationInterface::ProtocolTypeToPendingPackets (AnimationInterface::ProtocolType protocolType) -{ - AnimUidPacketInfoMap * pendingPackets = 0; - switch (protocolType) - { - case AnimationInterface::WIFI: - { - pendingPackets = &m_pendingWifiPackets; - break; - } - case AnimationInterface::UAN: - { - pendingPackets = &m_pendingUanPackets; - break; - } - case AnimationInterface::CSMA: - { - pendingPackets = &m_pendingCsmaPackets; - break; - } - case AnimationInterface::WIMAX: - { - pendingPackets = &m_pendingWimaxPackets; - break; - } - case AnimationInterface::LTE: - { - pendingPackets = &m_pendingLtePackets; - break; - } - case AnimationInterface::LRWPAN: - { - pendingPackets = &m_pendingLrWpanPackets; - break; - } - case AnimationInterface::WAVE: - { - pendingPackets = &m_pendingWavePackets; - break; - } - } - return pendingPackets; - -} - -std::string -AnimationInterface::ProtocolTypeToString (AnimationInterface::ProtocolType protocolType) -{ - std::string result = "Unknown"; - switch (protocolType) - { - case AnimationInterface::WIFI: - { - result = "WIFI"; - break; - } - case AnimationInterface::UAN: - { - result = "UAN"; - break; - } - case AnimationInterface::CSMA: - { - result = "CSMA"; - break; - } - case AnimationInterface::WIMAX: - { - result = "WIMAX"; - break; - } - case AnimationInterface::LTE: - { - result = "LTE"; - break; - } - case AnimationInterface::LRWPAN: - { - result = "LRWPAN"; - break; - } - case AnimationInterface::WAVE: - { - result = "WAVE"; - break; - } - } - return result; -} - -// Counters - -std::string -AnimationInterface::CounterTypeToString (CounterType counterType) -{ - std::string typeString = "unknown"; - switch (counterType) - { - case UINT32_COUNTER: - { - typeString = "UINT32"; - break; - } - case DOUBLE_COUNTER: - { - typeString = "DOUBLE"; - break; - } - } - return typeString; -} - -// General - -std::string -AnimationInterface::GetPacketMetadata (Ptr p) -{ - std::ostringstream oss; - p->Print (oss); - return oss.str (); -} - -uint64_t -AnimationInterface::GetTracePktCount () -{ - return m_currentPktCount; -} - -void -AnimationInterface::StopAnimation (bool onlyAnimation) -{ - m_started = false; - NS_LOG_INFO ("Stopping Animation"); - ResetAnimWriteCallback (); - if (m_f) - { - // Terminate the anim element - WriteXmlClose ("anim"); - std::fclose (m_f); - m_f = 0; - } - if (onlyAnimation) - { - return; - } - if (m_routingF) - { - WriteXmlClose ("anim", true); - std::fclose (m_routingF); - m_routingF = 0; - } -} - -void -AnimationInterface::StartAnimation (bool restart) -{ - m_currentPktCount = 0; - m_started = true; - SetOutputFile (m_outputFileName); - WriteXmlAnim (); - WriteNodes (); - WriteNodeColors (); - WriteLinkProperties (); - WriteIpv4Addresses (); - WriteIpv6Addresses (); - WriteNodeSizes (); - WriteNodeEnergies (); - if (!restart) - { - Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this); - ConnectCallbacks (); - } -} - -void -AnimationInterface::AddToIpv4AddressNodeIdTable (std::string ipv4Address, uint32_t nodeId) -{ - m_ipv4ToNodeIdMap[ipv4Address] = nodeId; - m_nodeIdIpv4Map.insert(NodeIdIpv4Pair(nodeId, ipv4Address)); -} - -void -AnimationInterface::AddToIpv4AddressNodeIdTable (std::vector ipv4Addresses, uint32_t nodeId) -{ - for (std::vector::const_iterator i = ipv4Addresses.begin (); - i != ipv4Addresses.end (); - ++i) - { - AddToIpv4AddressNodeIdTable (*i, nodeId); - } -} - -void -AnimationInterface::AddToIpv6AddressNodeIdTable(std::string ipv6Address, uint32_t nodeId) -{ - m_ipv6ToNodeIdMap[ipv6Address] = nodeId; - m_nodeIdIpv6Map.insert(NodeIdIpv6Pair(nodeId, ipv6Address)); -} - -void -AnimationInterface::AddToIpv6AddressNodeIdTable(std::vector ipv6Addresses, uint32_t nodeId) -{ - for (std::vector::const_iterator i = ipv6Addresses.begin(); - i != ipv6Addresses.end(); - ++i) - { - AddToIpv6AddressNodeIdTable(*i, nodeId); - } -} - -// Callbacks -void -AnimationInterface::ConnectLteEnb (Ptr n, Ptr nd, uint32_t devIndex) -{ - - Ptr lteEnbPhy = nd->GetPhy (); - Ptr dlPhy = lteEnbPhy->GetDownlinkSpectrumPhy (); - Ptr ulPhy = lteEnbPhy->GetUplinkSpectrumPhy (); - std::ostringstream oss; - //NodeList/*/DeviceList/*/ - oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/"; - if (dlPhy) - { - dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); - dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); - } - if (ulPhy) - { - ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); - ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); - } -} - - - -void -AnimationInterface::ConnectLteUe (Ptr n, Ptr nd, uint32_t devIndex) -{ - - Ptr lteUePhy = nd->GetPhy (); - Ptr dlPhy = lteUePhy->GetDownlinkSpectrumPhy (); - Ptr ulPhy = lteUePhy->GetUplinkSpectrumPhy (); - std::ostringstream oss; - //NodeList/*/DeviceList/*/ - oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/"; - if (dlPhy) - { - dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); - dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); - } - if (ulPhy) - { - ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); - ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); - } -} - -void -AnimationInterface::ConnectLte () -{ - - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - NS_ASSERT (n); - uint32_t nDevices = n->GetNDevices (); - for (uint32_t devIndex = 0; devIndex < nDevices; ++devIndex) - { - Ptr nd = n->GetDevice (devIndex); - if (!nd) - continue; - Ptr lteUeNetDevice = DynamicCast (nd); - if (lteUeNetDevice) - { - ConnectLteUe (n, lteUeNetDevice, devIndex); - continue; - } - Ptr lteEnbNetDevice = DynamicCast (nd); - if (lteEnbNetDevice) - ConnectLteEnb (n, lteEnbNetDevice, devIndex); - } - - } -} - -void -AnimationInterface::ConnectCallbacks () -{ - // Connect the callbacks - Config::Connect ("/ChannelList/*/TxRxPointToPoint", - MakeCallback (&AnimationInterface::DevTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxBegin", - MakeCallback (&AnimationInterface::WifiPhyTxBeginTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxBegin", - MakeCallback (&AnimationInterface::WifiPhyRxBeginTrace, this)); - Config::ConnectWithoutContext ("/NodeList/*/$ns3::MobilityModel/CourseChange", - MakeCallback (&AnimationInterface::MobilityCourseChangeTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Tx", - MakeCallback (&AnimationInterface::WimaxTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Rx", - MakeCallback (&AnimationInterface::WimaxRxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Tx", - MakeCallback (&AnimationInterface::LteTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Rx", - MakeCallback (&AnimationInterface::LteRxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxBegin", - MakeCallback (&AnimationInterface::CsmaPhyTxBeginTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxEnd", - MakeCallback (&AnimationInterface::CsmaPhyTxEndTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyRxEnd", - MakeCallback (&AnimationInterface::CsmaPhyRxEndTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacRx", - MakeCallback (&AnimationInterface::CsmaMacRxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyTxBegin", - MakeCallback (&AnimationInterface::UanPhyGenTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyRxBegin", - MakeCallback (&AnimationInterface::UanPhyGenRxTrace, this)); - Config::Connect ("/NodeList/*/$ns3::BasicEnergySource/RemainingEnergy", - MakeCallback (&AnimationInterface::RemainingEnergyTrace, this)); - - ConnectLte (); - - Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Tx", - MakeCallback (&AnimationInterface::Ipv4TxTrace, this)); - Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Rx", - MakeCallback (&AnimationInterface::Ipv4RxTrace, this)); - Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Drop", - MakeCallback (&AnimationInterface::Ipv4DropTrace, this)); - - // Queue Enqueues - - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Enqueue", - MakeCallback (&AnimationInterface::EnqueueTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Enqueue", - MakeCallback (&AnimationInterface::EnqueueTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Enqueue", - MakeCallback (&AnimationInterface::EnqueueTrace, this)); - - // Queue Dequeues - - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Dequeue", - MakeCallback (&AnimationInterface::DequeueTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Dequeue", - MakeCallback (&AnimationInterface::DequeueTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Dequeue", - MakeCallback (&AnimationInterface::DequeueTrace, this)); - - // Queue Drops - - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Drop", - MakeCallback (&AnimationInterface::QueueDropTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Drop", - MakeCallback (&AnimationInterface::QueueDropTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Drop", - MakeCallback (&AnimationInterface::QueueDropTrace, this)); - - - // Wifi Mac - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx", - MakeCallback (&AnimationInterface::WifiMacTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTxDrop", - MakeCallback (&AnimationInterface::WifiMacTxDropTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx", - MakeCallback (&AnimationInterface::WifiMacRxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRxDrop", - MakeCallback (&AnimationInterface::WifiMacRxDropTrace, this)); - - // Wifi Phy - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxDrop", - MakeCallback (&AnimationInterface::WifiPhyTxDropTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop", - MakeCallback (&AnimationInterface::WifiPhyRxDropTrace, this)); - - // LrWpan - Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyTxBegin", - MakeCallback (&AnimationInterface::LrWpanPhyTxBeginTrace, this)); - Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyRxBegin", - MakeCallback (&AnimationInterface::LrWpanPhyRxBeginTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTx", - MakeCallback (&AnimationInterface::LrWpanMacTxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTxDrop", - MakeCallback (&AnimationInterface::LrWpanMacTxDropTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRx", - MakeCallback (&AnimationInterface::LrWpanMacRxTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRxDrop", - MakeCallback (&AnimationInterface::LrWpanMacRxDropTrace, this)); - - // Wave - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyTxBegin", - MakeCallback (&AnimationInterface::WavePhyTxBeginTrace, this)); - Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyRxBegin", - MakeCallback (&AnimationInterface::WavePhyRxBeginTrace, this)); -} - -Vector -AnimationInterface::UpdatePosition (Ptr n) -{ - Ptr loc = n->GetObject (); - if (loc) - { - m_nodeLocation[n->GetId ()] = loc->GetPosition (); - } - else - { - NS_LOG_UNCOND ( "AnimationInterface WARNING:Node:" << n->GetId () << " Does not have a mobility model. Use SetConstantPosition if it is stationary"); - Ptr x = CreateObject (); - x->SetAttribute ("Min", DoubleValue (0)); - x->SetAttribute ("Max", DoubleValue (100)); - Ptr y = CreateObject (); - y->SetAttribute ("Min", DoubleValue (0)); - y->SetAttribute ("Max", DoubleValue (100)); - m_nodeLocation[n->GetId ()] = Vector (int (x->GetValue ()), int (y->GetValue ()), 0); - } - return m_nodeLocation[n->GetId ()]; -} - -Vector -AnimationInterface::UpdatePosition (Ptr n, Vector v) -{ - m_nodeLocation[n->GetId ()] = v; - return v; -} - -Vector -AnimationInterface::UpdatePosition (Ptr ndev) -{ - Ptr n = ndev->GetNode (); - NS_ASSERT (n); - return UpdatePosition (n); -} - -Vector -AnimationInterface::GetPosition (Ptr n) -{ - if (m_nodeLocation.find (n->GetId ()) == m_nodeLocation.end ()) - { - NS_FATAL_ERROR ("Node:" <GetId () << " not found in Location table"); - } - return m_nodeLocation[n->GetId ()]; -} - - -std::string -AnimationInterface::GetMacAddress (Ptr nd) -{ - Address nodeAddr = nd->GetAddress (); - std::ostringstream oss; - oss << nodeAddr; - return oss.str ().substr (6); // Skip the first 6 chars to get the Mac -} - -std::string -AnimationInterface::GetIpv4Address (Ptr nd) -{ - Ptr ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); - if (!ipv4) - { - NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found"); - return "0.0.0.0"; - } - int32_t ifIndex = ipv4->GetInterfaceForDevice (nd); - if (ifIndex == -1) - { - NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); - return "0.0.0.0"; - } - Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, 0); - std::ostringstream oss; - oss << addr.GetLocal (); - return oss.str (); -} - -std::string -AnimationInterface::GetIpv6Address(Ptr nd) -{ - Ptr ipv6 = NodeList::GetNode(nd->GetNode()->GetId())->GetObject (); - if (!ipv6) - { - NS_LOG_WARN("Node: " << nd->GetNode()->GetId() << " No ipv4 object found"); - return "::"; - } - int32_t ifIndex = ipv6->GetInterfaceForDevice(nd); - if (ifIndex == -1) - { - NS_LOG_WARN("Node :" << nd->GetNode()->GetId() << " Could not find index of NetDevice"); - return "::"; - } - bool nonLinkLocalFound = false; - uint32_t nAddresses = ipv6->GetNAddresses(ifIndex); - Ipv6InterfaceAddress addr; - for (uint32_t addressIndex = 0; addressIndex < nAddresses; ++addressIndex) - { - addr = ipv6->GetAddress(ifIndex, addressIndex); - if (!addr.GetAddress().IsLinkLocal()) - { - nonLinkLocalFound = true; - break; - } - } - if (!nonLinkLocalFound) - addr = ipv6->GetAddress(ifIndex, 0); - std::ostringstream oss; - oss << addr.GetAddress(); - return oss.str(); -} - - - -std::vector -AnimationInterface::GetIpv4Addresses (Ptr nd) -{ - std::vector ipv4Addresses; - Ptr ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); - if (!ipv4) - { - NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found"); - return ipv4Addresses; - } - int32_t ifIndex = ipv4->GetInterfaceForDevice (nd); - if (ifIndex == -1) - { - NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); - return ipv4Addresses; - } - for (uint32_t index = 0; index < ipv4->GetNAddresses (ifIndex); ++index) - { - Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, index); - std::ostringstream oss; - oss << addr.GetLocal (); - ipv4Addresses.push_back(oss.str ()); - } - return ipv4Addresses; -} - -std::vector -AnimationInterface::GetIpv6Addresses(Ptr nd) -{ - std::vector ipv6Addresses; - Ptr ipv6 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); - if (!ipv6) - { - NS_LOG_WARN("Node: " << nd->GetNode ()->GetId () << " No ipv6 object found"); - return ipv6Addresses; - } - int32_t ifIndex = ipv6->GetInterfaceForDevice (nd); - if (ifIndex == -1) - { - NS_LOG_WARN("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); - return ipv6Addresses; - } - for (uint32_t index = 0; index < ipv6->GetNAddresses (ifIndex); ++index) - { - Ipv6InterfaceAddress addr = ipv6->GetAddress (ifIndex, index); - std::ostringstream oss; - oss << addr.GetAddress (); - ipv6Addresses.push_back (oss.str ()); - } - return ipv6Addresses; -} - - -void -AnimationInterface::WriteIpv4Addresses () -{ - for (NodeIdIpv4Map::const_iterator i = m_nodeIdIpv4Map.begin (); - i != m_nodeIdIpv4Map.end(); - ++i) - { - std::vector ipv4Addresses; - std::pair iterPair = m_nodeIdIpv4Map.equal_range (i->first); - for (NodeIdIpv4Map::const_iterator it = iterPair.first; - it != iterPair.second; - ++it) - { - ipv4Addresses.push_back (it->second); - } - WriteXmlIpv4Addresses (i->first, ipv4Addresses); - } -} - -void -AnimationInterface::WriteIpv6Addresses() -{ - for (NodeIdIpv6Map::const_iterator i = m_nodeIdIpv6Map.begin (); - i != m_nodeIdIpv6Map.end (); - i = m_nodeIdIpv6Map.upper_bound (i->first)) - { - std::vector ipv6Addresses; - std::pair iterPair = m_nodeIdIpv6Map.equal_range (i->first); - for (NodeIdIpv6Map::const_iterator it = iterPair.first; - it != iterPair.second; - ++it) - { - ipv6Addresses.push_back (it->second); - } - WriteXmlIpv6Addresses (i->first, ipv6Addresses); - } -} - -void -AnimationInterface::WriteLinkProperties () -{ - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - UpdatePosition (n); - uint32_t n1Id = n->GetId (); - uint32_t nDev = n->GetNDevices (); // Number of devices - for (uint32_t i = 0; i < nDev; ++i) - { - Ptr dev = n->GetDevice (i); - NS_ASSERT (dev); - Ptr ch = dev->GetChannel (); - std::string channelType = "Unknown channel"; - if (ch) - { - channelType = ch->GetInstanceTypeId ().GetName (); - } - NS_LOG_DEBUG("Got ChannelType" << channelType); - - if (!ch || (channelType != std::string("ns3::PointToPointChannel"))) - { - NS_LOG_DEBUG ("No channel can't be a p2p device"); - /* - // Try to see if it is an LTE NetDevice, which does not return a channel - if ((dev->GetInstanceTypeId ().GetName () == "ns3::LteUeNetDevice") || - (dev->GetInstanceTypeId ().GetName () == "ns3::LteEnbNetDevice")|| - (dev->GetInstanceTypeId ().GetName () == "ns3::VirtualNetDevice")) - { - WriteNonP2pLinkProperties (n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType); - AddToIpv4AddressNodeIdTable (GetIpv4Address (dev), n->GetId ()); - } - */ - std::vector ipv4Addresses = GetIpv4Addresses (dev); - AddToIpv4AddressNodeIdTable(ipv4Addresses, n->GetId ()); - std::vector ipv6Addresses = GetIpv6Addresses (dev); - AddToIpv6AddressNodeIdTable(ipv6Addresses, n->GetId ()); - if (!ipv4Addresses.empty ()) - { - NS_LOG_INFO ("Writing Ipv4 link"); - WriteNonP2pLinkProperties(n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType); - } - else if (!ipv6Addresses.empty ()) - { - NS_LOG_INFO ("Writing Ipv6 link"); - WriteNonP2pLinkProperties(n->GetId (), GetIpv6Address (dev) + "~" + GetMacAddress (dev), channelType); - } - continue; - } - - else if (channelType == std::string ("ns3::PointToPointChannel")) - { // Since these are duplex links, we only need to dump - // if srcid < dstid - uint32_t nChDev = ch->GetNDevices (); - for (uint32_t j = 0; j < nChDev; ++j) - { - Ptr chDev = ch->GetDevice (j); - uint32_t n2Id = chDev->GetNode ()->GetId (); - if (n1Id < n2Id) - { - - std::vector ipv4Addresses = GetIpv4Addresses (dev); - AddToIpv4AddressNodeIdTable (ipv4Addresses, n1Id); - ipv4Addresses = GetIpv4Addresses (chDev); - AddToIpv4AddressNodeIdTable (ipv4Addresses, n2Id); - std::vector ipv6Addresses = GetIpv6Addresses (dev); - AddToIpv6AddressNodeIdTable(ipv6Addresses, n1Id); - ipv6Addresses = GetIpv6Addresses (chDev); - AddToIpv6AddressNodeIdTable(ipv6Addresses, n2Id); - - P2pLinkNodeIdPair p2pPair; - p2pPair.fromNode = n1Id; - p2pPair.toNode = n2Id; - if (!ipv4Addresses.empty ()) - { - LinkProperties lp = { GetIpv4Address (dev) + "~" + GetMacAddress (dev), GetIpv4Address (chDev) + "~" + GetMacAddress (chDev), "" }; - m_linkProperties[p2pPair] = lp; - } - else if (!ipv6Addresses.empty ()) - { - LinkProperties lp = { GetIpv6Address (dev) + "~" + GetMacAddress (dev), GetIpv6Address (chDev) + "~" + GetMacAddress (chDev), "" }; - m_linkProperties[p2pPair] = lp; - } - WriteXmlLink (n1Id, 0, n2Id); - } - } - } - } - } - m_linkProperties.clear (); -} - -void -AnimationInterface::WriteNodes () -{ - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - NS_LOG_INFO ("Update Position for Node: " << n->GetId ()); - Vector v = UpdatePosition (n); - WriteXmlNode (n->GetId (), n->GetSystemId (), v.x, v.y); - } -} - -void -AnimationInterface::WriteNodeColors () -{ - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - Rgb rgb = {255, 0, 0}; - if (m_nodeColors.find (n->GetId ()) == m_nodeColors.end ()) - { - m_nodeColors[n->GetId ()] = rgb; - } - UpdateNodeColor (n, rgb.r, rgb.g, rgb.b); - } -} - -void -AnimationInterface::WriteNodeSizes () -{ - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - NS_LOG_INFO ("Update Size for Node: " << n->GetId ()); - AnimationInterface::NodeSize s = { 1, 1 }; - m_nodeSizes[n->GetId ()] = s; - UpdateNodeSize (n->GetId (), s.width, s.height); - } -} - -void -AnimationInterface::WriteNodeEnergies () -{ - m_remainingEnergyCounterId = AddNodeCounter ("RemainingEnergy", AnimationInterface::DOUBLE_COUNTER); - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - if (NodeList::GetNode (n->GetId ())->GetObject ()) - { - UpdateNodeCounter (m_remainingEnergyCounterId, n->GetId (), 1); - } - } -} - -bool -AnimationInterface::IsInTimeWindow () -{ - if ((Simulator::Now () >= m_startTime) && - (Simulator::Now () <= m_stopTime)) - return true; - else - return false; -} - -void -AnimationInterface::SetOutputFile (const std::string& fn, bool routing) -{ - if (!routing && m_f) - { - return; - } - if (routing && m_routingF) - { - NS_FATAL_ERROR ("SetRoutingOutputFile already used once"); - return; - } - - NS_LOG_INFO ("Creating new trace file:" << fn.c_str ()); - FILE * f = 0; - f = std::fopen (fn.c_str (), "w"); - if (!f) - { - NS_FATAL_ERROR ("Unable to open output file:" << fn.c_str ()); - return; // Can't open output file - } - if (routing) - { - m_routingF = f; - m_routingFileName = fn; - } - else - { - m_f = f; - m_outputFileName = fn; - } - return; -} - -void -AnimationInterface::CheckMaxPktsPerTraceFile () -{ - // Start a new trace file if the current packet count exceeded nax packets per file - ++m_currentPktCount; - if (m_currentPktCount <= m_maxPktsPerFile) - { - return; - } - NS_LOG_UNCOND ("Max Packets per trace file exceeded"); - StopAnimation (true); -} - -std::string -AnimationInterface::GetNetAnimVersion () -{ - return NETANIM_VERSION; -} - - -void -AnimationInterface::TrackQueueCounters () -{ - if (Simulator::Now () > m_queueCountersStopTime) - { - NS_LOG_INFO ("TrackQueueCounters Completed"); - return; - } - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - uint32_t nodeId = Ptr (*i)->GetId (); - UpdateNodeCounter (m_queueEnqueueCounterId, nodeId, m_nodeQueueEnqueue[nodeId]); - UpdateNodeCounter (m_queueDequeueCounterId, nodeId, m_nodeQueueDequeue[nodeId]); - UpdateNodeCounter (m_queueDropCounterId, nodeId, m_nodeQueueDrop[nodeId]); - } - Simulator::Schedule (m_queueCountersPollInterval, &AnimationInterface::TrackQueueCounters, this); -} - -void -AnimationInterface::TrackWifiMacCounters () -{ - if (Simulator::Now () > m_wifiMacCountersStopTime) - { - NS_LOG_INFO ("TrackWifiMacCounters Completed"); - return; - } - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - uint32_t nodeId = Ptr (*i)->GetId (); - UpdateNodeCounter (m_wifiMacTxCounterId, nodeId, m_nodeWifiMacTx[nodeId]); - UpdateNodeCounter (m_wifiMacTxDropCounterId, nodeId, m_nodeWifiMacTxDrop[nodeId]); - UpdateNodeCounter (m_wifiMacRxCounterId, nodeId, m_nodeWifiMacRx[nodeId]); - UpdateNodeCounter (m_wifiMacRxDropCounterId, nodeId, m_nodeWifiMacRxDrop[nodeId]); - } - Simulator::Schedule (m_wifiMacCountersPollInterval, &AnimationInterface::TrackWifiMacCounters, this); -} - -void -AnimationInterface::TrackWifiPhyCounters () -{ - if (Simulator::Now () > m_wifiPhyCountersStopTime) - { - NS_LOG_INFO ("TrackWifiPhyCounters Completed"); - return; - } - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - uint32_t nodeId = Ptr (*i)->GetId (); - UpdateNodeCounter (m_wifiPhyTxDropCounterId, nodeId, m_nodeWifiPhyTxDrop[nodeId]); - UpdateNodeCounter (m_wifiPhyRxDropCounterId, nodeId, m_nodeWifiPhyRxDrop[nodeId]); - } - Simulator::Schedule (m_wifiPhyCountersPollInterval, &AnimationInterface::TrackWifiPhyCounters, this); -} - -void -AnimationInterface::TrackIpv4L3ProtocolCounters () -{ - if (Simulator::Now () > m_ipv4L3ProtocolCountersStopTime) - { - NS_LOG_INFO ("TrackIpv4L3ProtocolCounters Completed"); - return; - } - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - uint32_t nodeId = Ptr (*i)->GetId (); - UpdateNodeCounter (m_ipv4L3ProtocolTxCounterId, nodeId, m_nodeIpv4Tx[nodeId]); - UpdateNodeCounter (m_ipv4L3ProtocolRxCounterId, nodeId, m_nodeIpv4Rx[nodeId]); - UpdateNodeCounter (m_ipv4L3ProtocolDropCounterId, nodeId, m_nodeIpv4Drop[nodeId]); - } - Simulator::Schedule (m_ipv4L3ProtocolCountersPollInterval, &AnimationInterface::TrackIpv4L3ProtocolCounters, this); -} - - - - - -/***** Routing-related *****/ - -void -AnimationInterface::TrackIpv4RoutePaths () -{ - if (m_ipv4RouteTrackElements.empty ()) - { - return; - } - for (std::vector ::const_iterator i = m_ipv4RouteTrackElements.begin (); - i != m_ipv4RouteTrackElements.end (); - ++i) - { - Ipv4RouteTrackElement trackElement = *i; - Ptr fromNode = NodeList::GetNode (trackElement.fromNodeId); - if (!fromNode) - { - NS_FATAL_ERROR ("Node: " << trackElement.fromNodeId << " Not found"); - continue; - } - Ptr ipv4 = fromNode->GetObject (); - if (!ipv4) - { - NS_LOG_WARN ("ipv4 object not found"); - continue; - } - Ptr rp = ipv4->GetRoutingProtocol (); - if (!rp) - { - NS_LOG_WARN ("Routing protocol object not found"); - continue; - } - NS_LOG_INFO ("Begin Track Route for: " << trackElement.destination.c_str () << " From:" << trackElement.fromNodeId); - Ptr pkt = Create (); - Ipv4Header header; - header.SetDestination (Ipv4Address (trackElement.destination.c_str ())); - Socket::SocketErrno sockerr; - Ptr rt = rp->RouteOutput (pkt, header, 0, sockerr); - Ipv4RoutePathElements rpElements; - if (!rt) - { - NS_LOG_INFO ("No route to :" << trackElement.destination.c_str ()); - Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" }; - rpElements.push_back (elem); - WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements); - continue; - } - std::ostringstream oss; - oss << rt->GetGateway (); - NS_LOG_INFO ("Node:" << trackElement.fromNodeId << "-->" << rt->GetGateway ()); - if (rt->GetGateway () == "0.0.0.0") - { - Ipv4RoutePathElement elem = { trackElement.fromNodeId, "C" }; - rpElements.push_back (elem); - if ( m_ipv4ToNodeIdMap.find (trackElement.destination) != m_ipv4ToNodeIdMap.end ()) - { - Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[trackElement.destination], "L" }; - rpElements.push_back (elem2); - } - } - else if (rt->GetGateway () == "127.0.0.1") - { - Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" }; - rpElements.push_back (elem); - } - else - { - Ipv4RoutePathElement elem = { trackElement.fromNodeId, oss.str () }; - rpElements.push_back (elem); - } - RecursiveIpv4RoutePathSearch (oss.str (), trackElement.destination, rpElements); - WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements); - } - -} - -void -AnimationInterface::TrackIpv4Route () -{ - if (Simulator::Now () > m_routingStopTime) - { - NS_LOG_INFO ("TrackIpv4Route completed"); - return; - } - if (m_routingNc.GetN ()) - { - for (NodeContainer::Iterator i = m_routingNc.Begin (); i != m_routingNc.End (); ++i) - { - Ptr n = *i; - WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n)); - } - } - else - { - for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) - { - Ptr n = *i; - WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n)); - } - } - TrackIpv4RoutePaths (); - Simulator::Schedule (m_routingPollInterval, &AnimationInterface::TrackIpv4Route, this); -} - -std::string -AnimationInterface::GetIpv4RoutingTable (Ptr n) -{ - - NS_ASSERT (n); - Ptr ipv4 = n->GetObject (); - if (!ipv4) - { - NS_LOG_WARN ("Node " << n->GetId () << " Does not have an Ipv4 object"); - return ""; - } - std::stringstream stream; - Ptr routingstream = Create (&stream); - ipv4->GetRoutingProtocol ()->PrintRoutingTable (routingstream); - return stream.str (); - -} - -void -AnimationInterface::RecursiveIpv4RoutePathSearch (std::string from, std::string to, Ipv4RoutePathElements & rpElements) -{ - NS_LOG_INFO ("RecursiveIpv4RoutePathSearch from:" << from.c_str () << " to:" << to.c_str ()); - if ((from == "0.0.0.0") || (from == "127.0.0.1")) - { - NS_LOG_INFO ("Got " << from.c_str () << " End recursion"); - return; - } - Ptr fromNode = NodeList::GetNode (m_ipv4ToNodeIdMap[from]); - Ptr toNode = NodeList::GetNode (m_ipv4ToNodeIdMap[to]); - if (fromNode->GetId () == toNode->GetId ()) - { - Ipv4RoutePathElement elem = { fromNode->GetId (), "L" }; - rpElements.push_back (elem); - return; - } - if (!fromNode) - { - NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[from] << " Not found"); - return; - } - if (!toNode) - { - NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[to] << " Not found"); - return; - } - Ptr ipv4 = fromNode->GetObject (); - if (!ipv4) - { - NS_LOG_WARN ("ipv4 object not found"); - return; - } - Ptr rp = ipv4->GetRoutingProtocol (); - if (!rp) - { - NS_LOG_WARN ("Routing protocol object not found"); - return; - } - Ptr pkt = Create (); - Ipv4Header header; - header.SetDestination (Ipv4Address (to.c_str ())); - Socket::SocketErrno sockerr; - Ptr rt = rp->RouteOutput (pkt, header, 0, sockerr); - if (!rt) - { - return; - } - NS_LOG_DEBUG ("Node: " << fromNode->GetId () << " G:" << rt->GetGateway ()); - std::ostringstream oss; - oss << rt->GetGateway (); - if (oss.str () == "0.0.0.0" && (sockerr != Socket::ERROR_NOROUTETOHOST)) - { - NS_LOG_INFO ("Null gw"); - Ipv4RoutePathElement elem = { fromNode->GetId (), "C" }; - rpElements.push_back (elem); - if ( m_ipv4ToNodeIdMap.find (to) != m_ipv4ToNodeIdMap.end ()) - { - Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[to], "L" }; - rpElements.push_back (elem2); - } - return; - } - NS_LOG_INFO ("Node:" << fromNode->GetId () << "-->" << rt->GetGateway ()); - Ipv4RoutePathElement elem = { fromNode->GetId (), oss.str () }; - rpElements.push_back (elem); - RecursiveIpv4RoutePathSearch (oss.str (), to, rpElements); - -} - - - -/***** WriteXml *****/ - -void -AnimationInterface::WriteXmlAnim (bool routing) -{ - AnimXmlElement element ("anim"); - element.AddAttribute ("ver", GetNetAnimVersion ()); - FILE * f = m_f; - if (!routing) - { - element.AddAttribute ("filetype", "animation"); - } - else - { - element.AddAttribute ("filetype", "routing"); - f = m_routingF; - } - WriteN (element.ToString (false) + ">\n", f); -} - -void -AnimationInterface::WriteXmlClose (std::string name, bool routing) -{ - std::string closeString = "\n"; - if (!routing) - { - WriteN (closeString, m_f); - } - else - { - WriteN (closeString, m_routingF); - } -} - -void -AnimationInterface::WriteXmlNode (uint32_t id, uint32_t sysId, double locX, double locY) -{ - AnimXmlElement element ("node"); - element.AddAttribute ("id", id); - element.AddAttribute ("sysId", sysId); - element.AddAttribute ("locX", locX); - element.AddAttribute ("locY", locY); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string linkDescription) -{ - AnimXmlElement element ("linkupdate"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("fromId", fromId); - element.AddAttribute ("toId", toId); - element.AddAttribute ("ld", linkDescription, true); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlLink (uint32_t fromId, uint32_t toLp, uint32_t toId) -{ - AnimXmlElement element ("link"); - element.AddAttribute ("fromId", fromId); - element.AddAttribute ("toId", toId); - - LinkProperties lprop ; - lprop.fromNodeDescription = ""; - lprop.toNodeDescription = ""; - lprop.linkDescription = ""; - - P2pLinkNodeIdPair p1 = { fromId, toId }; - P2pLinkNodeIdPair p2 = { toId, fromId }; - if (m_linkProperties.find (p1) != m_linkProperties.end ()) - { - lprop = m_linkProperties[p1]; - } - else if (m_linkProperties.find (p2) != m_linkProperties.end ()) - { - lprop = m_linkProperties[p2]; - } - - element.AddAttribute ("fd", lprop.fromNodeDescription, true); - element.AddAttribute ("td", lprop.toNodeDescription, true); - element.AddAttribute ("ld", lprop.linkDescription, true); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlIpv4Addresses (uint32_t nodeId, std::vector ipv4Addresses) -{ - AnimXmlElement element ("ip"); - element.AddAttribute ("n", nodeId); - for (std::vector::const_iterator i = ipv4Addresses.begin (); - i != ipv4Addresses.end (); - ++i) - { - AnimXmlElement valueElement ("address"); - valueElement.SetText (*i); - element.AppendChild(valueElement); - } - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlIpv6Addresses (uint32_t nodeId, std::vector ipv6Addresses) -{ - AnimXmlElement element ("ipv6"); - element.AddAttribute("n", nodeId); - for (std::vector::const_iterator i = ipv6Addresses.begin (); - i != ipv6Addresses.end (); - ++i) - { - AnimXmlElement valueElement ("address"); - valueElement.SetText (*i); - element.AppendChild (valueElement); - } - WriteN(element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlRouting (uint32_t nodeId, std::string routingInfo) -{ - AnimXmlElement element ("rt"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("info", routingInfo.c_str (), true); - WriteN (element.ToString (), m_routingF); -} - -void -AnimationInterface::WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements) -{ - std::string tagName = "rp"; - AnimXmlElement element (tagName, false); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("d", destination.c_str ()); - element.AddAttribute ("c", rpElements.size ()); - for (Ipv4RoutePathElements::const_iterator i = rpElements.begin (); - i != rpElements.end (); - ++i) - { - Ipv4RoutePathElement rpElement = *i; - AnimXmlElement rpeElement ("rpe"); - rpeElement.AddAttribute ("n", rpElement.nodeId); - rpeElement.AddAttribute ("nH", rpElement.nextHop.c_str ()); - element.AppendChild (rpeElement); - } - WriteN (element.ToString (), m_routingF); -} - - -void -AnimationInterface::WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo) -{ - AnimXmlElement element ("pr"); - element.AddAttribute ("uId", animUid); - element.AddAttribute ("fId", fId); - element.AddAttribute ("fbTx", fbTx); - if (!metaInfo.empty ()) - { - element.AddAttribute ("meta-info", metaInfo.c_str (), true); - } - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlP (uint64_t animUid, std::string pktType, uint32_t tId, double fbRx, double lbRx) -{ - AnimXmlElement element (pktType); - element.AddAttribute ("uId", animUid); - element.AddAttribute ("tId", tId); - element.AddAttribute ("fbRx", fbRx); - element.AddAttribute ("lbRx", lbRx); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlP (std::string pktType, uint32_t fId, double fbTx, double lbTx, - uint32_t tId, double fbRx, double lbRx, std::string metaInfo) -{ - AnimXmlElement element (pktType); - element.AddAttribute ("fId", fId); - element.AddAttribute ("fbTx", fbTx); - element.AddAttribute ("lbTx", lbTx); - if (!metaInfo.empty ()) - { - element.AddAttribute ("meta-info", metaInfo.c_str (), true); - } - element.AddAttribute ("tId", tId); - element.AddAttribute ("fbRx", fbRx); - element.AddAttribute ("lbRx", lbRx); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlAddNodeCounter (uint32_t nodeCounterId, std::string counterName, CounterType counterType) -{ - AnimXmlElement element ("ncs"); - element.AddAttribute ("ncId", nodeCounterId); - element.AddAttribute ("n", counterName); - element.AddAttribute ("t", CounterTypeToString (counterType)); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlAddResource (uint32_t resourceId, std::string resourcePath) -{ - AnimXmlElement element ("res"); - element.AddAttribute ("rid", resourceId); - element.AddAttribute ("p", resourcePath); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateNodeImage (uint32_t nodeId, uint32_t resourceId) -{ - AnimXmlElement element ("nu"); - element.AddAttribute ("p", "i"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("rid", resourceId); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateNodeSize (uint32_t nodeId, double width, double height) -{ - AnimXmlElement element ("nu"); - element.AddAttribute ("p", "s"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("w", width); - element.AddAttribute ("h", height); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateNodePosition (uint32_t nodeId, double x, double y) -{ - AnimXmlElement element ("nu"); - element.AddAttribute ("p", "p"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("x", x); - element.AddAttribute ("y", y); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b) -{ - AnimXmlElement element ("nu"); - element.AddAttribute ("p", "c"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - element.AddAttribute ("r", (uint32_t) r); - element.AddAttribute ("g", (uint32_t) g); - element.AddAttribute ("b", (uint32_t) b); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateNodeDescription (uint32_t nodeId) -{ - AnimXmlElement element ("nu"); - element.AddAttribute ("p", "d"); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("id", nodeId); - if (m_nodeDescriptions.find (nodeId) != m_nodeDescriptions.end ()) - { - element.AddAttribute ("descr", m_nodeDescriptions[nodeId], true); - } - WriteN (element.ToString (), m_f); -} - - -void -AnimationInterface::WriteXmlUpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counterValue) -{ - AnimXmlElement element ("nc"); - element.AddAttribute ("c", nodeCounterId); - element.AddAttribute ("i", nodeId); - element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); - element.AddAttribute ("v", counterValue); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity) -{ - AnimXmlElement element ("bg"); - element.AddAttribute ("f", fileName); - element.AddAttribute ("x", x); - element.AddAttribute ("y", y); - element.AddAttribute ("sx", scaleX); - element.AddAttribute ("sy", scaleY); - element.AddAttribute ("o", opacity); - WriteN (element.ToString (), m_f); -} - -void -AnimationInterface::WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipAddress, std::string channelType) -{ - AnimXmlElement element ("nonp2plinkproperties"); - element.AddAttribute ("id", id); - element.AddAttribute ("ipAddress", ipAddress); - element.AddAttribute ("channelType", channelType); - WriteN (element.ToString (), m_f); -} - - - -/***** AnimXmlElement *****/ - -AnimationInterface::AnimXmlElement::AnimXmlElement(std::string tagName, bool emptyElement) : - m_tagName(tagName), - m_text("") -{ -} - -template -void -AnimationInterface::AnimXmlElement::AddAttribute(std::string attribute, T value, bool xmlEscape) -{ - std::ostringstream oss; - oss << std::setprecision(10); - oss << value; - std::string attributeString = attribute.c_str(); - if (xmlEscape) - { - attributeString += "=\""; - std::string valueStr = oss.str(); - for (std::string::iterator it = valueStr.begin(); it != valueStr.end(); ++it) - { - switch (*it) - { - case '&': - attributeString += "&"; - break; - case '\"': - attributeString += """; - break; - case '\'': - attributeString += "'"; - break; - case '<': - attributeString += "<"; - break; - case '>': - attributeString += ">"; - break; - default: - attributeString += *it; - break; - } - } - attributeString += "\" "; - } - else - { - attributeString += "=\"" + oss.str() + "\" "; - } - m_attributes.push_back(attributeString); -} - -void -AnimationInterface::AnimXmlElement::AppendChild(AnimXmlElement e) -{ - m_children.push_back(e.ToString()); -} - -void -AnimationInterface::AnimXmlElement::SetText(std::string text) -{ - m_text = text; -} - -std::string -AnimationInterface::AnimXmlElement::ToString(bool autoClose) -{ - std::string elementString = "<" + m_tagName + " "; - - - for (std::vector::const_iterator i = m_attributes.begin(); - i != m_attributes.end(); - ++i) - { - elementString += *i; - } - if (m_children.empty() && m_text.empty()) - { - if (autoClose) - { - elementString += "/>"; - } - } - else - { - elementString += ">"; - if (!m_text.empty()) - { - elementString += m_text; - } - if (!m_children.empty()) - { - elementString += "\n"; - for (std::vector::const_iterator i = m_children.begin(); - i != m_children.end(); - ++i) - { - elementString += *i + "\n"; - } - - } - if (autoClose) - { - elementString += ""; - } - } - - - return elementString + ((autoClose) ?"\n": ""); -} - - - - - -/***** AnimByteTag *****/ - -TypeId -AnimByteTag::GetTypeId (void) -{ - static TypeId tid = TypeId ("ns3::AnimByteTag") - .SetParent () - .SetGroupName ("NetAnim") - .AddConstructor () - ; - return tid; -} - -TypeId -AnimByteTag::GetInstanceTypeId (void) const -{ - return GetTypeId (); -} - -uint32_t -AnimByteTag::GetSerializedSize (void) const -{ - return sizeof (uint64_t); -} - -void -AnimByteTag::Serialize (TagBuffer i) const -{ - i.WriteU64 (m_AnimUid); -} - -void -AnimByteTag::Deserialize (TagBuffer i) -{ - m_AnimUid = i.ReadU64 (); -} - -void -AnimByteTag::Print (std::ostream &os) const -{ - os << "AnimUid=" << m_AnimUid; -} - -void -AnimByteTag::Set (uint64_t AnimUid) -{ - m_AnimUid = AnimUid; -} - -uint64_t -AnimByteTag::Get (void) const -{ - return m_AnimUid; -} - -AnimationInterface::AnimPacketInfo::AnimPacketInfo () - : m_txnd (0), - m_txNodeId (0), - m_fbTx (0), - m_lbTx (0), - m_lbRx (0) -{ -} - -AnimationInterface::AnimPacketInfo::AnimPacketInfo (const AnimPacketInfo & pInfo) -{ - m_txnd = pInfo.m_txnd; - m_txNodeId = pInfo.m_txNodeId; - m_fbTx = pInfo.m_fbTx; - m_lbTx = pInfo.m_lbTx; - m_lbRx = pInfo.m_lbRx; -} - -AnimationInterface::AnimPacketInfo::AnimPacketInfo (Ptr txnd, - const Time fbTx, - uint32_t txNodeId) - : m_txnd (txnd), - m_txNodeId (0), - m_fbTx (fbTx.GetSeconds ()), - m_lbTx (0), - m_lbRx (0) -{ - if (!m_txnd) - m_txNodeId = txNodeId; -} - -void -AnimationInterface::AnimPacketInfo::ProcessRxBegin (Ptr nd, const double fbRx) -{ - Ptr n = nd->GetNode (); - m_fbRx = fbRx; - m_rxnd = nd; -} - -} // namespace ns3 +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: George F. Riley + * Modified by: John Abraham + * Contributions: Eugene Kalishenko (Open Source and Linux Laboratory http://dev.osll.ru/) + * Tommaso Pecorella + * Pavel Vasilyev + */ + +// Interface between ns-3 and the network animator + + + +#include +#ifndef WIN32 +#include +#endif +#include +#include +#include +#include +#include + +// ns3 includes +#include "ns3/animation-interface.h" +#include "ns3/channel.h" +#include "ns3/config.h" +#include "ns3/node.h" +#include "ns3/mobility-model.h" +#include "ns3/packet.h" +#include "ns3/simulator.h" +#include "ns3/wifi-mac-header.h" +#include "ns3/wimax-mac-header.h" +#include "ns3/wifi-net-device.h" +#include "ns3/wifi-mac.h" +#include "ns3/lr-wpan-mac-header.h" +#include "ns3/lr-wpan-net-device.h" +#include "ns3/constant-position-mobility-model.h" +#include "ns3/lte-ue-phy.h" +#include "ns3/lte-enb-phy.h" +#include "ns3/uan-net-device.h" +#include "ns3/uan-mac.h" +#include "ns3/double.h" +#include "ns3/ipv4.h" +#include "ns3/ipv6.h" +#include "ns3/ipv4-routing-protocol.h" +#include "ns3/energy-source-container.h" +#include "animation-interface.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("AnimationInterface"); + +// Globals + +static bool initialized = false; //!< Initialization flag + + +// Public methods + +AnimationInterface::AnimationInterface (const std::string fn) + : m_f (0), + m_routingF (0), + m_mobilityPollInterval (Seconds (0.25)), + m_outputFileName (fn), + gAnimUid (0), + m_writeCallback (0), + m_started (false), + m_enablePacketMetadata (false), + m_startTime (Seconds (0)), + m_stopTime (Seconds (3600 * 1000)), + m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE), + m_originalFileName (fn), + m_routingStopTime (Seconds (0)), + m_routingFileName (""), + m_routingPollInterval (Seconds (5)), + m_trackPackets (true) +{ + initialized = true; + StartAnimation (); +} + +AnimationInterface::~AnimationInterface () +{ + StopAnimation (); +} + +void +AnimationInterface::SkipPacketTracing () +{ + m_trackPackets = false; +} + +void +AnimationInterface::EnableWifiPhyCounters (Time startTime, Time stopTime, Time pollInterval) +{ + m_wifiPhyCountersStopTime = stopTime; + m_wifiPhyCountersPollInterval = pollInterval; + m_wifiPhyTxDropCounterId = AddNodeCounter ("WifiPhy TxDrop", AnimationInterface::DOUBLE_COUNTER); + m_wifiPhyRxDropCounterId = AddNodeCounter ("WifiPhy RxDrop", AnimationInterface::DOUBLE_COUNTER); + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + m_nodeWifiPhyTxDrop[n->GetId ()] = 0; + m_nodeWifiPhyRxDrop[n->GetId ()] = 0; + UpdateNodeCounter (m_wifiPhyTxDropCounterId, n->GetId (), 0); + UpdateNodeCounter (m_wifiPhyRxDropCounterId, n->GetId (), 0); + } + Simulator::Schedule (startTime, &AnimationInterface::TrackWifiPhyCounters, this); + +} + +void +AnimationInterface::EnableWifiMacCounters (Time startTime, Time stopTime, Time pollInterval) +{ + m_wifiMacCountersStopTime = stopTime; + m_wifiMacCountersPollInterval = pollInterval; + m_wifiMacTxCounterId = AddNodeCounter ("WifiMac Tx", AnimationInterface::DOUBLE_COUNTER); + m_wifiMacTxDropCounterId = AddNodeCounter ("WifiMac TxDrop", AnimationInterface::DOUBLE_COUNTER); + m_wifiMacRxCounterId = AddNodeCounter ("WifiMac Rx", AnimationInterface::DOUBLE_COUNTER); + m_wifiMacRxDropCounterId = AddNodeCounter ("WifiMac RxDrop", AnimationInterface::DOUBLE_COUNTER); + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + m_nodeWifiMacTx[n->GetId ()] = 0; + m_nodeWifiMacTxDrop[n->GetId ()] = 0; + m_nodeWifiMacRx[n->GetId ()] = 0; + m_nodeWifiMacRxDrop[n->GetId ()] = 0; + UpdateNodeCounter (m_wifiMacTxCounterId, n->GetId (), 0); + UpdateNodeCounter (m_wifiMacTxDropCounterId, n->GetId (), 0); + UpdateNodeCounter (m_wifiMacRxCounterId, n->GetId (), 0); + UpdateNodeCounter (m_wifiMacRxDropCounterId, n->GetId (), 0); + } + Simulator::Schedule (startTime, &AnimationInterface::TrackWifiMacCounters, this); +} + +void +AnimationInterface::EnableQueueCounters (Time startTime, Time stopTime, Time pollInterval) +{ + m_queueCountersStopTime = stopTime; + m_queueCountersPollInterval = pollInterval; + m_queueEnqueueCounterId = AddNodeCounter ("Enqueue", AnimationInterface::DOUBLE_COUNTER); + m_queueDequeueCounterId = AddNodeCounter ("Dequeue", AnimationInterface::DOUBLE_COUNTER); + m_queueDropCounterId = AddNodeCounter ("Queue Drop", AnimationInterface::DOUBLE_COUNTER); + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + m_nodeQueueEnqueue[n->GetId ()] = 0; + m_nodeQueueDequeue[n->GetId ()] = 0; + m_nodeQueueDrop[n->GetId ()] = 0; + UpdateNodeCounter (m_queueEnqueueCounterId, n->GetId (), 0); + UpdateNodeCounter (m_queueDequeueCounterId, n->GetId (), 0); + UpdateNodeCounter (m_queueDropCounterId, n->GetId (), 0); + } + Simulator::Schedule (startTime, &AnimationInterface::TrackQueueCounters, this); +} + +void +AnimationInterface::EnableIpv4L3ProtocolCounters (Time startTime, Time stopTime, Time pollInterval) +{ + m_ipv4L3ProtocolCountersStopTime = stopTime; + m_ipv4L3ProtocolCountersPollInterval = pollInterval; + m_ipv4L3ProtocolTxCounterId = AddNodeCounter ("Ipv4 Tx", AnimationInterface::DOUBLE_COUNTER); + m_ipv4L3ProtocolRxCounterId = AddNodeCounter ("Ipv4 Rx", AnimationInterface::DOUBLE_COUNTER); + m_ipv4L3ProtocolDropCounterId = AddNodeCounter ("Ipv4 Drop", AnimationInterface::DOUBLE_COUNTER); + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + m_nodeIpv4Tx[n->GetId ()] = 0; + m_nodeIpv4Rx[n->GetId ()] = 0; + m_nodeIpv4Drop[n->GetId ()] = 0; + UpdateNodeCounter (m_ipv4L3ProtocolTxCounterId, n->GetId (), 0); + UpdateNodeCounter (m_ipv4L3ProtocolRxCounterId, n->GetId (), 0); + UpdateNodeCounter (m_ipv4L3ProtocolDropCounterId, n->GetId (), 0); + } + Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4L3ProtocolCounters, this); +} + +AnimationInterface & +AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, Time pollInterval) +{ + SetOutputFile (fileName, true); + m_routingStopTime = stopTime; + m_routingPollInterval = pollInterval; + WriteXmlAnim (true); + Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4Route, this); + return *this; +} + +AnimationInterface & +AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, NodeContainer nc, Time pollInterval) +{ + m_routingNc = nc; + return EnableIpv4RouteTracking (fileName, startTime, stopTime, pollInterval); +} + +AnimationInterface & +AnimationInterface::AddSourceDestination (uint32_t fromNodeId, std::string ipv4Address) +{ + Ipv4RouteTrackElement element = { ipv4Address, fromNodeId }; + m_ipv4RouteTrackElements.push_back (element); + return *this; +} + +void +AnimationInterface::SetStartTime (Time t) +{ + m_startTime = t; +} + +void +AnimationInterface::SetStopTime (Time t) +{ + m_stopTime = t; +} + +void +AnimationInterface::SetMaxPktsPerTraceFile (uint64_t maxPacketsPerFile) +{ + m_maxPktsPerFile = maxPacketsPerFile; +} + +uint32_t +AnimationInterface::AddNodeCounter (std::string counterName, CounterType counterType) +{ + m_nodeCounters.push_back (counterName); + uint32_t counterId = m_nodeCounters.size () - 1; // counter ID is zero-indexed + WriteXmlAddNodeCounter (counterId, counterName, counterType); + return counterId; +} + +uint32_t +AnimationInterface::AddResource (std::string resourcePath) +{ + m_resources.push_back (resourcePath); + uint32_t resourceId = m_resources.size () - 1; // resource ID is zero-indexed + WriteXmlAddResource (resourceId, resourcePath); + return resourceId; +} + +void +AnimationInterface::EnablePacketMetadata (bool enable) +{ + m_enablePacketMetadata = enable; + if (enable) + { + Packet::EnablePrinting (); + } +} + +bool +AnimationInterface::IsInitialized () +{ + return initialized; +} + +bool +AnimationInterface::IsStarted () +{ + return m_started; +} + +void +AnimationInterface::SetAnimWriteCallback (AnimWriteCallback cb) +{ + m_writeCallback = cb; +} + +void +AnimationInterface::ResetAnimWriteCallback () +{ + m_writeCallback = 0; +} + +void +AnimationInterface::SetMobilityPollInterval (Time t) +{ + m_mobilityPollInterval = t; +} + + +void +AnimationInterface::SetConstantPosition (Ptr n, double x, double y, double z) +{ + NS_ASSERT (n); + Ptr loc = n->GetObject (); + if (loc == 0) + { + loc = CreateObject (); + n->AggregateObject (loc); + } + Vector hubVec (x, y, z); + loc->SetPosition (hubVec); + NS_LOG_INFO ("Node:" << n->GetId () << " Position set to:(" << x << "," << y << "," << z << ")"); + +} + +void +AnimationInterface::UpdateNodeImage (uint32_t nodeId, uint32_t resourceId) +{ + NS_LOG_INFO ("Setting node image for Node Id:" << nodeId); + if (resourceId > (m_resources.size ()-1)) + { + NS_FATAL_ERROR ("Resource Id:" << resourceId << " not found. Did you use AddResource?"); + } + WriteXmlUpdateNodeImage (nodeId, resourceId); +} + +void +AnimationInterface::UpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counter) +{ + if (nodeCounterId > (m_nodeCounters.size () - 1)) + { + NS_FATAL_ERROR ("NodeCounter Id:" << nodeCounterId << " not found. Did you use AddNodeCounter?"); + } + WriteXmlUpdateNodeCounter (nodeCounterId, nodeId, counter); +} + +void +AnimationInterface::SetBackgroundImage (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity) +{ + if ((opacity < 0) || (opacity > 1)) + { + NS_FATAL_ERROR ("Opacity must be between 0.0 and 1.0"); + } + WriteXmlUpdateBackground (fileName, x, y, scaleX, scaleY, opacity); +} + +void +AnimationInterface::UpdateNodeSize (uint32_t nodeId, double width, double height) +{ + AnimationInterface::NodeSize s = { width, height }; + m_nodeSizes[nodeId] = s; + WriteXmlUpdateNodeSize (nodeId, s.width, s.height); +} + +void +AnimationInterface::UpdateNodeColor (Ptr n, uint8_t r, uint8_t g, uint8_t b) +{ + UpdateNodeColor (n->GetId (), r, g, b); +} + +void +AnimationInterface::UpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b) +{ + NS_ASSERT (NodeList::GetNode (nodeId)); + NS_LOG_INFO ("Setting node color for Node Id:" << nodeId); + Rgb rgb = {r, g, b}; + m_nodeColors[nodeId] = rgb; + WriteXmlUpdateNodeColor (nodeId, r, g, b); +} + +void +AnimationInterface::UpdateLinkDescription (uint32_t fromNode, uint32_t toNode, + std::string linkDescription) +{ + WriteXmlUpdateLink (fromNode, toNode, linkDescription); +} + +void +AnimationInterface::UpdateLinkDescription (Ptr fromNode, Ptr toNode, + std::string linkDescription) +{ + NS_ASSERT (fromNode); + NS_ASSERT (toNode); + WriteXmlUpdateLink (fromNode->GetId (), toNode->GetId (), linkDescription); +} + +void +AnimationInterface::UpdateNodeDescription (Ptr n, std::string descr) +{ + UpdateNodeDescription (n->GetId (), descr); +} + +void +AnimationInterface::UpdateNodeDescription (uint32_t nodeId, std::string descr) +{ + NS_ASSERT (NodeList::GetNode (nodeId)); + m_nodeDescriptions[nodeId] = descr; + WriteXmlUpdateNodeDescription (nodeId); +} + +// Private methods + + +double +AnimationInterface::GetNodeEnergyFraction (Ptr node) const +{ + const EnergyFractionMap::const_iterator fractionIter = m_nodeEnergyFraction.find (node->GetId ()); + NS_ASSERT (fractionIter != m_nodeEnergyFraction.end ()); + return fractionIter->second; +} + +void +AnimationInterface::MobilityCourseChangeTrace (Ptr mobility) +{ + CHECK_STARTED_INTIMEWINDOW; + Ptr n = mobility->GetObject (); + NS_ASSERT (n); + Vector v ; + if (!mobility) + { + v = GetPosition (n); + } + else + { + v = mobility->GetPosition (); + } + UpdatePosition (n, v); + WriteXmlUpdateNodePosition (n->GetId (), v.x, v.y); +} + +bool +AnimationInterface::NodeHasMoved (Ptr n, Vector newLocation) +{ + Vector oldLocation = GetPosition (n); + bool moved = true; + if ((ceil (oldLocation.x) == ceil (newLocation.x)) && + (ceil (oldLocation.y) == ceil (newLocation.y))) + { + moved = false; + } + else + { + moved = true; + } + return moved; +} + +void +AnimationInterface::MobilityAutoCheck () +{ + CHECK_STARTED_INTIMEWINDOW; + std::vector > MovedNodes = GetMovedNodes (); + for (uint32_t i = 0; i < MovedNodes.size (); i++) + { + Ptr n = MovedNodes [i]; + NS_ASSERT (n); + Vector v = GetPosition (n); + WriteXmlUpdateNodePosition (n->GetId () , v.x, v.y); + } + if (!Simulator::IsFinished ()) + { + PurgePendingPackets (AnimationInterface::WIFI); + PurgePendingPackets (AnimationInterface::WIMAX); + PurgePendingPackets (AnimationInterface::LTE); + PurgePendingPackets (AnimationInterface::CSMA); + PurgePendingPackets (AnimationInterface::LRWPAN); + PurgePendingPackets (AnimationInterface::WAVE); + Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this); + } +} + +std::vector > +AnimationInterface::GetMovedNodes () +{ + std::vector < Ptr > movedNodes; + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + NS_ASSERT (n); + Ptr mobility = n->GetObject (); + Vector newLocation; + if (!mobility) + { + newLocation = GetPosition (n); + } + else + { + newLocation = mobility->GetPosition (); + } + if (!NodeHasMoved (n, newLocation)) + { + continue; //Location has not changed + } + else + { + UpdatePosition (n, newLocation); + movedNodes.push_back (n); + } + } + return movedNodes; +} + +int +AnimationInterface::WriteN (const std::string& st, FILE * f) +{ + if (!f) + { + return 0; + } + if (m_writeCallback) + { + m_writeCallback (st.c_str ()); + } + return WriteN (st.c_str (), st.length (), f); +} + +int +AnimationInterface::WriteN (const char* data, uint32_t count, FILE * f) +{ + if (!f) + { + return 0; + } + // Write count bytes to h from data + uint32_t nLeft = count; + const char* p = data; + uint32_t written = 0; + while (nLeft) + { + int n = std::fwrite (p, 1, nLeft, f); + if (n <= 0) + { + return written; + } + written += n; + nLeft -= n; + p += n; + } + return written; +} + +void +AnimationInterface::WriteRoutePath (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements) +{ + NS_LOG_INFO ("Writing Route Path From :" << nodeId << " To: " << destination.c_str ()); + WriteXmlRp (nodeId, destination, rpElements); + /*for (Ipv4RoutePathElements::const_iterator i = rpElements.begin (); + i != rpElements.end (); + ++i) + { + Ipv4RoutePathElement rpElement = *i; + NS_LOG_INFO ("Node:" << rpElement.nodeId << "-->" << rpElement.nextHop.c_str ()); + WriteN (GetXmlRp (rpElement.node, GetIpv4RoutingTable (n)), m_routingF); + + } + */ +} + +void +AnimationInterface::WriteNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType) +{ + WriteXmlNonP2pLinkProperties (id, ipv4Address, channelType); +} + +const std::vector +AnimationInterface::GetElementsFromContext (const std::string& context) const +{ + std::vector elements; + size_t pos1=0, pos2; + while (pos1 != context.npos) + { + pos1 = context.find ("/",pos1); + pos2 = context.find ("/",pos1+1); + elements.push_back (context.substr (pos1+1,pos2-(pos1+1))); + pos1 = pos2; + pos2 = context.npos; + } + return elements; +} + +Ptr +AnimationInterface::GetNodeFromContext (const std::string& context) const +{ + // Use "NodeList/*/ as reference + // where element [1] is the Node Id + + std::vector elements = GetElementsFromContext (context); + Ptr n = NodeList::GetNode (atoi (elements.at (1).c_str ())); + NS_ASSERT (n); + + return n; +} + +Ptr +AnimationInterface::GetNetDeviceFromContext (std::string context) +{ + // Use "NodeList/*/DeviceList/*/ as reference + // where element [1] is the Node Id + // element [2] is the NetDevice Id + + std::vector elements = GetElementsFromContext (context); + Ptr n = GetNodeFromContext (context); + + return n->GetDevice (atoi (elements.at (3).c_str ())); +} + +uint64_t +AnimationInterface::GetAnimUidFromPacket (Ptr p) +{ + AnimByteTag tag; + TypeId tid = tag.GetInstanceTypeId (); + ByteTagIterator i = p->GetByteTagIterator (); + bool found = false; + while (i.HasNext ()) + { + ByteTagIterator::Item item = i.Next (); + if (tid == item.GetTypeId ()) + { + item.GetTag (tag); + found = true; + } + } + if (found) + { + return tag.Get (); + } + else + { + return 0; + } +} + +void +AnimationInterface::AddByteTag (uint64_t animUid, Ptr p) +{ + AnimByteTag tag; + tag.Set (animUid); + p->AddByteTag (tag); +} + +void +AnimationInterface::RemainingEnergyTrace (std::string context, double previousEnergy, double currentEnergy) +{ + CHECK_STARTED_INTIMEWINDOW; + const Ptr node = GetNodeFromContext (context); + const uint32_t nodeId = node->GetId (); + + NS_LOG_INFO ("Remaining energy on one of sources on node " << nodeId << ": " << currentEnergy); + + const Ptr energySource = node->GetObject (); + + NS_ASSERT (energySource); + // Don't call GetEnergyFraction () because of recursion + const double energyFraction = currentEnergy / energySource->GetInitialEnergy (); + + NS_LOG_INFO ("Total energy fraction on node " << nodeId << ": " << energyFraction); + + m_nodeEnergyFraction[nodeId] = energyFraction; + UpdateNodeCounter (m_remainingEnergyCounterId, nodeId, energyFraction); +} + +void +AnimationInterface::WifiPhyTxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiPhyTxDrop[node->GetId ()]; +} + +void +AnimationInterface::WifiPhyRxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiPhyRxDrop[node->GetId ()]; +} + +void +AnimationInterface::WifiMacTxTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiMacTx[node->GetId ()]; +} + +void +AnimationInterface::WifiMacTxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiMacTxDrop[node->GetId ()]; +} + +void +AnimationInterface::WifiMacRxTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiMacRx[node->GetId ()]; +} + +void +AnimationInterface::WifiMacRxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeWifiMacRxDrop[node->GetId ()]; +} + +void +AnimationInterface::LrWpanMacTxTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeLrWpanMacTx[node->GetId ()]; +} + +void +AnimationInterface::LrWpanMacTxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeLrWpanMacTxDrop[node->GetId ()]; +} + +void +AnimationInterface::LrWpanMacRxTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeLrWpanMacRx[node->GetId ()]; +} + +void +AnimationInterface::LrWpanMacRxDropTrace (std::string context, Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeLrWpanMacRxDrop[node->GetId ()]; +} + +void +AnimationInterface::Ipv4TxTrace (std::string context, Ptr p, Ptr ipv4, uint32_t interfaceIndex) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeIpv4Tx[node->GetId ()]; +} + +void +AnimationInterface::Ipv4RxTrace (std::string context, Ptr p, Ptr ipv4, uint32_t interfaceIndex) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeIpv4Rx[node->GetId ()]; +} + +void +AnimationInterface::Ipv4DropTrace (std::string context, + const Ipv4Header & ipv4Header, + Ptr p, + Ipv4L3Protocol::DropReason dropReason, + Ptr ipv4, + uint32_t) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeIpv4Drop[node->GetId ()]; +} + +void +AnimationInterface::EnqueueTrace (std::string context, + Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeQueueEnqueue[node->GetId ()]; +} + +void +AnimationInterface::DequeueTrace (std::string context, + Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeQueueDequeue[node->GetId ()]; +} + +void +AnimationInterface::QueueDropTrace (std::string context, + Ptr p) +{ + const Ptr node = GetNodeFromContext (context); + ++m_nodeQueueDrop[node->GetId ()]; +} + +void +AnimationInterface::DevTxTrace (std::string context, + Ptr p, + Ptr tx, + Ptr rx, + Time txTime, + Time rxTime) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + NS_ASSERT (tx); + NS_ASSERT (rx); + Time now = Simulator::Now (); + double fbTx = now.GetSeconds (); + double lbTx = (now + txTime).GetSeconds (); + double fbRx = (now + rxTime - txTime).GetSeconds (); + double lbRx = (now + rxTime).GetSeconds (); + CheckMaxPktsPerTraceFile (); + WriteXmlP ("p", + tx->GetNode ()->GetId (), + fbTx, + lbTx, + rx->GetNode ()->GetId (), + fbRx, + lbRx, + m_enablePacketMetadata? GetPacketMetadata (p):""); +} + +void +AnimationInterface::GenericWirelessTxTrace (std::string context, Ptr p, ProtocolType protocolType) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + + ++gAnimUid; + NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessTxTrace for packet:" << gAnimUid); + AddByteTag (gAnimUid, p); + AnimPacketInfo pktInfo (ndev, Simulator::Now ()); + AddPendingPacket (protocolType, gAnimUid, pktInfo); + + Ptr netDevice = DynamicCast (ndev); + if (netDevice) + { + Mac48Address nodeAddr = netDevice->GetMac ()->GetAddress (); + std::ostringstream oss; + oss << nodeAddr; + Ptr n = netDevice->GetNode (); + NS_ASSERT (n); + m_macToNodeIdMap[oss.str ()] = n->GetId (); + NS_LOG_INFO ("Added Mac" << oss.str () << " node:" <at (gAnimUid), gAnimUid); +} + +void +AnimationInterface::GenericWirelessRxTrace (std::string context, Ptr p, ProtocolType protocolType) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " for packet:" << animUid); + if (!IsPacketPending (animUid, protocolType)) + { + NS_LOG_WARN (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessRxTrace: unknown Uid"); + return; + } + AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); + pendingPackets->at (animUid).ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + OutputWirelessPacketRxInfo (p, pendingPackets->at (animUid), animUid); +} + +void +AnimationInterface::UanPhyGenTxTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessTxTrace (context, p, AnimationInterface::UAN); +} + +void +AnimationInterface::UanPhyGenRxTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessRxTrace (context, p, AnimationInterface::UAN); +} + +void +AnimationInterface::WifiPhyTxBeginTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessTxTrace (context, p, AnimationInterface::WIFI); +} + +void +AnimationInterface::WifiPhyRxBeginTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO ("Wifi RxBeginTrace for packet:" << animUid); + if (!IsPacketPending (animUid, AnimationInterface::WIFI)) + { + NS_ASSERT (0); + NS_LOG_WARN ("WifiPhyRxBeginTrace: unknown Uid"); + std::ostringstream oss; + WifiMacHeader hdr; + if (!p->PeekHeader (hdr)) + { + NS_LOG_WARN ("WifiMacHeader not present"); + return; + } + oss << hdr.GetAddr2 (); + if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ()) + { + NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping"); + return; + } + Ptr txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]); + UpdatePosition (txNode); + AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]); + AddPendingPacket (AnimationInterface::WIFI, animUid, pktInfo); + NS_LOG_WARN ("WifiPhyRxBegin: unknown Uid, but we are adding a wifi packet"); + } + /// \todo NS_ASSERT (WifiPacketIsPending (animUid) == true); + m_pendingWifiPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + OutputWirelessPacketRxInfo (p, m_pendingWifiPackets[animUid], animUid); +} + +void +AnimationInterface::LrWpanPhyTxBeginTrace (std::string context, + Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + Ptr netDevice = DynamicCast (ndev); + + Ptr n = ndev->GetNode (); + NS_ASSERT (n); + + UpdatePosition (n); + + LrWpanMacHeader hdr; + if (!p->PeekHeader (hdr)) + { + NS_LOG_WARN ("LrWpanMacHeader not present"); + return; + } + + std::ostringstream oss; + if (hdr.GetSrcAddrMode () == 2) + { + Mac16Address nodeAddr = netDevice->GetMac ()->GetShortAddress (); + oss << nodeAddr; + } + else if (hdr.GetSrcAddrMode () == 3) + { + Mac64Address nodeAddr = netDevice->GetMac ()->GetExtendedAddress (); + oss << nodeAddr; + } + else + { + NS_LOG_WARN ("LrWpanMacHeader without source address"); + return; + } + m_macToNodeIdMap[oss.str ()] = n->GetId (); + NS_LOG_INFO ("Added Mac" << oss.str () << " node:" < p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + Ptr n = ndev->GetNode (); + NS_ASSERT (n); + + AnimByteTag tag; + if (!p->FindFirstMatchingByteTag (tag)) + { + return; + } + + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO ("LrWpan RxBeginTrace for packet:" << animUid); + if (!IsPacketPending (animUid, AnimationInterface::LRWPAN)) + { + NS_LOG_WARN ("LrWpanPhyRxBeginTrace: unknown Uid - most probably it's an ACK."); + } + + UpdatePosition (n); + m_pendingLrWpanPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + OutputWirelessPacketRxInfo (p, m_pendingLrWpanPackets[animUid], animUid); +} + +void +AnimationInterface::WavePhyTxBeginTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessTxTrace (context, p, AnimationInterface::WAVE); +} + +void +AnimationInterface::WavePhyRxBeginTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO ("Wave RxBeginTrace for packet:" << animUid); + if (!IsPacketPending (animUid, AnimationInterface::WAVE)) + { + NS_ASSERT (0); + NS_LOG_WARN ("WavePhyRxBeginTrace: unknown Uid"); + std::ostringstream oss; + WifiMacHeader hdr; + if (!p->PeekHeader (hdr)) + { + NS_LOG_WARN ("WaveMacHeader not present"); + return; + } + oss << hdr.GetAddr2 (); + if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ()) + { + NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping"); + return; + } + Ptr txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]); + UpdatePosition (txNode); + AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]); + AddPendingPacket (AnimationInterface::WAVE, animUid, pktInfo); + NS_LOG_WARN ("WavePhyRxBegin: unknown Uid, but we are adding a wave packet"); + } + /// \todo NS_ASSERT (WavePacketIsPending (animUid) == true); + m_pendingWavePackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + OutputWirelessPacketRxInfo (p, m_pendingWavePackets[animUid], animUid); +} + + +void +AnimationInterface::WimaxTxTrace (std::string context, Ptr p, const Mac48Address & m) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessTxTrace (context, p, AnimationInterface::WIMAX); +} + + +void +AnimationInterface::WimaxRxTrace (std::string context, Ptr p, const Mac48Address & m) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessRxTrace (context, p, AnimationInterface::WIMAX); +} + +void +AnimationInterface::LteTxTrace (std::string context, Ptr p, const Mac48Address & m) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessTxTrace (context, p, AnimationInterface::LTE); +} + +void +AnimationInterface::LteRxTrace (std::string context, Ptr p, const Mac48Address & m) +{ + NS_LOG_FUNCTION (this); + return GenericWirelessRxTrace (context, p, AnimationInterface::LTE); +} + +void +AnimationInterface::LteSpectrumPhyTxStart (std::string context, Ptr pb) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + if (!pb) + { + NS_LOG_WARN ("pb == 0. Not yet supported"); + return; + } + context = "/" + context; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + + std::list > pbList = pb->GetPackets (); + for (std::list >::iterator i = pbList.begin (); + i != pbList.end (); + ++i) + { + Ptr p = *i; + ++gAnimUid; + NS_LOG_INFO ("LteSpectrumPhyTxTrace for packet:" << gAnimUid); + AnimPacketInfo pktInfo (ndev, Simulator::Now ()); + AddByteTag (gAnimUid, p); + AddPendingPacket (AnimationInterface::LTE, gAnimUid, pktInfo); + OutputWirelessPacketTxInfo (p, pktInfo, gAnimUid); + } +} + +void +AnimationInterface::LteSpectrumPhyRxStart (std::string context, Ptr pb) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + if (!pb) + { + NS_LOG_WARN ("pb == 0. Not yet supported"); + return; + } + context = "/" + context; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + + std::list > pbList = pb->GetPackets (); + for (std::list >::iterator i = pbList.begin (); + i != pbList.end (); + ++i) + { + Ptr p = *i; + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO ("LteSpectrumPhyRxTrace for packet:" << gAnimUid); + if (!IsPacketPending (animUid, AnimationInterface::LTE)) + { + NS_LOG_WARN ("LteSpectrumPhyRxTrace: unknown Uid"); + return; + } + AnimPacketInfo& pktInfo = m_pendingLtePackets[animUid]; + pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + OutputWirelessPacketRxInfo (p, pktInfo, animUid); + } +} + +void +AnimationInterface::CsmaPhyTxBeginTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + ++gAnimUid; + NS_LOG_INFO ("CsmaPhyTxBeginTrace for packet:" << gAnimUid); + AddByteTag (gAnimUid, p); + UpdatePosition (ndev); + AnimPacketInfo pktInfo (ndev, Simulator::Now ()); + AddPendingPacket (AnimationInterface::CSMA, gAnimUid, pktInfo); + + +} + +void +AnimationInterface::CsmaPhyTxEndTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + NS_LOG_INFO ("CsmaPhyTxEndTrace for packet:" << animUid); + if (!IsPacketPending (animUid, AnimationInterface::CSMA)) + { + NS_LOG_WARN ("CsmaPhyTxEndTrace: unknown Uid"); + NS_FATAL_ERROR ("CsmaPhyTxEndTrace: unknown Uid"); + AnimPacketInfo pktInfo (ndev, Simulator::Now ()); + AddPendingPacket (AnimationInterface::CSMA, animUid, pktInfo); + NS_LOG_WARN ("Unknown Uid, but adding Csma Packet anyway"); + } + /// \todo NS_ASSERT (IsPacketPending (AnimUid) == true); + AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; + pktInfo.m_lbTx = Simulator::Now ().GetSeconds (); +} + +void +AnimationInterface::CsmaPhyRxEndTrace (std::string context, Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + UpdatePosition (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + if (!IsPacketPending (animUid, AnimationInterface::CSMA)) + { + NS_LOG_WARN ("CsmaPhyRxEndTrace: unknown Uid"); + return; + } + /// \todo NS_ASSERT (CsmaPacketIsPending (AnimUid) == true); + AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; + pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ()); + NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid); + NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid << " complete"); + OutputCsmaPacket (p, pktInfo); +} + +void +AnimationInterface::CsmaMacRxTrace (std::string context, + Ptr p) +{ + NS_LOG_FUNCTION (this); + CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS; + Ptr ndev = GetNetDeviceFromContext (context); + NS_ASSERT (ndev); + uint64_t animUid = GetAnimUidFromPacket (p); + if (!IsPacketPending (animUid, AnimationInterface::CSMA)) + { + NS_LOG_WARN ("CsmaMacRxTrace: unknown Uid"); + return; + } + /// \todo NS_ASSERT (CsmaPacketIsPending (AnimUid) == true); + AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid]; + NS_LOG_INFO ("MacRxTrace for packet:" << animUid << " complete"); + OutputCsmaPacket (p, pktInfo); +} + +void +AnimationInterface::OutputWirelessPacketTxInfo (Ptr p, AnimPacketInfo &pktInfo, uint64_t animUid) +{ + CheckMaxPktsPerTraceFile (); + uint32_t nodeId = 0; + if (pktInfo.m_txnd) + { + nodeId = pktInfo.m_txnd->GetNode ()->GetId (); + } + else + { + nodeId = pktInfo.m_txNodeId; + } + WriteXmlPRef (animUid, nodeId, pktInfo.m_fbTx, m_enablePacketMetadata? GetPacketMetadata (p):""); +} + +void +AnimationInterface::OutputWirelessPacketRxInfo (Ptr p, AnimPacketInfo & pktInfo, uint64_t animUid) +{ + CheckMaxPktsPerTraceFile (); + uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId (); + WriteXmlP (animUid, "wpr", rxId, pktInfo.m_fbRx, pktInfo.m_lbRx); +} + +void +AnimationInterface::OutputCsmaPacket (Ptr p, AnimPacketInfo &pktInfo) +{ + CheckMaxPktsPerTraceFile (); + NS_ASSERT (pktInfo.m_txnd); + uint32_t nodeId = pktInfo.m_txnd->GetNode ()->GetId (); + uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId (); + + WriteXmlP ("p", + nodeId, + pktInfo.m_fbTx, + pktInfo.m_lbTx, + rxId, + pktInfo.m_fbRx, + pktInfo.m_lbRx, + m_enablePacketMetadata? GetPacketMetadata (p):""); +} + +void +AnimationInterface::AddPendingPacket (ProtocolType protocolType, uint64_t animUid, AnimPacketInfo pktInfo) +{ + AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); + NS_ASSERT (pendingPackets); + pendingPackets->insert (AnimUidPacketInfoMap::value_type (animUid, pktInfo)); +} + +bool +AnimationInterface::IsPacketPending (uint64_t animUid, AnimationInterface::ProtocolType protocolType) +{ + AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); + NS_ASSERT (pendingPackets); + return (pendingPackets->find (animUid) != pendingPackets->end ()); +} + +void +AnimationInterface::PurgePendingPackets (AnimationInterface::ProtocolType protocolType) +{ + AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType); + NS_ASSERT (pendingPackets); + if (pendingPackets->empty ()) + { + return; + } + std::vector purgeList; + for (AnimUidPacketInfoMap::iterator i = pendingPackets->begin (); + i != pendingPackets->end (); + ++i) + { + + AnimPacketInfo pktInfo = i->second; + double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx); + if (delta > PURGE_INTERVAL) + { + purgeList.push_back (i->first); + } + } + for (std::vector ::iterator i = purgeList.begin (); + i != purgeList.end (); + ++i) + { + pendingPackets->erase (*i); + } +} + +AnimationInterface::AnimUidPacketInfoMap * +AnimationInterface::ProtocolTypeToPendingPackets (AnimationInterface::ProtocolType protocolType) +{ + AnimUidPacketInfoMap * pendingPackets = 0; + switch (protocolType) + { + case AnimationInterface::WIFI: + { + pendingPackets = &m_pendingWifiPackets; + break; + } + case AnimationInterface::UAN: + { + pendingPackets = &m_pendingUanPackets; + break; + } + case AnimationInterface::CSMA: + { + pendingPackets = &m_pendingCsmaPackets; + break; + } + case AnimationInterface::WIMAX: + { + pendingPackets = &m_pendingWimaxPackets; + break; + } + case AnimationInterface::LTE: + { + pendingPackets = &m_pendingLtePackets; + break; + } + case AnimationInterface::LRWPAN: + { + pendingPackets = &m_pendingLrWpanPackets; + break; + } + case AnimationInterface::WAVE: + { + pendingPackets = &m_pendingWavePackets; + break; + } + } + return pendingPackets; + +} + +std::string +AnimationInterface::ProtocolTypeToString (AnimationInterface::ProtocolType protocolType) +{ + std::string result = "Unknown"; + switch (protocolType) + { + case AnimationInterface::WIFI: + { + result = "WIFI"; + break; + } + case AnimationInterface::UAN: + { + result = "UAN"; + break; + } + case AnimationInterface::CSMA: + { + result = "CSMA"; + break; + } + case AnimationInterface::WIMAX: + { + result = "WIMAX"; + break; + } + case AnimationInterface::LTE: + { + result = "LTE"; + break; + } + case AnimationInterface::LRWPAN: + { + result = "LRWPAN"; + break; + } + case AnimationInterface::WAVE: + { + result = "WAVE"; + break; + } + } + return result; +} + +// Counters + +std::string +AnimationInterface::CounterTypeToString (CounterType counterType) +{ + std::string typeString = "unknown"; + switch (counterType) + { + case UINT32_COUNTER: + { + typeString = "UINT32"; + break; + } + case DOUBLE_COUNTER: + { + typeString = "DOUBLE"; + break; + } + } + return typeString; +} + +// General + +std::string +AnimationInterface::GetPacketMetadata (Ptr p) +{ + std::ostringstream oss; + p->Print (oss); + return oss.str (); +} + +uint64_t +AnimationInterface::GetTracePktCount () +{ + return m_currentPktCount; +} + +void +AnimationInterface::StopAnimation (bool onlyAnimation) +{ + m_started = false; + NS_LOG_INFO ("Stopping Animation"); + ResetAnimWriteCallback (); + if (m_f) + { + // Terminate the anim element + WriteXmlClose ("anim"); + std::fclose (m_f); + m_f = 0; + } + if (onlyAnimation) + { + return; + } + if (m_routingF) + { + WriteXmlClose ("anim", true); + std::fclose (m_routingF); + m_routingF = 0; + } +} + +void +AnimationInterface::StartAnimation (bool restart) +{ + m_currentPktCount = 0; + m_started = true; + SetOutputFile (m_outputFileName); + WriteXmlAnim (); + WriteNodes (); + WriteNodeColors (); + WriteLinkProperties (); + WriteIpv4Addresses (); + WriteIpv6Addresses (); + WriteNodeSizes (); + WriteNodeEnergies (); + if (!restart) + { + Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this); + ConnectCallbacks (); + } +} + +void +AnimationInterface::AddToIpv4AddressNodeIdTable (std::string ipv4Address, uint32_t nodeId) +{ + m_ipv4ToNodeIdMap[ipv4Address] = nodeId; + m_nodeIdIpv4Map.insert(NodeIdIpv4Pair(nodeId, ipv4Address)); +} + +void +AnimationInterface::AddToIpv4AddressNodeIdTable (std::vector ipv4Addresses, uint32_t nodeId) +{ + for (std::vector::const_iterator i = ipv4Addresses.begin (); + i != ipv4Addresses.end (); + ++i) + { + AddToIpv4AddressNodeIdTable (*i, nodeId); + } +} + +void +AnimationInterface::AddToIpv6AddressNodeIdTable(std::string ipv6Address, uint32_t nodeId) +{ + m_ipv6ToNodeIdMap[ipv6Address] = nodeId; + m_nodeIdIpv6Map.insert(NodeIdIpv6Pair(nodeId, ipv6Address)); +} + +void +AnimationInterface::AddToIpv6AddressNodeIdTable(std::vector ipv6Addresses, uint32_t nodeId) +{ + for (std::vector::const_iterator i = ipv6Addresses.begin(); + i != ipv6Addresses.end(); + ++i) + { + AddToIpv6AddressNodeIdTable(*i, nodeId); + } +} + +// Callbacks +void +AnimationInterface::ConnectLteEnb (Ptr n, Ptr nd, uint32_t devIndex) +{ + + Ptr lteEnbPhy = nd->GetPhy (); + Ptr dlPhy = lteEnbPhy->GetDownlinkSpectrumPhy (); + Ptr ulPhy = lteEnbPhy->GetUplinkSpectrumPhy (); + std::ostringstream oss; + //NodeList/*/DeviceList/*/ + oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/"; + if (dlPhy) + { + dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); + dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); + } + if (ulPhy) + { + ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); + ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); + } +} + + + +void +AnimationInterface::ConnectLteUe (Ptr n, Ptr nd, uint32_t devIndex) +{ + + Ptr lteUePhy = nd->GetPhy (); + Ptr dlPhy = lteUePhy->GetDownlinkSpectrumPhy (); + Ptr ulPhy = lteUePhy->GetUplinkSpectrumPhy (); + std::ostringstream oss; + //NodeList/*/DeviceList/*/ + oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/"; + if (dlPhy) + { + dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); + dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); + } + if (ulPhy) + { + ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this)); + ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this)); + } +} + +void +AnimationInterface::ConnectLte () +{ + + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + NS_ASSERT (n); + uint32_t nDevices = n->GetNDevices (); + for (uint32_t devIndex = 0; devIndex < nDevices; ++devIndex) + { + Ptr nd = n->GetDevice (devIndex); + if (!nd) + continue; + Ptr lteUeNetDevice = DynamicCast (nd); + if (lteUeNetDevice) + { + ConnectLteUe (n, lteUeNetDevice, devIndex); + continue; + } + Ptr lteEnbNetDevice = DynamicCast (nd); + if (lteEnbNetDevice) + ConnectLteEnb (n, lteEnbNetDevice, devIndex); + } + + } +} + +void +AnimationInterface::ConnectCallbacks () +{ + // Connect the callbacks + Config::Connect ("/ChannelList/*/TxRxPointToPoint", + MakeCallback (&AnimationInterface::DevTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxBegin", + MakeCallback (&AnimationInterface::WifiPhyTxBeginTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxBegin", + MakeCallback (&AnimationInterface::WifiPhyRxBeginTrace, this)); + Config::ConnectWithoutContext ("/NodeList/*/$ns3::MobilityModel/CourseChange", + MakeCallback (&AnimationInterface::MobilityCourseChangeTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Tx", + MakeCallback (&AnimationInterface::WimaxTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Rx", + MakeCallback (&AnimationInterface::WimaxRxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Tx", + MakeCallback (&AnimationInterface::LteTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Rx", + MakeCallback (&AnimationInterface::LteRxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxBegin", + MakeCallback (&AnimationInterface::CsmaPhyTxBeginTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxEnd", + MakeCallback (&AnimationInterface::CsmaPhyTxEndTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyRxEnd", + MakeCallback (&AnimationInterface::CsmaPhyRxEndTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacRx", + MakeCallback (&AnimationInterface::CsmaMacRxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyTxBegin", + MakeCallback (&AnimationInterface::UanPhyGenTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyRxBegin", + MakeCallback (&AnimationInterface::UanPhyGenRxTrace, this)); + Config::Connect ("/NodeList/*/$ns3::BasicEnergySource/RemainingEnergy", + MakeCallback (&AnimationInterface::RemainingEnergyTrace, this)); + + ConnectLte (); + + Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Tx", + MakeCallback (&AnimationInterface::Ipv4TxTrace, this)); + Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Rx", + MakeCallback (&AnimationInterface::Ipv4RxTrace, this)); + Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Drop", + MakeCallback (&AnimationInterface::Ipv4DropTrace, this)); + + // Queue Enqueues + + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Enqueue", + MakeCallback (&AnimationInterface::EnqueueTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Enqueue", + MakeCallback (&AnimationInterface::EnqueueTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Enqueue", + MakeCallback (&AnimationInterface::EnqueueTrace, this)); + + // Queue Dequeues + + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Dequeue", + MakeCallback (&AnimationInterface::DequeueTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Dequeue", + MakeCallback (&AnimationInterface::DequeueTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Dequeue", + MakeCallback (&AnimationInterface::DequeueTrace, this)); + + // Queue Drops + + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Drop", + MakeCallback (&AnimationInterface::QueueDropTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Drop", + MakeCallback (&AnimationInterface::QueueDropTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Drop", + MakeCallback (&AnimationInterface::QueueDropTrace, this)); + + + // Wifi Mac + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx", + MakeCallback (&AnimationInterface::WifiMacTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTxDrop", + MakeCallback (&AnimationInterface::WifiMacTxDropTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx", + MakeCallback (&AnimationInterface::WifiMacRxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRxDrop", + MakeCallback (&AnimationInterface::WifiMacRxDropTrace, this)); + + // Wifi Phy + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxDrop", + MakeCallback (&AnimationInterface::WifiPhyTxDropTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop", + MakeCallback (&AnimationInterface::WifiPhyRxDropTrace, this)); + + // LrWpan + Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyTxBegin", + MakeCallback (&AnimationInterface::LrWpanPhyTxBeginTrace, this)); + Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyRxBegin", + MakeCallback (&AnimationInterface::LrWpanPhyRxBeginTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTx", + MakeCallback (&AnimationInterface::LrWpanMacTxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTxDrop", + MakeCallback (&AnimationInterface::LrWpanMacTxDropTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRx", + MakeCallback (&AnimationInterface::LrWpanMacRxTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRxDrop", + MakeCallback (&AnimationInterface::LrWpanMacRxDropTrace, this)); + + // Wave + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyTxBegin", + MakeCallback (&AnimationInterface::WavePhyTxBeginTrace, this)); + Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyRxBegin", + MakeCallback (&AnimationInterface::WavePhyRxBeginTrace, this)); +} + +Vector +AnimationInterface::UpdatePosition (Ptr n) +{ + Ptr loc = n->GetObject (); + if (loc) + { + m_nodeLocation[n->GetId ()] = loc->GetPosition (); + } + else + { + NS_LOG_UNCOND ( "AnimationInterface WARNING:Node:" << n->GetId () << " Does not have a mobility model. Use SetConstantPosition if it is stationary"); + Ptr x = CreateObject (); + x->SetAttribute ("Min", DoubleValue (0)); + x->SetAttribute ("Max", DoubleValue (100)); + Ptr y = CreateObject (); + y->SetAttribute ("Min", DoubleValue (0)); + y->SetAttribute ("Max", DoubleValue (100)); + m_nodeLocation[n->GetId ()] = Vector (int (x->GetValue ()), int (y->GetValue ()), 0); + } + return m_nodeLocation[n->GetId ()]; +} + +Vector +AnimationInterface::UpdatePosition (Ptr n, Vector v) +{ + m_nodeLocation[n->GetId ()] = v; + return v; +} + +Vector +AnimationInterface::UpdatePosition (Ptr ndev) +{ + Ptr n = ndev->GetNode (); + NS_ASSERT (n); + return UpdatePosition (n); +} + +Vector +AnimationInterface::GetPosition (Ptr n) +{ + if (m_nodeLocation.find (n->GetId ()) == m_nodeLocation.end ()) + { + NS_FATAL_ERROR ("Node:" <GetId () << " not found in Location table"); + } + return m_nodeLocation[n->GetId ()]; +} + + +std::string +AnimationInterface::GetMacAddress (Ptr nd) +{ + Address nodeAddr = nd->GetAddress (); + std::ostringstream oss; + oss << nodeAddr; + return oss.str ().substr (6); // Skip the first 6 chars to get the Mac +} + +std::string +AnimationInterface::GetIpv4Address (Ptr nd) +{ + Ptr ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); + if (!ipv4) + { + NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found"); + return "0.0.0.0"; + } + int32_t ifIndex = ipv4->GetInterfaceForDevice (nd); + if (ifIndex == -1) + { + NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); + return "0.0.0.0"; + } + Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, 0); + std::ostringstream oss; + oss << addr.GetLocal (); + return oss.str (); +} + +std::string +AnimationInterface::GetIpv6Address(Ptr nd) +{ + Ptr ipv6 = NodeList::GetNode(nd->GetNode()->GetId())->GetObject (); + if (!ipv6) + { + NS_LOG_WARN("Node: " << nd->GetNode()->GetId() << " No ipv4 object found"); + return "::"; + } + int32_t ifIndex = ipv6->GetInterfaceForDevice(nd); + if (ifIndex == -1) + { + NS_LOG_WARN("Node :" << nd->GetNode()->GetId() << " Could not find index of NetDevice"); + return "::"; + } + bool nonLinkLocalFound = false; + uint32_t nAddresses = ipv6->GetNAddresses(ifIndex); + Ipv6InterfaceAddress addr; + for (uint32_t addressIndex = 0; addressIndex < nAddresses; ++addressIndex) + { + addr = ipv6->GetAddress(ifIndex, addressIndex); + if (!addr.GetAddress().IsLinkLocal()) + { + nonLinkLocalFound = true; + break; + } + } + if (!nonLinkLocalFound) + addr = ipv6->GetAddress(ifIndex, 0); + std::ostringstream oss; + oss << addr.GetAddress(); + return oss.str(); +} + + + +std::vector +AnimationInterface::GetIpv4Addresses (Ptr nd) +{ + std::vector ipv4Addresses; + Ptr ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); + if (!ipv4) + { + NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found"); + return ipv4Addresses; + } + int32_t ifIndex = ipv4->GetInterfaceForDevice (nd); + if (ifIndex == -1) + { + NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); + return ipv4Addresses; + } + for (uint32_t index = 0; index < ipv4->GetNAddresses (ifIndex); ++index) + { + Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, index); + std::ostringstream oss; + oss << addr.GetLocal (); + ipv4Addresses.push_back(oss.str ()); + } + return ipv4Addresses; +} + +std::vector +AnimationInterface::GetIpv6Addresses(Ptr nd) +{ + std::vector ipv6Addresses; + Ptr ipv6 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject (); + if (!ipv6) + { + NS_LOG_WARN("Node: " << nd->GetNode ()->GetId () << " No ipv6 object found"); + return ipv6Addresses; + } + int32_t ifIndex = ipv6->GetInterfaceForDevice (nd); + if (ifIndex == -1) + { + NS_LOG_WARN("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice"); + return ipv6Addresses; + } + for (uint32_t index = 0; index < ipv6->GetNAddresses (ifIndex); ++index) + { + Ipv6InterfaceAddress addr = ipv6->GetAddress (ifIndex, index); + std::ostringstream oss; + oss << addr.GetAddress (); + ipv6Addresses.push_back (oss.str ()); + } + return ipv6Addresses; +} + + +void +AnimationInterface::WriteIpv4Addresses () +{ + for (NodeIdIpv4Map::const_iterator i = m_nodeIdIpv4Map.begin (); + i != m_nodeIdIpv4Map.end(); + ++i) + { + std::vector ipv4Addresses; + std::pair iterPair = m_nodeIdIpv4Map.equal_range (i->first); + for (NodeIdIpv4Map::const_iterator it = iterPair.first; + it != iterPair.second; + ++it) + { + ipv4Addresses.push_back (it->second); + } + WriteXmlIpv4Addresses (i->first, ipv4Addresses); + } +} + +void +AnimationInterface::WriteIpv6Addresses() +{ + for (NodeIdIpv6Map::const_iterator i = m_nodeIdIpv6Map.begin (); + i != m_nodeIdIpv6Map.end (); + i = m_nodeIdIpv6Map.upper_bound (i->first)) + { + std::vector ipv6Addresses; + std::pair iterPair = m_nodeIdIpv6Map.equal_range (i->first); + for (NodeIdIpv6Map::const_iterator it = iterPair.first; + it != iterPair.second; + ++it) + { + ipv6Addresses.push_back (it->second); + } + WriteXmlIpv6Addresses (i->first, ipv6Addresses); + } +} + +void +AnimationInterface::WriteLinkProperties () +{ + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + UpdatePosition (n); + uint32_t n1Id = n->GetId (); + uint32_t nDev = n->GetNDevices (); // Number of devices + for (uint32_t i = 0; i < nDev; ++i) + { + Ptr dev = n->GetDevice (i); + NS_ASSERT (dev); + Ptr ch = dev->GetChannel (); + std::string channelType = "Unknown channel"; + if (ch) + { + channelType = ch->GetInstanceTypeId ().GetName (); + } + NS_LOG_DEBUG("Got ChannelType" << channelType); + + if (!ch || (channelType != std::string("ns3::PointToPointChannel"))) + { + NS_LOG_DEBUG ("No channel can't be a p2p device"); + /* + // Try to see if it is an LTE NetDevice, which does not return a channel + if ((dev->GetInstanceTypeId ().GetName () == "ns3::LteUeNetDevice") || + (dev->GetInstanceTypeId ().GetName () == "ns3::LteEnbNetDevice")|| + (dev->GetInstanceTypeId ().GetName () == "ns3::VirtualNetDevice")) + { + WriteNonP2pLinkProperties (n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType); + AddToIpv4AddressNodeIdTable (GetIpv4Address (dev), n->GetId ()); + } + */ + std::vector ipv4Addresses = GetIpv4Addresses (dev); + AddToIpv4AddressNodeIdTable(ipv4Addresses, n->GetId ()); + std::vector ipv6Addresses = GetIpv6Addresses (dev); + AddToIpv6AddressNodeIdTable(ipv6Addresses, n->GetId ()); + if (!ipv4Addresses.empty ()) + { + NS_LOG_INFO ("Writing Ipv4 link"); + WriteNonP2pLinkProperties(n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType); + } + else if (!ipv6Addresses.empty ()) + { + NS_LOG_INFO ("Writing Ipv6 link"); + WriteNonP2pLinkProperties(n->GetId (), GetIpv6Address (dev) + "~" + GetMacAddress (dev), channelType); + } + continue; + } + + else if (channelType == std::string ("ns3::PointToPointChannel")) + { // Since these are duplex links, we only need to dump + // if srcid < dstid + uint32_t nChDev = ch->GetNDevices (); + for (uint32_t j = 0; j < nChDev; ++j) + { + Ptr chDev = ch->GetDevice (j); + uint32_t n2Id = chDev->GetNode ()->GetId (); + if (n1Id < n2Id) + { + + std::vector ipv4Addresses = GetIpv4Addresses (dev); + AddToIpv4AddressNodeIdTable (ipv4Addresses, n1Id); + ipv4Addresses = GetIpv4Addresses (chDev); + AddToIpv4AddressNodeIdTable (ipv4Addresses, n2Id); + std::vector ipv6Addresses = GetIpv6Addresses (dev); + AddToIpv6AddressNodeIdTable(ipv6Addresses, n1Id); + ipv6Addresses = GetIpv6Addresses (chDev); + AddToIpv6AddressNodeIdTable(ipv6Addresses, n2Id); + + P2pLinkNodeIdPair p2pPair; + p2pPair.fromNode = n1Id; + p2pPair.toNode = n2Id; + if (!ipv4Addresses.empty ()) + { + LinkProperties lp = { GetIpv4Address (dev) + "~" + GetMacAddress (dev), GetIpv4Address (chDev) + "~" + GetMacAddress (chDev), "" }; + m_linkProperties[p2pPair] = lp; + } + else if (!ipv6Addresses.empty ()) + { + LinkProperties lp = { GetIpv6Address (dev) + "~" + GetMacAddress (dev), GetIpv6Address (chDev) + "~" + GetMacAddress (chDev), "" }; + m_linkProperties[p2pPair] = lp; + } + WriteXmlLink (n1Id, 0, n2Id); + } + } + } + } + } + m_linkProperties.clear (); +} + +void +AnimationInterface::WriteNodes () +{ + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + NS_LOG_INFO ("Update Position for Node: " << n->GetId ()); + Vector v = UpdatePosition (n); + WriteXmlNode (n->GetId (), n->GetSystemId (), v.x, v.y); + } +} + +void +AnimationInterface::WriteNodeColors () +{ + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + Rgb rgb = {255, 0, 0}; + if (m_nodeColors.find (n->GetId ()) == m_nodeColors.end ()) + { + m_nodeColors[n->GetId ()] = rgb; + } + UpdateNodeColor (n, rgb.r, rgb.g, rgb.b); + } +} + +void +AnimationInterface::WriteNodeSizes () +{ + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + NS_LOG_INFO ("Update Size for Node: " << n->GetId ()); + AnimationInterface::NodeSize s = { 1, 1 }; + m_nodeSizes[n->GetId ()] = s; + UpdateNodeSize (n->GetId (), s.width, s.height); + } +} + +void +AnimationInterface::WriteNodeEnergies () +{ + m_remainingEnergyCounterId = AddNodeCounter ("RemainingEnergy", AnimationInterface::DOUBLE_COUNTER); + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + if (NodeList::GetNode (n->GetId ())->GetObject ()) + { + UpdateNodeCounter (m_remainingEnergyCounterId, n->GetId (), 1); + } + } +} + +bool +AnimationInterface::IsInTimeWindow () +{ + if ((Simulator::Now () >= m_startTime) && + (Simulator::Now () <= m_stopTime)) + return true; + else + return false; +} + +void +AnimationInterface::SetOutputFile (const std::string& fn, bool routing) +{ + if (!routing && m_f) + { + return; + } + if (routing && m_routingF) + { + NS_FATAL_ERROR ("SetRoutingOutputFile already used once"); + return; + } + + NS_LOG_INFO ("Creating new trace file:" << fn.c_str ()); + FILE * f = 0; + f = std::fopen (fn.c_str (), "w"); + if (!f) + { + NS_FATAL_ERROR ("Unable to open output file:" << fn.c_str ()); + return; // Can't open output file + } + if (routing) + { + m_routingF = f; + m_routingFileName = fn; + } + else + { + m_f = f; + m_outputFileName = fn; + } + return; +} + +void +AnimationInterface::CheckMaxPktsPerTraceFile () +{ + // Start a new trace file if the current packet count exceeded nax packets per file + ++m_currentPktCount; + if (m_currentPktCount <= m_maxPktsPerFile) + { + return; + } + NS_LOG_UNCOND ("Max Packets per trace file exceeded"); + StopAnimation (true); +} + +std::string +AnimationInterface::GetNetAnimVersion () +{ + return NETANIM_VERSION; +} + + +void +AnimationInterface::TrackQueueCounters () +{ + if (Simulator::Now () > m_queueCountersStopTime) + { + NS_LOG_INFO ("TrackQueueCounters Completed"); + return; + } + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + uint32_t nodeId = Ptr (*i)->GetId (); + UpdateNodeCounter (m_queueEnqueueCounterId, nodeId, m_nodeQueueEnqueue[nodeId]); + UpdateNodeCounter (m_queueDequeueCounterId, nodeId, m_nodeQueueDequeue[nodeId]); + UpdateNodeCounter (m_queueDropCounterId, nodeId, m_nodeQueueDrop[nodeId]); + } + Simulator::Schedule (m_queueCountersPollInterval, &AnimationInterface::TrackQueueCounters, this); +} + +void +AnimationInterface::TrackWifiMacCounters () +{ + if (Simulator::Now () > m_wifiMacCountersStopTime) + { + NS_LOG_INFO ("TrackWifiMacCounters Completed"); + return; + } + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + uint32_t nodeId = Ptr (*i)->GetId (); + UpdateNodeCounter (m_wifiMacTxCounterId, nodeId, m_nodeWifiMacTx[nodeId]); + UpdateNodeCounter (m_wifiMacTxDropCounterId, nodeId, m_nodeWifiMacTxDrop[nodeId]); + UpdateNodeCounter (m_wifiMacRxCounterId, nodeId, m_nodeWifiMacRx[nodeId]); + UpdateNodeCounter (m_wifiMacRxDropCounterId, nodeId, m_nodeWifiMacRxDrop[nodeId]); + } + Simulator::Schedule (m_wifiMacCountersPollInterval, &AnimationInterface::TrackWifiMacCounters, this); +} + +void +AnimationInterface::TrackWifiPhyCounters () +{ + if (Simulator::Now () > m_wifiPhyCountersStopTime) + { + NS_LOG_INFO ("TrackWifiPhyCounters Completed"); + return; + } + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + uint32_t nodeId = Ptr (*i)->GetId (); + UpdateNodeCounter (m_wifiPhyTxDropCounterId, nodeId, m_nodeWifiPhyTxDrop[nodeId]); + UpdateNodeCounter (m_wifiPhyRxDropCounterId, nodeId, m_nodeWifiPhyRxDrop[nodeId]); + } + Simulator::Schedule (m_wifiPhyCountersPollInterval, &AnimationInterface::TrackWifiPhyCounters, this); +} + +void +AnimationInterface::TrackIpv4L3ProtocolCounters () +{ + if (Simulator::Now () > m_ipv4L3ProtocolCountersStopTime) + { + NS_LOG_INFO ("TrackIpv4L3ProtocolCounters Completed"); + return; + } + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + uint32_t nodeId = Ptr (*i)->GetId (); + UpdateNodeCounter (m_ipv4L3ProtocolTxCounterId, nodeId, m_nodeIpv4Tx[nodeId]); + UpdateNodeCounter (m_ipv4L3ProtocolRxCounterId, nodeId, m_nodeIpv4Rx[nodeId]); + UpdateNodeCounter (m_ipv4L3ProtocolDropCounterId, nodeId, m_nodeIpv4Drop[nodeId]); + } + Simulator::Schedule (m_ipv4L3ProtocolCountersPollInterval, &AnimationInterface::TrackIpv4L3ProtocolCounters, this); +} + + + + + +/***** Routing-related *****/ + +void +AnimationInterface::TrackIpv4RoutePaths () +{ + if (m_ipv4RouteTrackElements.empty ()) + { + return; + } + for (std::vector ::const_iterator i = m_ipv4RouteTrackElements.begin (); + i != m_ipv4RouteTrackElements.end (); + ++i) + { + Ipv4RouteTrackElement trackElement = *i; + Ptr fromNode = NodeList::GetNode (trackElement.fromNodeId); + if (!fromNode) + { + NS_FATAL_ERROR ("Node: " << trackElement.fromNodeId << " Not found"); + continue; + } + Ptr ipv4 = fromNode->GetObject (); + if (!ipv4) + { + NS_LOG_WARN ("ipv4 object not found"); + continue; + } + Ptr rp = ipv4->GetRoutingProtocol (); + if (!rp) + { + NS_LOG_WARN ("Routing protocol object not found"); + continue; + } + NS_LOG_INFO ("Begin Track Route for: " << trackElement.destination.c_str () << " From:" << trackElement.fromNodeId); + Ptr pkt = Create (); + Ipv4Header header; + header.SetDestination (Ipv4Address (trackElement.destination.c_str ())); + Socket::SocketErrno sockerr; + Ptr rt = rp->RouteOutput (pkt, header, 0, sockerr); + Ipv4RoutePathElements rpElements; + if (!rt) + { + NS_LOG_INFO ("No route to :" << trackElement.destination.c_str ()); + Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" }; + rpElements.push_back (elem); + WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements); + continue; + } + std::ostringstream oss; + oss << rt->GetGateway (); + NS_LOG_INFO ("Node:" << trackElement.fromNodeId << "-->" << rt->GetGateway ()); + if (rt->GetGateway () == "0.0.0.0") + { + Ipv4RoutePathElement elem = { trackElement.fromNodeId, "C" }; + rpElements.push_back (elem); + if ( m_ipv4ToNodeIdMap.find (trackElement.destination) != m_ipv4ToNodeIdMap.end ()) + { + Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[trackElement.destination], "L" }; + rpElements.push_back (elem2); + } + } + else if (rt->GetGateway () == "127.0.0.1") + { + Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" }; + rpElements.push_back (elem); + } + else + { + Ipv4RoutePathElement elem = { trackElement.fromNodeId, oss.str () }; + rpElements.push_back (elem); + } + RecursiveIpv4RoutePathSearch (oss.str (), trackElement.destination, rpElements); + WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements); + } + +} + +void +AnimationInterface::TrackIpv4Route () +{ + if (Simulator::Now () > m_routingStopTime) + { + NS_LOG_INFO ("TrackIpv4Route completed"); + return; + } + if (m_routingNc.GetN ()) + { + for (NodeContainer::Iterator i = m_routingNc.Begin (); i != m_routingNc.End (); ++i) + { + Ptr n = *i; + WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n)); + } + } + else + { + for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) + { + Ptr n = *i; + WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n)); + } + } + TrackIpv4RoutePaths (); + Simulator::Schedule (m_routingPollInterval, &AnimationInterface::TrackIpv4Route, this); +} + +std::string +AnimationInterface::GetIpv4RoutingTable (Ptr n) +{ + + NS_ASSERT (n); + Ptr ipv4 = n->GetObject (); + if (!ipv4) + { + NS_LOG_WARN ("Node " << n->GetId () << " Does not have an Ipv4 object"); + return ""; + } + std::stringstream stream; + Ptr routingstream = Create (&stream); + ipv4->GetRoutingProtocol ()->PrintRoutingTable (routingstream); + return stream.str (); + +} + +void +AnimationInterface::RecursiveIpv4RoutePathSearch (std::string from, std::string to, Ipv4RoutePathElements & rpElements) +{ + NS_LOG_INFO ("RecursiveIpv4RoutePathSearch from:" << from.c_str () << " to:" << to.c_str ()); + if ((from == "0.0.0.0") || (from == "127.0.0.1")) + { + NS_LOG_INFO ("Got " << from.c_str () << " End recursion"); + return; + } + Ptr fromNode = NodeList::GetNode (m_ipv4ToNodeIdMap[from]); + Ptr toNode = NodeList::GetNode (m_ipv4ToNodeIdMap[to]); + if (fromNode->GetId () == toNode->GetId ()) + { + Ipv4RoutePathElement elem = { fromNode->GetId (), "L" }; + rpElements.push_back (elem); + return; + } + if (!fromNode) + { + NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[from] << " Not found"); + return; + } + if (!toNode) + { + NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[to] << " Not found"); + return; + } + Ptr ipv4 = fromNode->GetObject (); + if (!ipv4) + { + NS_LOG_WARN ("ipv4 object not found"); + return; + } + Ptr rp = ipv4->GetRoutingProtocol (); + if (!rp) + { + NS_LOG_WARN ("Routing protocol object not found"); + return; + } + Ptr pkt = Create (); + Ipv4Header header; + header.SetDestination (Ipv4Address (to.c_str ())); + Socket::SocketErrno sockerr; + Ptr rt = rp->RouteOutput (pkt, header, 0, sockerr); + if (!rt) + { + return; + } + NS_LOG_DEBUG ("Node: " << fromNode->GetId () << " G:" << rt->GetGateway ()); + std::ostringstream oss; + oss << rt->GetGateway (); + if (oss.str () == "0.0.0.0" && (sockerr != Socket::ERROR_NOROUTETOHOST)) + { + NS_LOG_INFO ("Null gw"); + Ipv4RoutePathElement elem = { fromNode->GetId (), "C" }; + rpElements.push_back (elem); + if ( m_ipv4ToNodeIdMap.find (to) != m_ipv4ToNodeIdMap.end ()) + { + Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[to], "L" }; + rpElements.push_back (elem2); + } + return; + } + NS_LOG_INFO ("Node:" << fromNode->GetId () << "-->" << rt->GetGateway ()); + Ipv4RoutePathElement elem = { fromNode->GetId (), oss.str () }; + rpElements.push_back (elem); + RecursiveIpv4RoutePathSearch (oss.str (), to, rpElements); + +} + + + +/***** WriteXml *****/ + +void +AnimationInterface::WriteXmlAnim (bool routing) +{ + AnimXmlElement element ("anim"); + element.AddAttribute ("ver", GetNetAnimVersion ()); + FILE * f = m_f; + if (!routing) + { + element.AddAttribute ("filetype", "animation"); + } + else + { + element.AddAttribute ("filetype", "routing"); + f = m_routingF; + } + WriteN (element.ToString (false) + ">\n", f); +} + +void +AnimationInterface::WriteXmlClose (std::string name, bool routing) +{ + std::string closeString = "\n"; + if (!routing) + { + WriteN (closeString, m_f); + } + else + { + WriteN (closeString, m_routingF); + } +} + +void +AnimationInterface::WriteXmlNode (uint32_t id, uint32_t sysId, double locX, double locY) +{ + AnimXmlElement element ("node"); + element.AddAttribute ("id", id); + element.AddAttribute ("sysId", sysId); + element.AddAttribute ("locX", locX); + element.AddAttribute ("locY", locY); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string linkDescription) +{ + AnimXmlElement element ("linkupdate"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("fromId", fromId); + element.AddAttribute ("toId", toId); + element.AddAttribute ("ld", linkDescription, true); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlLink (uint32_t fromId, uint32_t toLp, uint32_t toId) +{ + AnimXmlElement element ("link"); + element.AddAttribute ("fromId", fromId); + element.AddAttribute ("toId", toId); + + LinkProperties lprop ; + lprop.fromNodeDescription = ""; + lprop.toNodeDescription = ""; + lprop.linkDescription = ""; + + P2pLinkNodeIdPair p1 = { fromId, toId }; + P2pLinkNodeIdPair p2 = { toId, fromId }; + if (m_linkProperties.find (p1) != m_linkProperties.end ()) + { + lprop = m_linkProperties[p1]; + } + else if (m_linkProperties.find (p2) != m_linkProperties.end ()) + { + lprop = m_linkProperties[p2]; + } + + element.AddAttribute ("fd", lprop.fromNodeDescription, true); + element.AddAttribute ("td", lprop.toNodeDescription, true); + element.AddAttribute ("ld", lprop.linkDescription, true); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlIpv4Addresses (uint32_t nodeId, std::vector ipv4Addresses) +{ + AnimXmlElement element ("ip"); + element.AddAttribute ("n", nodeId); + for (std::vector::const_iterator i = ipv4Addresses.begin (); + i != ipv4Addresses.end (); + ++i) + { + AnimXmlElement valueElement ("address"); + valueElement.SetText (*i); + element.AppendChild(valueElement); + } + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlIpv6Addresses (uint32_t nodeId, std::vector ipv6Addresses) +{ + AnimXmlElement element ("ipv6"); + element.AddAttribute("n", nodeId); + for (std::vector::const_iterator i = ipv6Addresses.begin (); + i != ipv6Addresses.end (); + ++i) + { + AnimXmlElement valueElement ("address"); + valueElement.SetText (*i); + element.AppendChild (valueElement); + } + WriteN(element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlRouting (uint32_t nodeId, std::string routingInfo) +{ + AnimXmlElement element ("rt"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("info", routingInfo.c_str (), true); + WriteN (element.ToString (), m_routingF); +} + +void +AnimationInterface::WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements) +{ + std::string tagName = "rp"; + AnimXmlElement element (tagName, false); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("d", destination.c_str ()); + element.AddAttribute ("c", rpElements.size ()); + for (Ipv4RoutePathElements::const_iterator i = rpElements.begin (); + i != rpElements.end (); + ++i) + { + Ipv4RoutePathElement rpElement = *i; + AnimXmlElement rpeElement ("rpe"); + rpeElement.AddAttribute ("n", rpElement.nodeId); + rpeElement.AddAttribute ("nH", rpElement.nextHop.c_str ()); + element.AppendChild (rpeElement); + } + WriteN (element.ToString (), m_routingF); +} + + +void +AnimationInterface::WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo) +{ + AnimXmlElement element ("pr"); + element.AddAttribute ("uId", animUid); + element.AddAttribute ("fId", fId); + element.AddAttribute ("fbTx", fbTx); + if (!metaInfo.empty ()) + { + element.AddAttribute ("meta-info", metaInfo.c_str (), true); + } + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlP (uint64_t animUid, std::string pktType, uint32_t tId, double fbRx, double lbRx) +{ + AnimXmlElement element (pktType); + element.AddAttribute ("uId", animUid); + element.AddAttribute ("tId", tId); + element.AddAttribute ("fbRx", fbRx); + element.AddAttribute ("lbRx", lbRx); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlP (std::string pktType, uint32_t fId, double fbTx, double lbTx, + uint32_t tId, double fbRx, double lbRx, std::string metaInfo) +{ + AnimXmlElement element (pktType); + element.AddAttribute ("fId", fId); + element.AddAttribute ("fbTx", fbTx); + element.AddAttribute ("lbTx", lbTx); + if (!metaInfo.empty ()) + { + element.AddAttribute ("meta-info", metaInfo.c_str (), true); + } + element.AddAttribute ("tId", tId); + element.AddAttribute ("fbRx", fbRx); + element.AddAttribute ("lbRx", lbRx); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlAddNodeCounter (uint32_t nodeCounterId, std::string counterName, CounterType counterType) +{ + AnimXmlElement element ("ncs"); + element.AddAttribute ("ncId", nodeCounterId); + element.AddAttribute ("n", counterName); + element.AddAttribute ("t", CounterTypeToString (counterType)); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlAddResource (uint32_t resourceId, std::string resourcePath) +{ + AnimXmlElement element ("res"); + element.AddAttribute ("rid", resourceId); + element.AddAttribute ("p", resourcePath); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateNodeImage (uint32_t nodeId, uint32_t resourceId) +{ + AnimXmlElement element ("nu"); + element.AddAttribute ("p", "i"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("rid", resourceId); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateNodeSize (uint32_t nodeId, double width, double height) +{ + AnimXmlElement element ("nu"); + element.AddAttribute ("p", "s"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("w", width); + element.AddAttribute ("h", height); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateNodePosition (uint32_t nodeId, double x, double y) +{ + AnimXmlElement element ("nu"); + element.AddAttribute ("p", "p"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("x", x); + element.AddAttribute ("y", y); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b) +{ + AnimXmlElement element ("nu"); + element.AddAttribute ("p", "c"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + element.AddAttribute ("r", (uint32_t) r); + element.AddAttribute ("g", (uint32_t) g); + element.AddAttribute ("b", (uint32_t) b); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateNodeDescription (uint32_t nodeId) +{ + AnimXmlElement element ("nu"); + element.AddAttribute ("p", "d"); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("id", nodeId); + if (m_nodeDescriptions.find (nodeId) != m_nodeDescriptions.end ()) + { + element.AddAttribute ("descr", m_nodeDescriptions[nodeId], true); + } + WriteN (element.ToString (), m_f); +} + + +void +AnimationInterface::WriteXmlUpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counterValue) +{ + AnimXmlElement element ("nc"); + element.AddAttribute ("c", nodeCounterId); + element.AddAttribute ("i", nodeId); + element.AddAttribute ("t", Simulator::Now ().GetSeconds ()); + element.AddAttribute ("v", counterValue); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity) +{ + AnimXmlElement element ("bg"); + element.AddAttribute ("f", fileName); + element.AddAttribute ("x", x); + element.AddAttribute ("y", y); + element.AddAttribute ("sx", scaleX); + element.AddAttribute ("sy", scaleY); + element.AddAttribute ("o", opacity); + WriteN (element.ToString (), m_f); +} + +void +AnimationInterface::WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipAddress, std::string channelType) +{ + AnimXmlElement element ("nonp2plinkproperties"); + element.AddAttribute ("id", id); + element.AddAttribute ("ipAddress", ipAddress); + element.AddAttribute ("channelType", channelType); + WriteN (element.ToString (), m_f); +} + + + +/***** AnimXmlElement *****/ + +AnimationInterface::AnimXmlElement::AnimXmlElement(std::string tagName, bool emptyElement) : + m_tagName(tagName), + m_text("") +{ +} + +template +void +AnimationInterface::AnimXmlElement::AddAttribute(std::string attribute, T value, bool xmlEscape) +{ + std::ostringstream oss; + oss << std::setprecision(10); + oss << value; + std::string attributeString = attribute.c_str(); + if (xmlEscape) + { + attributeString += "=\""; + std::string valueStr = oss.str(); + for (std::string::iterator it = valueStr.begin(); it != valueStr.end(); ++it) + { + switch (*it) + { + case '&': + attributeString += "&"; + break; + case '\"': + attributeString += """; + break; + case '\'': + attributeString += "'"; + break; + case '<': + attributeString += "<"; + break; + case '>': + attributeString += ">"; + break; + default: + attributeString += *it; + break; + } + } + attributeString += "\" "; + } + else + { + attributeString += "=\"" + oss.str() + "\" "; + } + m_attributes.push_back(attributeString); +} + +void +AnimationInterface::AnimXmlElement::AppendChild(AnimXmlElement e) +{ + m_children.push_back(e.ToString()); +} + +void +AnimationInterface::AnimXmlElement::SetText(std::string text) +{ + m_text = text; +} + +std::string +AnimationInterface::AnimXmlElement::ToString(bool autoClose) +{ + std::string elementString = "<" + m_tagName + " "; + + + for (std::vector::const_iterator i = m_attributes.begin(); + i != m_attributes.end(); + ++i) + { + elementString += *i; + } + if (m_children.empty() && m_text.empty()) + { + if (autoClose) + { + elementString += "/>"; + } + } + else + { + elementString += ">"; + if (!m_text.empty()) + { + elementString += m_text; + } + if (!m_children.empty()) + { + elementString += "\n"; + for (std::vector::const_iterator i = m_children.begin(); + i != m_children.end(); + ++i) + { + elementString += *i + "\n"; + } + + } + if (autoClose) + { + elementString += ""; + } + } + + + return elementString + ((autoClose) ?"\n": ""); +} + + + + + +/***** AnimByteTag *****/ + +TypeId +AnimByteTag::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::AnimByteTag") + .SetParent () + .SetGroupName ("NetAnim") + .AddConstructor () + ; + return tid; +} + +TypeId +AnimByteTag::GetInstanceTypeId (void) const +{ + return GetTypeId (); +} + +uint32_t +AnimByteTag::GetSerializedSize (void) const +{ + return sizeof (uint64_t); +} + +void +AnimByteTag::Serialize (TagBuffer i) const +{ + i.WriteU64 (m_AnimUid); +} + +void +AnimByteTag::Deserialize (TagBuffer i) +{ + m_AnimUid = i.ReadU64 (); +} + +void +AnimByteTag::Print (std::ostream &os) const +{ + os << "AnimUid=" << m_AnimUid; +} + +void +AnimByteTag::Set (uint64_t AnimUid) +{ + m_AnimUid = AnimUid; +} + +uint64_t +AnimByteTag::Get (void) const +{ + return m_AnimUid; +} + +AnimationInterface::AnimPacketInfo::AnimPacketInfo () + : m_txnd (0), + m_txNodeId (0), + m_fbTx (0), + m_lbTx (0), + m_lbRx (0) +{ +} + +AnimationInterface::AnimPacketInfo::AnimPacketInfo (const AnimPacketInfo & pInfo) +{ + m_txnd = pInfo.m_txnd; + m_txNodeId = pInfo.m_txNodeId; + m_fbTx = pInfo.m_fbTx; + m_lbTx = pInfo.m_lbTx; + m_lbRx = pInfo.m_lbRx; +} + +AnimationInterface::AnimPacketInfo::AnimPacketInfo (Ptr txnd, + const Time fbTx, + uint32_t txNodeId) + : m_txnd (txnd), + m_txNodeId (0), + m_fbTx (fbTx.GetSeconds ()), + m_lbTx (0), + m_lbRx (0) +{ + if (!m_txnd) + m_txNodeId = txNodeId; +} + +void +AnimationInterface::AnimPacketInfo::ProcessRxBegin (Ptr nd, const double fbRx) +{ + Ptr n = nd->GetNode (); + m_fbRx = fbRx; + m_rxnd = nd; +} + +} // namespace ns3 From d795a4bb47c3e2e545b1dc113cbaf0c557b364d4 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 11:10:25 -0700 Subject: [PATCH 044/551] aodv: Fix various coding style issues --- src/aodv/model/aodv-dpd.cc | 6 +- src/aodv/model/aodv-id-cache.cc | 18 +- src/aodv/model/aodv-neighbor.cc | 62 ++-- src/aodv/model/aodv-packet.cc | 128 +++++--- src/aodv/model/aodv-routing-protocol.cc | 414 ++++++++++++++---------- src/aodv/model/aodv-rqueue.cc | 31 +- src/aodv/model/aodv-rtable.cc | 90 ++++-- 7 files changed, 454 insertions(+), 295 deletions(-) diff --git a/src/aodv/model/aodv-dpd.cc b/src/aodv/model/aodv-dpd.cc index 73ca2c07137..9350533d448 100644 --- a/src/aodv/model/aodv-dpd.cc +++ b/src/aodv/model/aodv-dpd.cc @@ -22,10 +22,8 @@ #include "aodv-dpd.h" -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { bool DuplicatePacketDetection::IsDuplicate (Ptr p, const Ipv4Header & header) diff --git a/src/aodv/model/aodv-id-cache.cc b/src/aodv/model/aodv-id-cache.cc index fae34e976c3..bc7135f6b62 100644 --- a/src/aodv/model/aodv-id-cache.cc +++ b/src/aodv/model/aodv-id-cache.cc @@ -28,20 +28,24 @@ #include "aodv-id-cache.h" #include -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { bool IdCache::IsDuplicate (Ipv4Address addr, uint32_t id) { Purge (); for (std::vector::const_iterator i = m_idCache.begin (); i != m_idCache.end (); ++i) - if (i->m_context == addr && i->m_id == id) - return true; + { + if (i->m_context == addr && i->m_id == id) + { + return true; + } + } struct UniqueId uniqueId = - { addr, id, m_lifetime + Simulator::Now () }; + { + addr, id, m_lifetime + Simulator::Now () + }; m_idCache.push_back (uniqueId); return false; } diff --git a/src/aodv/model/aodv-neighbor.cc b/src/aodv/model/aodv-neighbor.cc index 090d5964721..0f894fb6cd5 100644 --- a/src/aodv/model/aodv-neighbor.cc +++ b/src/aodv/model/aodv-neighbor.cc @@ -31,15 +31,13 @@ #include -namespace ns3 -{ - +namespace ns3 { + NS_LOG_COMPONENT_DEFINE ("AodvNeighbors"); -namespace aodv -{ -Neighbors::Neighbors (Time delay) : - m_ntimer (Timer::CANCEL_ON_DESTROY) +namespace aodv { +Neighbors::Neighbors (Time delay) + : m_ntimer (Timer::CANCEL_ON_DESTROY) { m_ntimer.SetDelay (delay); m_ntimer.SetFunction (&Neighbors::Purge, this); @@ -54,7 +52,9 @@ Neighbors::IsNeighbor (Ipv4Address addr) i != m_nb.end (); ++i) { if (i->m_neighborAddress == addr) - return true; + { + return true; + } } return false; } @@ -67,7 +67,9 @@ Neighbors::GetExpireTime (Ipv4Address addr) != m_nb.end (); ++i) { if (i->m_neighborAddress == addr) - return (i->m_expireTime - Simulator::Now ()); + { + return (i->m_expireTime - Simulator::Now ()); + } } return Seconds (0); } @@ -76,14 +78,18 @@ void Neighbors::Update (Ipv4Address addr, Time expire) { for (std::vector::iterator i = m_nb.begin (); i != m_nb.end (); ++i) - if (i->m_neighborAddress == addr) - { - i->m_expireTime - = std::max (expire + Simulator::Now (), i->m_expireTime); - if (i->m_hardwareAddress == Mac48Address ()) - i->m_hardwareAddress = LookupMacAddress (i->m_neighborAddress); - return; - } + { + if (i->m_neighborAddress == addr) + { + i->m_expireTime + = std::max (expire + Simulator::Now (), i->m_expireTime); + if (i->m_hardwareAddress == Mac48Address ()) + { + i->m_hardwareAddress = LookupMacAddress (i->m_neighborAddress); + } + return; + } + } NS_LOG_LOGIC ("Open link to " << addr); Neighbor neighbor (addr, LookupMacAddress (addr), expire + Simulator::Now ()); @@ -91,8 +97,17 @@ Neighbors::Update (Ipv4Address addr, Time expire) Purge (); } +/** + * \brief CloseNeighbor structure + */ struct CloseNeighbor { + /** + * Check if the entry is expired + * + * \param nb Neighbors::Neighbor entry + * \return true if expired, false otherwise + */ bool operator() (const Neighbors::Neighbor & nb) const { return ((nb.m_expireTime < Simulator::Now ()) || nb.close); @@ -103,7 +118,9 @@ void Neighbors::Purge () { if (m_nb.empty ()) - return; + { + return; + } CloseNeighbor pred; if (!m_handleLinkFailure.IsNull ()) @@ -166,10 +183,13 @@ Neighbors::ProcessTxError (WifiMacHeader const & hdr) for (std::vector::iterator i = m_nb.begin (); i != m_nb.end (); ++i) { if (i->m_hardwareAddress == addr) - i->close = true; + { + i->close = true; + } } Purge (); } -} -} + +} // namespace aodv +} // namespace ns3 diff --git a/src/aodv/model/aodv-packet.cc b/src/aodv/model/aodv-packet.cc index 6471a283a19..4a54a2ecd17 100644 --- a/src/aodv/model/aodv-packet.cc +++ b/src/aodv/model/aodv-packet.cc @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -29,15 +29,14 @@ #include "ns3/address-utils.h" #include "ns3/packet.h" -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { NS_OBJECT_ENSURE_REGISTERED (TypeHeader); -TypeHeader::TypeHeader (MessageType t) : - m_type (t), m_valid (true) +TypeHeader::TypeHeader (MessageType t) + : m_type (t), + m_valid (true) { } @@ -46,7 +45,7 @@ TypeHeader::GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::TypeHeader") .SetParent
() - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; @@ -141,9 +140,15 @@ operator<< (std::ostream & os, TypeHeader const & h) // RREQ //----------------------------------------------------------------------------- RreqHeader::RreqHeader (uint8_t flags, uint8_t reserved, uint8_t hopCount, uint32_t requestID, Ipv4Address dst, - uint32_t dstSeqNo, Ipv4Address origin, uint32_t originSeqNo) : - m_flags (flags), m_reserved (reserved), m_hopCount (hopCount), m_requestID (requestID), m_dst (dst), - m_dstSeqNo (dstSeqNo), m_origin (origin), m_originSeqNo (originSeqNo) + uint32_t dstSeqNo, Ipv4Address origin, uint32_t originSeqNo) + : m_flags (flags), + m_reserved (reserved), + m_hopCount (hopCount), + m_requestID (requestID), + m_dst (dst), + m_dstSeqNo (dstSeqNo), + m_origin (origin), + m_originSeqNo (originSeqNo) { } @@ -154,7 +159,7 @@ RreqHeader::GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::RreqHeader") .SetParent
() - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; @@ -225,9 +230,13 @@ void RreqHeader::SetGratiousRrep (bool f) { if (f) - m_flags |= (1 << 5); + { + m_flags |= (1 << 5); + } else - m_flags &= ~(1 << 5); + { + m_flags &= ~(1 << 5); + } } bool @@ -240,9 +249,13 @@ void RreqHeader::SetDestinationOnly (bool f) { if (f) - m_flags |= (1 << 4); + { + m_flags |= (1 << 4); + } else - m_flags &= ~(1 << 4); + { + m_flags &= ~(1 << 4); + } } bool @@ -255,9 +268,13 @@ void RreqHeader::SetUnknownSeqno (bool f) { if (f) - m_flags |= (1 << 3); + { + m_flags |= (1 << 3); + } else - m_flags &= ~(1 << 3); + { + m_flags &= ~(1 << 3); + } } bool @@ -269,10 +286,10 @@ RreqHeader::GetUnknownSeqno () const bool RreqHeader::operator== (RreqHeader const & o) const { - return (m_flags == o.m_flags && m_reserved == o.m_reserved && - m_hopCount == o.m_hopCount && m_requestID == o.m_requestID && - m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo && - m_origin == o.m_origin && m_originSeqNo == o.m_originSeqNo); + return (m_flags == o.m_flags && m_reserved == o.m_reserved + && m_hopCount == o.m_hopCount && m_requestID == o.m_requestID + && m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo + && m_origin == o.m_origin && m_originSeqNo == o.m_originSeqNo); } //----------------------------------------------------------------------------- @@ -280,9 +297,13 @@ RreqHeader::operator== (RreqHeader const & o) const //----------------------------------------------------------------------------- RrepHeader::RrepHeader (uint8_t prefixSize, uint8_t hopCount, Ipv4Address dst, - uint32_t dstSeqNo, Ipv4Address origin, Time lifeTime) : - m_flags (0), m_prefixSize (prefixSize), m_hopCount (hopCount), - m_dst (dst), m_dstSeqNo (dstSeqNo), m_origin (origin) + uint32_t dstSeqNo, Ipv4Address origin, Time lifeTime) + : m_flags (0), + m_prefixSize (prefixSize), + m_hopCount (hopCount), + m_dst (dst), + m_dstSeqNo (dstSeqNo), + m_origin (origin) { m_lifeTime = uint32_t (lifeTime.GetMilliSeconds ()); } @@ -294,7 +315,7 @@ RrepHeader::GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::RrepHeader") .SetParent
() - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; @@ -371,9 +392,13 @@ void RrepHeader::SetAckRequired (bool f) { if (f) - m_flags |= (1 << 6); + { + m_flags |= (1 << 6); + } else - m_flags &= ~(1 << 6); + { + m_flags &= ~(1 << 6); + } } bool @@ -397,9 +422,9 @@ RrepHeader::GetPrefixSize () const bool RrepHeader::operator== (RrepHeader const & o) const { - return (m_flags == o.m_flags && m_prefixSize == o.m_prefixSize && - m_hopCount == o.m_hopCount && m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo && - m_origin == o.m_origin && m_lifeTime == o.m_lifeTime); + return (m_flags == o.m_flags && m_prefixSize == o.m_prefixSize + && m_hopCount == o.m_hopCount && m_dst == o.m_dst && m_dstSeqNo == o.m_dstSeqNo + && m_origin == o.m_origin && m_lifeTime == o.m_lifeTime); } void @@ -425,19 +450,19 @@ operator<< (std::ostream & os, RrepHeader const & h) // RREP-ACK //----------------------------------------------------------------------------- -RrepAckHeader::RrepAckHeader () : - m_reserved (0) +RrepAckHeader::RrepAckHeader () + : m_reserved (0) { } NS_OBJECT_ENSURE_REGISTERED (RrepAckHeader); - + TypeId RrepAckHeader::GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::RrepAckHeader") .SetParent
() - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; @@ -492,8 +517,9 @@ operator<< (std::ostream & os, RrepAckHeader const & h ) //----------------------------------------------------------------------------- // RERR //----------------------------------------------------------------------------- -RerrHeader::RerrHeader () : - m_flag (0), m_reserved (0) +RerrHeader::RerrHeader () + : m_flag (0), + m_reserved (0) { } @@ -504,7 +530,7 @@ RerrHeader::GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::RerrHeader") .SetParent
() - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; @@ -574,9 +600,13 @@ void RerrHeader::SetNoDelete (bool f ) { if (f) - m_flag |= (1 << 0); + { + m_flag |= (1 << 0); + } else - m_flag &= ~(1 << 0); + { + m_flag &= ~(1 << 0); + } } bool @@ -589,7 +619,9 @@ bool RerrHeader::AddUnDestination (Ipv4Address dst, uint32_t seqNo ) { if (m_unreachableDstSeqNo.find (dst) != m_unreachableDstSeqNo.end ()) - return true; + { + return true; + } NS_ASSERT (GetDestCount () < 255); // can't support more than 255 destinations in single RERR m_unreachableDstSeqNo.insert (std::make_pair (dst, seqNo)); @@ -600,7 +632,9 @@ bool RerrHeader::RemoveUnDestination (std::pair & un ) { if (m_unreachableDstSeqNo.empty ()) - return false; + { + return false; + } std::map::iterator i = m_unreachableDstSeqNo.begin (); un = *i; m_unreachableDstSeqNo.erase (i); @@ -619,14 +653,18 @@ bool RerrHeader::operator== (RerrHeader const & o ) const { if (m_flag != o.m_flag || m_reserved != o.m_reserved || GetDestCount () != o.GetDestCount ()) - return false; + { + return false; + } std::map::const_iterator j = m_unreachableDstSeqNo.begin (); std::map::const_iterator k = o.m_unreachableDstSeqNo.begin (); for (uint8_t i = 0; i < GetDestCount (); ++i) { if ((j->first != k->first) || (j->second != k->second)) - return false; + { + return false; + } j++; k++; diff --git a/src/aodv/model/aodv-routing-protocol.cc b/src/aodv/model/aodv-routing-protocol.cc index 5082f7d4e64..6d627e37a0f 100644 --- a/src/aodv/model/aodv-routing-protocol.cc +++ b/src/aodv/model/aodv-routing-protocol.cc @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -26,7 +26,7 @@ * Pavel Boyko */ #define NS_LOG_APPEND_CONTEXT \ - if (m_ipv4) { std::clog << "[node " << m_ipv4->GetObject ()->GetId () << "] "; } + if (m_ipv4) { std::clog << "[node " << m_ipv4->GetObject ()->GetId () << "] "; } #include "aodv-routing-protocol.h" #include "ns3/log.h" @@ -44,48 +44,66 @@ #include #include -namespace ns3 -{ +namespace ns3 { NS_LOG_COMPONENT_DEFINE ("AodvRoutingProtocol"); -namespace aodv -{ +namespace aodv { NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol); /// UDP Port for AODV control traffic const uint32_t RoutingProtocol::AODV_PORT = 654; -//----------------------------------------------------------------------------- -/// Tag used by AODV implementation - +/** +* \ingroup aodv +* \brief Tag used by AODV implementation +*/ class DeferredRouteOutputTag : public Tag { public: - DeferredRouteOutputTag (int32_t o = -1) : Tag (), m_oif (o) {} + /** + * \brief Constructor + * \param o the output interface + */ + DeferredRouteOutputTag (int32_t o = -1) : Tag (), + m_oif (o) + { + } + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId () { static TypeId tid = TypeId ("ns3::aodv::DeferredRouteOutputTag") .SetParent () - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () ; return tid; } - TypeId GetInstanceTypeId () const + TypeId GetInstanceTypeId () const { return GetTypeId (); } - int32_t GetInterface() const + /** + * \brief Get the output interface + * \return the output interface + */ + int32_t GetInterface () const { return m_oif; } - void SetInterface(int32_t oif) + /** + * \brief Set the output interface + * \param oif the output interface + */ + void SetInterface (int32_t oif) { m_oif = oif; } @@ -119,43 +137,43 @@ NS_OBJECT_ENSURE_REGISTERED (DeferredRouteOutputTag); //----------------------------------------------------------------------------- -RoutingProtocol::RoutingProtocol () : - m_rreqRetries (2), - m_ttlStart (1), - m_ttlIncrement (2), - m_ttlThreshold (7), - m_timeoutBuffer (2), - m_rreqRateLimit (10), - m_rerrRateLimit (10), - m_activeRouteTimeout (Seconds (3)), - m_netDiameter (35), - m_nodeTraversalTime (MilliSeconds (40)), - m_netTraversalTime (Time ((2 * m_netDiameter) * m_nodeTraversalTime)), - m_pathDiscoveryTime ( Time (2 * m_netTraversalTime)), - m_myRouteTimeout (Time (2 * std::max (m_pathDiscoveryTime, m_activeRouteTimeout))), - m_helloInterval (Seconds (1)), - m_allowedHelloLoss (2), - m_deletePeriod (Time (5 * std::max (m_activeRouteTimeout, m_helloInterval))), - m_nextHopWait (m_nodeTraversalTime + MilliSeconds (10)), - m_blackListTimeout (Time (m_rreqRetries * m_netTraversalTime)), - m_maxQueueLen (64), - m_maxQueueTime (Seconds (30)), - m_destinationOnly (false), - m_gratuitousReply (true), - m_enableHello (false), - m_routingTable (m_deletePeriod), - m_queue (m_maxQueueLen, m_maxQueueTime), - m_requestId (0), - m_seqNo (0), - m_rreqIdCache (m_pathDiscoveryTime), - m_dpd (m_pathDiscoveryTime), - m_nb (m_helloInterval), - m_rreqCount (0), - m_rerrCount (0), - m_htimer (Timer::CANCEL_ON_DESTROY), - m_rreqRateLimitTimer (Timer::CANCEL_ON_DESTROY), - m_rerrRateLimitTimer (Timer::CANCEL_ON_DESTROY), - m_lastBcastTime (Seconds (0)) +RoutingProtocol::RoutingProtocol () + : m_rreqRetries (2), + m_ttlStart (1), + m_ttlIncrement (2), + m_ttlThreshold (7), + m_timeoutBuffer (2), + m_rreqRateLimit (10), + m_rerrRateLimit (10), + m_activeRouteTimeout (Seconds (3)), + m_netDiameter (35), + m_nodeTraversalTime (MilliSeconds (40)), + m_netTraversalTime (Time ((2 * m_netDiameter) * m_nodeTraversalTime)), + m_pathDiscoveryTime ( Time (2 * m_netTraversalTime)), + m_myRouteTimeout (Time (2 * std::max (m_pathDiscoveryTime, m_activeRouteTimeout))), + m_helloInterval (Seconds (1)), + m_allowedHelloLoss (2), + m_deletePeriod (Time (5 * std::max (m_activeRouteTimeout, m_helloInterval))), + m_nextHopWait (m_nodeTraversalTime + MilliSeconds (10)), + m_blackListTimeout (Time (m_rreqRetries * m_netTraversalTime)), + m_maxQueueLen (64), + m_maxQueueTime (Seconds (30)), + m_destinationOnly (false), + m_gratuitousReply (true), + m_enableHello (false), + m_routingTable (m_deletePeriod), + m_queue (m_maxQueueLen, m_maxQueueTime), + m_requestId (0), + m_seqNo (0), + m_rreqIdCache (m_pathDiscoveryTime), + m_dpd (m_pathDiscoveryTime), + m_nb (m_helloInterval), + m_rreqCount (0), + m_rerrCount (0), + m_htimer (Timer::CANCEL_ON_DESTROY), + m_rreqRateLimitTimer (Timer::CANCEL_ON_DESTROY), + m_rerrRateLimitTimer (Timer::CANCEL_ON_DESTROY), + m_lastBcastTime (Seconds (0)) { m_nb.SetCallback (MakeCallback (&RoutingProtocol::SendRerrWhenBreaksLinkToNextHop, this)); } @@ -165,7 +183,7 @@ RoutingProtocol::GetTypeId (void) { static TypeId tid = TypeId ("ns3::aodv::RoutingProtocol") .SetParent () - .SetGroupName("Aodv") + .SetGroupName ("Aodv") .AddConstructor () .AddAttribute ("HelloInterval", "HELLO messages emission interval.", TimeValue (Seconds (1)), @@ -321,7 +339,7 @@ void RoutingProtocol::PrintRoutingTable (Ptr stream, Time::Unit unit) const { *stream->GetStream () << "Node: " << m_ipv4->GetObject ()->GetId () - << "; Time: " << Now().As (unit) + << "; Time: " << Now ().As (unit) << ", Local time: " << GetObject ()->GetLocalTime ().As (unit) << ", AODV Routing table" << std::endl; @@ -362,7 +380,7 @@ RoutingProtocol::RouteOutput (Ptr p, const Ipv4Header &header, NS_LOG_FUNCTION (this << header << (oif ? oif->GetIfIndex () : 0)); if (!p) { - NS_LOG_DEBUG("Packet is == 0"); + NS_LOG_DEBUG ("Packet is == 0"); return LoopbackRoute (header, oif); // later } if (m_socketAddresses.empty ()) @@ -392,8 +410,8 @@ RoutingProtocol::RouteOutput (Ptr p, const Ipv4Header &header, return route; } - // Valid route not found, in this case we return loopback. - // Actual route request will be deferred until packet will be fully formed, + // Valid route not found, in this case we return loopback. + // Actual route request will be deferred until packet will be fully formed, // routed to loopback, received from loopback and passed to RouteInput (see below) uint32_t iif = (oif ? m_ipv4->GetInterfaceForDevice (oif) : -1); DeferredRouteOutputTag tag (iif); @@ -406,7 +424,7 @@ RoutingProtocol::RouteOutput (Ptr p, const Ipv4Header &header, } void -RoutingProtocol::DeferredRouteOutput (Ptr p, const Ipv4Header & header, +RoutingProtocol::DeferredRouteOutput (Ptr p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb) { NS_LOG_FUNCTION (this << p << header); @@ -419,9 +437,9 @@ RoutingProtocol::DeferredRouteOutput (Ptr p, const Ipv4Header & he NS_LOG_LOGIC ("Add packet " << p->GetUid () << " to queue. Protocol " << (uint16_t) header.GetProtocol ()); RoutingTableEntry rt; bool result = m_routingTable.LookupRoute (header.GetDestination (), rt); - if(!result || ((rt.GetFlag () != IN_SEARCH) && result)) + if (!result || ((rt.GetFlag () != IN_SEARCH) && result)) { - NS_LOG_LOGIC ("Send new RREQ for outbound packet to " < p, const Ipv4Header &header, // Duplicate of own packet if (IsMyOwnAddress (origin)) - return true; + { + return true; + } // AODV is not a multicast routing protocol if (dst.IsMulticast ()) { - return false; + return false; } // Broadcast local delivery/forwarding @@ -474,60 +494,62 @@ RoutingProtocol::RouteInput (Ptr p, const Ipv4Header &header, { Ipv4InterfaceAddress iface = j->second; if (m_ipv4->GetInterfaceForAddress (iface.GetLocal ()) == iif) - if (dst == iface.GetBroadcast () || dst.IsBroadcast ()) - { - if (m_dpd.IsDuplicate (p, header)) - { - NS_LOG_DEBUG ("Duplicated packet " << p->GetUid () << " from " << origin << ". Drop."); - return true; - } - UpdateRouteLifeTime (origin, m_activeRouteTimeout); - Ptr packet = p->Copy (); - if (lcb.IsNull () == false) - { - NS_LOG_LOGIC ("Broadcast local delivery to " << iface.GetLocal ()); - lcb (p, header, iif); - // Fall through to additional processing - } - else - { - NS_LOG_ERROR ("Unable to deliver packet locally due to null callback " << p->GetUid () << " from " << origin); - ecb (p, header, Socket::ERROR_NOROUTETOHOST); - } - if (!m_enableBroadcast) - { - return true; - } - if (header.GetProtocol () == UdpL4Protocol::PROT_NUMBER) - { - UdpHeader udpHeader; - p->PeekHeader (udpHeader); - if (udpHeader.GetDestinationPort () == AODV_PORT) - { - // AODV packets sent in broadcast are already managed - return true; - } - } - if (header.GetTtl () > 1) - { - NS_LOG_LOGIC ("Forward broadcast. TTL " << (uint16_t) header.GetTtl ()); - RoutingTableEntry toBroadcast; - if (m_routingTable.LookupRoute (dst, toBroadcast)) - { - Ptr route = toBroadcast.GetRoute (); - ucb (route, packet, header); - } - else - { - NS_LOG_DEBUG ("No route to forward broadcast. Drop packet " << p->GetUid ()); - } - } - else - { - NS_LOG_DEBUG ("TTL exceeded. Drop packet " << p->GetUid ()); - } - return true; - } + { + if (dst == iface.GetBroadcast () || dst.IsBroadcast ()) + { + if (m_dpd.IsDuplicate (p, header)) + { + NS_LOG_DEBUG ("Duplicated packet " << p->GetUid () << " from " << origin << ". Drop."); + return true; + } + UpdateRouteLifeTime (origin, m_activeRouteTimeout); + Ptr packet = p->Copy (); + if (lcb.IsNull () == false) + { + NS_LOG_LOGIC ("Broadcast local delivery to " << iface.GetLocal ()); + lcb (p, header, iif); + // Fall through to additional processing + } + else + { + NS_LOG_ERROR ("Unable to deliver packet locally due to null callback " << p->GetUid () << " from " << origin); + ecb (p, header, Socket::ERROR_NOROUTETOHOST); + } + if (!m_enableBroadcast) + { + return true; + } + if (header.GetProtocol () == UdpL4Protocol::PROT_NUMBER) + { + UdpHeader udpHeader; + p->PeekHeader (udpHeader); + if (udpHeader.GetDestinationPort () == AODV_PORT) + { + // AODV packets sent in broadcast are already managed + return true; + } + } + if (header.GetTtl () > 1) + { + NS_LOG_LOGIC ("Forward broadcast. TTL " << (uint16_t) header.GetTtl ()); + RoutingTableEntry toBroadcast; + if (m_routingTable.LookupRoute (dst, toBroadcast)) + { + Ptr route = toBroadcast.GetRoute (); + ucb (route, packet, header); + } + else + { + NS_LOG_DEBUG ("No route to forward broadcast. Drop packet " << p->GetUid ()); + } + } + else + { + NS_LOG_DEBUG ("TTL exceeded. Drop packet " << p->GetUid ()); + } + return true; + } + } } // Unicast local delivery @@ -579,7 +601,7 @@ RoutingProtocol::Forwarding (Ptr p, const Ipv4Header & header, if (toDst.GetFlag () == VALID) { Ptr route = toDst.GetRoute (); - NS_LOG_LOGIC (route->GetSource ()<<" forwarding to " << dst << " from " << origin << " packet " << p->GetUid ()); + NS_LOG_LOGIC (route->GetSource () << " forwarding to " << dst << " from " << origin << " packet " << p->GetUid ()); /* * Each time a route is used to forward a data packet, its Active Route @@ -615,7 +637,7 @@ RoutingProtocol::Forwarding (Ptr p, const Ipv4Header & header, } } } - NS_LOG_LOGIC ("route not found to "<< dst << ". Send RERR message."); + NS_LOG_LOGIC ("route not found to " << dst << ". Send RERR message."); NS_LOG_DEBUG ("Drop packet " << p->GetUid () << " because no route to forward it."); SendRerrWhenNoRouteToForward (dst, 0, origin); return false; @@ -654,8 +676,10 @@ RoutingProtocol::NotifyInterfaceUp (uint32_t i) } Ipv4InterfaceAddress iface = l3->GetAddress (i, 0); if (iface.GetLocal () == Ipv4Address ("127.0.0.1")) - return; - + { + return; + } + // Create a socket to listen only on this interface Ptr socket = Socket::CreateSocket (GetObject (), UdpSocketFactory::GetTypeId ()); @@ -692,10 +716,14 @@ RoutingProtocol::NotifyInterfaceUp (uint32_t i) // Allow neighbor manager use this interface for layer 2 feedback if possible Ptr wifi = dev->GetObject (); if (wifi == 0) - return; + { + return; + } Ptr mac = wifi->GetMac (); if (mac == 0) - return; + { + return; + } mac->TraceConnectWithoutContext ("TxErrHeader", m_nb.GetTxErrorCallback ()); } @@ -720,7 +748,7 @@ RoutingProtocol::NotifyInterfaceDown (uint32_t i) } } - // Close socket + // Close socket Ptr socket = FindSocketWithInterfaceAddress (m_ipv4->GetAddress (i, 0)); NS_ASSERT (socket); socket->Close (); @@ -749,7 +777,9 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, Ipv4InterfaceAddress address) NS_LOG_FUNCTION (this << " interface " << i << " address " << address); Ptr l3 = m_ipv4->GetObject (); if (!l3->IsUp (i)) - return; + { + return; + } if (l3->GetNAddresses (i) == 1) { Ipv4InterfaceAddress iface = l3->GetAddress (i, 0); @@ -757,7 +787,9 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, Ipv4InterfaceAddress address) if (!socket) { if (iface.GetLocal () == Ipv4Address ("127.0.0.1")) - return; + { + return; + } // Create a socket to listen only on this interface Ptr socket = Socket::CreateSocket (GetObject (), UdpSocketFactory::GetTypeId ()); @@ -770,7 +802,7 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, Ipv4InterfaceAddress address) // create also a subnet directed broadcast socket socket = Socket::CreateSocket (GetObject (), - UdpSocketFactory::GetTypeId ()); + UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); @@ -830,7 +862,7 @@ RoutingProtocol::NotifyRemoveAddress (uint32_t i, Ipv4InterfaceAddress address) // create also a unicast socket socket = Socket::CreateSocket (GetObject (), - UdpSocketFactory::GetTypeId ()); + UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); @@ -876,7 +908,7 @@ RoutingProtocol::IsMyOwnAddress (Ipv4Address src) return false; } -Ptr +Ptr RoutingProtocol::LoopbackRoute (const Ipv4Header & hdr, Ptr oif) const { NS_LOG_FUNCTION (this << hdr); @@ -896,7 +928,7 @@ RoutingProtocol::LoopbackRoute (const Ipv4Header & hdr, Ptr oif) cons // For single interface, single address nodes, this is not a problem. // When there are possibly multiple outgoing interfaces, the policy // implemented here is to pick the first available AODV interface. - // If RouteOutput() caller specified an outgoing interface, that + // If RouteOutput() caller specified an outgoing interface, that // further constrains the selection of source address // std::map, Ipv4InterfaceAddress>::const_iterator j = m_socketAddresses.begin (); @@ -936,7 +968,9 @@ RoutingProtocol::SendRequest (Ipv4Address dst) return; } else - m_rreqCount++; + { + m_rreqCount++; + } // Create RREQ header RreqHeader rreqHeader; rreqHeader.SetDst (dst); @@ -954,14 +988,22 @@ RoutingProtocol::SendRequest (Ipv4Address dst) { ttl = rt.GetHop () + m_ttlIncrement; if (ttl > m_ttlThreshold) - ttl = m_netDiameter; + { + ttl = m_netDiameter; + } } if (ttl == m_netDiameter) - rt.IncrementRreqCnt (); + { + rt.IncrementRreqCnt (); + } if (rt.GetValidSeqNo ()) - rreqHeader.SetDstSeqno (rt.GetSeqNo ()); + { + rreqHeader.SetDstSeqno (rt.GetSeqNo ()); + } else - rreqHeader.SetUnknownSeqno (true); + { + rreqHeader.SetUnknownSeqno (true); + } rt.SetHop (ttl); rt.SetFlag (IN_SEARCH); rt.SetLifeTime (m_pathDiscoveryTime); @@ -976,15 +1018,21 @@ RoutingProtocol::SendRequest (Ipv4Address dst) /*nextHop=*/ Ipv4Address (), /*lifeTime=*/ m_pathDiscoveryTime); // Check if TtlStart == NetDiameter if (ttl == m_netDiameter) - newEntry.IncrementRreqCnt (); + { + newEntry.IncrementRreqCnt (); + } newEntry.SetFlag (IN_SEARCH); m_routingTable.AddRoute (newEntry); } if (m_gratuitousReply) - rreqHeader.SetGratiousRrep (true); + { + rreqHeader.SetGratiousRrep (true); + } if (m_destinationOnly) - rreqHeader.SetDestinationOnly (true); + { + rreqHeader.SetDestinationOnly (true); + } m_seqNo++; rreqHeader.SetOriginSeqno (m_seqNo); @@ -1015,12 +1063,12 @@ RoutingProtocol::SendRequest (Ipv4Address dst) destination = Ipv4Address ("255.255.255.255"); } else - { + { destination = iface.GetBroadcast (); } NS_LOG_DEBUG ("Send RREQ with id " << rreqHeader.GetId () << " to socket"); m_lastBcastTime = Simulator::Now (); - Simulator::Schedule (Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))), &RoutingProtocol::SendTo, this, socket, packet, destination); + Simulator::Schedule (Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))), &RoutingProtocol::SendTo, this, socket, packet, destination); } ScheduleRreqRetry (dst); } @@ -1028,7 +1076,7 @@ RoutingProtocol::SendRequest (Ipv4Address dst) void RoutingProtocol::SendTo (Ptr socket, Ptr packet, Ipv4Address destination) { - socket->SendTo (packet, 0, InetSocketAddress (destination, AODV_PORT)); + socket->SendTo (packet, 0, InetSocketAddress (destination, AODV_PORT)); } void @@ -1073,7 +1121,7 @@ RoutingProtocol::RecvAodv (Ptr socket) { receiver = m_socketAddresses[socket].GetLocal (); } - else if(m_socketSubnetBroadcastAddresses.find (socket) != m_socketSubnetBroadcastAddresses.end ()) + else if (m_socketSubnetBroadcastAddresses.find (socket) != m_socketSubnetBroadcastAddresses.end ()) { receiver = m_socketSubnetBroadcastAddresses[socket].GetLocal (); } @@ -1225,10 +1273,14 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s if (toOrigin.GetValidSeqNo ()) { if (int32_t (rreqHeader.GetOriginSeqno ()) - int32_t (toOrigin.GetSeqNo ()) > 0) - toOrigin.SetSeqNo (rreqHeader.GetOriginSeqno ()); + { + toOrigin.SetSeqNo (rreqHeader.GetOriginSeqno ()); + } } else - toOrigin.SetSeqNo (rreqHeader.GetOriginSeqno ()); + { + toOrigin.SetSeqNo (rreqHeader.GetOriginSeqno ()); + } toOrigin.SetValidSeqNo (true); toOrigin.SetNextHop (src); toOrigin.SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver))); @@ -1244,18 +1296,18 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s RoutingTableEntry toNeighbor; if (!m_routingTable.LookupRoute (src, toNeighbor)) { - NS_LOG_DEBUG ("Neighbor:" << src << " not found in routing table. Creating an entry"); + NS_LOG_DEBUG ("Neighbor:" << src << " not found in routing table. Creating an entry"); Ptr dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver)); RoutingTableEntry newEntry (dev, src, false, rreqHeader.GetOriginSeqno (), - m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0), - 1, src, m_activeRouteTimeout); + m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0), + 1, src, m_activeRouteTimeout); m_routingTable.AddRoute (newEntry); } else { toNeighbor.SetLifeTime (m_activeRouteTimeout); toNeighbor.SetValidSeqNo (false); - toNeighbor.SetSeqNo (rreqHeader.GetOriginSeqno ()); + toNeighbor.SetSeqNo (rreqHeader.GetOriginSeqno ()); toNeighbor.SetFlag (VALID); toNeighbor.SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (receiver))); toNeighbor.SetInterface (m_ipv4->GetAddress (m_ipv4->GetInterfaceForAddress (receiver), 0)); @@ -1265,7 +1317,7 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s } m_nb.Update (src, Time (m_allowedHelloLoss * m_helloInterval)); - NS_LOG_LOGIC (receiver << " receive RREQ with hop count " << static_cast(rreqHeader.GetHopCount ()) + NS_LOG_LOGIC (receiver << " receive RREQ with hop count " << static_cast (rreqHeader.GetHopCount ()) << " ID " << rreqHeader.GetId () << " to destination " << rreqHeader.GetDst ()); @@ -1341,11 +1393,11 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s destination = Ipv4Address ("255.255.255.255"); } else - { + { destination = iface.GetBroadcast (); } m_lastBcastTime = Simulator::Now (); - Simulator::Schedule (Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))), &RoutingProtocol::SendTo, this, socket, packet, destination); + Simulator::Schedule (Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))), &RoutingProtocol::SendTo, this, socket, packet, destination); } } @@ -1359,7 +1411,9 @@ RoutingProtocol::SendReply (RreqHeader const & rreqHeader, RoutingTableEntry con * incremented value. Otherwise, the destination does not change its sequence number before generating the RREP message. */ if (!rreqHeader.GetUnknownSeqno () && (rreqHeader.GetDstSeqno () == m_seqNo + 1)) - m_seqNo++; + { + m_seqNo++; + } RrepHeader rrepHeader ( /*prefixSize=*/ 0, /*hops=*/ 0, /*dst=*/ rreqHeader.GetDst (), /*dstSeqNo=*/ m_seqNo, /*origin=*/ toOrigin.GetDestination (), /*lifeTime=*/ m_myRouteTimeout); Ptr packet = Create (); @@ -1564,7 +1618,7 @@ RoutingProtocol::RecvReply (Ptr p, Ipv4Address receiver, Ipv4Address sen m_routingTable.Update (toNextHopToOrigin); } SocketIpTtlTag tag; - p->RemovePacketTag(tag); + p->RemovePacketTag (tag); if (tag.GetTtl () < 2) { NS_LOG_DEBUG ("TTL exceeded. Drop RREP destination " << dst << " origin " << rrepHeader.GetOrigin ()); @@ -1573,7 +1627,7 @@ RoutingProtocol::RecvReply (Ptr p, Ipv4Address receiver, Ipv4Address sen Ptr packet = Create (); SocketIpTtlTag ttl; - ttl.SetTtl (tag.GetTtl() - 1); + ttl.SetTtl (tag.GetTtl () - 1); packet->AddPacketTag (ttl); packet->AddHeader (rrepHeader); TypeHeader tHeader (AODVTYPE_RREP); @@ -1588,7 +1642,7 @@ RoutingProtocol::RecvReplyAck (Ipv4Address neighbor) { NS_LOG_FUNCTION (this); RoutingTableEntry rt; - if(m_routingTable.LookupRoute (neighbor, rt)) + if (m_routingTable.LookupRoute (neighbor, rt)) { rt.m_ackTimer.Cancel (); rt.SetFlag (VALID); @@ -1645,18 +1699,18 @@ RoutingProtocol::RecvError (Ptr p, Ipv4Address src ) while (rerrHeader.RemoveUnDestination (un)) { for (std::map::const_iterator i = - dstWithNextHopSrc.begin (); i != dstWithNextHopSrc.end (); ++i) - { - if (i->first == un.first) - { - unreachable.insert (un); - } - } + dstWithNextHopSrc.begin (); i != dstWithNextHopSrc.end (); ++i) + { + if (i->first == un.first) + { + unreachable.insert (un); + } + } } std::vector precursors; for (std::map::const_iterator i = unreachable.begin (); - i != unreachable.end ();) + i != unreachable.end (); ) { if (!rerrHeader.AddUnDestination (i->first, i->second)) { @@ -1805,11 +1859,11 @@ RoutingProtocol::SendHello () destination = Ipv4Address ("255.255.255.255"); } else - { + { destination = iface.GetBroadcast (); } Time jitter = Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))); - Simulator::Schedule (jitter, &RoutingProtocol::SendTo, this , socket, packet, destination); + Simulator::Schedule (jitter, &RoutingProtocol::SendTo, this, socket, packet, destination); } } @@ -1822,9 +1876,9 @@ RoutingProtocol::SendPacketFromQueue (Ipv4Address dst, Ptr route) { DeferredRouteOutputTag tag; Ptr p = ConstCast (queueEntry.GetPacket ()); - if (p->RemovePacketTag (tag) && - tag.GetInterface() != -1 && - tag.GetInterface() != m_ipv4->GetInterfaceForDevice (route->GetOutputDevice ())) + if (p->RemovePacketTag (tag) + && tag.GetInterface () != -1 + && tag.GetInterface () != m_ipv4->GetInterfaceForDevice (route->GetOutputDevice ())) { NS_LOG_DEBUG ("Output device doesn't match. Dropped."); return; @@ -1847,12 +1901,14 @@ RoutingProtocol::SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop) RoutingTableEntry toNextHop; if (!m_routingTable.LookupRoute (nextHop, toNextHop)) - return; + { + return; + } toNextHop.GetPrecursors (precursors); rerrHeader.AddUnDestination (nextHop, toNextHop.GetSeqNo ()); m_routingTable.GetListOfDestinationWithNextHop (nextHop, unreachable); for (std::map::const_iterator i = unreachable.begin (); i - != unreachable.end ();) + != unreachable.end (); ) { if (!rerrHeader.AddUnDestination (i->first, i->second)) { @@ -1901,7 +1957,7 @@ RoutingProtocol::SendRerrWhenNoRouteToForward (Ipv4Address dst, // Just make sure that the RerrRateLimit timer is running and will expire NS_ASSERT (m_rerrRateLimitTimer.IsRunning ()); // discard the packet and return - NS_LOG_LOGIC ("RerrRateLimit reached at " << Simulator::Now ().GetSeconds () << " with timer delay left " + NS_LOG_LOGIC ("RerrRateLimit reached at " << Simulator::Now ().GetSeconds () << " with timer delay left " << m_rerrRateLimitTimer.GetDelayLeft ().GetSeconds () << "; suppressing RERR"); return; @@ -1939,7 +1995,7 @@ RoutingProtocol::SendRerrWhenNoRouteToForward (Ipv4Address dst, destination = Ipv4Address ("255.255.255.255"); } else - { + { destination = iface.GetBroadcast (); } socket->SendTo (packet->Copy (), 0, InetSocketAddress (destination, AODV_PORT)); @@ -1963,7 +2019,7 @@ RoutingProtocol::SendRerrMessage (Ptr packet, std::vector p // Just make sure that the RerrRateLimit timer is running and will expire NS_ASSERT (m_rerrRateLimitTimer.IsRunning ()); // discard the packet and return - NS_LOG_LOGIC ("RerrRateLimit reached at " << Simulator::Now ().GetSeconds () << " with timer delay left " + NS_LOG_LOGIC ("RerrRateLimit reached at " << Simulator::Now ().GetSeconds () << " with timer delay left " << m_rerrRateLimitTimer.GetDelayLeft ().GetSeconds () << "; suppressing RERR"); return; @@ -1988,8 +2044,8 @@ RoutingProtocol::SendRerrMessage (Ptr packet, std::vector p RoutingTableEntry toPrecursor; for (std::vector::const_iterator i = precursors.begin (); i != precursors.end (); ++i) { - if (m_routingTable.LookupValidRoute (*i, toPrecursor) && - std::find (ifaces.begin (), ifaces.end (), toPrecursor.GetInterface ()) == ifaces.end ()) + if (m_routingTable.LookupValidRoute (*i, toPrecursor) + && std::find (ifaces.begin (), ifaces.end (), toPrecursor.GetInterface ()) == ifaces.end ()) { ifaces.push_back (toPrecursor.GetInterface ()); } @@ -2009,7 +2065,7 @@ RoutingProtocol::SendRerrMessage (Ptr packet, std::vector p destination = Ipv4Address ("255.255.255.255"); } else - { + { destination = i->GetBroadcast (); } Simulator::Schedule (Time (MilliSeconds (m_uniformRandomVariable->GetInteger (0, 10))), &RoutingProtocol::SendTo, this, socket, p, destination); @@ -2026,7 +2082,9 @@ RoutingProtocol::FindSocketWithInterfaceAddress (Ipv4InterfaceAddress addr ) con Ptr socket = j->first; Ipv4InterfaceAddress iface = j->second; if (iface == addr) - return socket; + { + return socket; + } } Ptr socket; return socket; @@ -2042,7 +2100,9 @@ RoutingProtocol::FindSubnetBroadcastSocketWithInterfaceAddress (Ipv4InterfaceAdd Ptr socket = j->first; Ipv4InterfaceAddress iface = j->second; if (iface == addr) - return socket; + { + return socket; + } } Ptr socket; return socket; diff --git a/src/aodv/model/aodv-rqueue.cc b/src/aodv/model/aodv-rqueue.cc index e9e3b7dc4ff..8b79c1182d2 100644 --- a/src/aodv/model/aodv-rqueue.cc +++ b/src/aodv/model/aodv-rqueue.cc @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -32,13 +32,11 @@ #include "ns3/socket.h" #include "ns3/log.h" -namespace ns3 -{ +namespace ns3 { NS_LOG_COMPONENT_DEFINE ("AodvRequestQueue"); -namespace aodv -{ +namespace aodv { uint32_t RequestQueue::GetSize () { @@ -56,7 +54,9 @@ RequestQueue::Enqueue (QueueEntry & entry) if ((i->GetPacket ()->GetUid () == entry.GetPacket ()->GetUid ()) && (i->GetIpv4Header ().GetDestination () == entry.GetIpv4Header ().GetDestination ())) - return false; + { + return false; + } } entry.SetExpireTime (m_queueTimeout); if (m_queue.size () == m_maxLen) @@ -108,14 +108,25 @@ RequestQueue::Find (Ipv4Address dst) != m_queue.end (); ++i) { if (i->GetIpv4Header ().GetDestination () == dst) - return true; + { + return true; + } } return false; } +/** + * \brief IsExpired structure + */ struct IsExpired { bool + /** + * Check if the entry is expired + * + * \param e QueueEntry entry + * \return true if expired, false otherwise + */ operator() (QueueEntry const & e) const { return (e.GetExpireTime () < Seconds (0)); @@ -147,5 +158,5 @@ RequestQueue::Drop (QueueEntry en, std::string reason) return; } -} -} +} // namespace aodv +} // namespace ns3 diff --git a/src/aodv/model/aodv-rtable.cc b/src/aodv/model/aodv-rtable.cc index bf26525e13a..51b1c03510f 100644 --- a/src/aodv/model/aodv-rtable.cc +++ b/src/aodv/model/aodv-rtable.cc @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -32,24 +32,28 @@ #include "ns3/simulator.h" #include "ns3/log.h" -namespace ns3 -{ +namespace ns3 { NS_LOG_COMPONENT_DEFINE ("AodvRoutingTable"); -namespace aodv -{ +namespace aodv { /* The Routing Table */ RoutingTableEntry::RoutingTableEntry (Ptr dev, Ipv4Address dst, bool vSeqNo, uint32_t seqNo, - Ipv4InterfaceAddress iface, uint16_t hops, Ipv4Address nextHop, Time lifetime) : - m_ackTimer (Timer::CANCEL_ON_DESTROY), - m_validSeqNo (vSeqNo), m_seqNo (seqNo), m_hops (hops), - m_lifeTime (lifetime + Simulator::Now ()), m_iface (iface), m_flag (VALID), - m_reqCount (0), m_blackListState (false), m_blackListTimeout (Simulator::Now ()) + Ipv4InterfaceAddress iface, uint16_t hops, Ipv4Address nextHop, Time lifetime) + : m_ackTimer (Timer::CANCEL_ON_DESTROY), + m_validSeqNo (vSeqNo), + m_seqNo (seqNo), + m_hops (hops), + m_lifeTime (lifetime + Simulator::Now ()), + m_iface (iface), + m_flag (VALID), + m_reqCount (0), + m_blackListState (false), + m_blackListTimeout (Simulator::Now ()) { m_ipv4Route = Create (); m_ipv4Route->SetDestination (dst); @@ -72,7 +76,9 @@ RoutingTableEntry::InsertPrecursor (Ipv4Address id) return true; } else - return false; + { + return false; + } } bool @@ -129,7 +135,9 @@ RoutingTableEntry::GetPrecursors (std::vector & prec) const { NS_LOG_FUNCTION (this); if (IsPrecursorListEmpty ()) - return; + { + return; + } for (std::vector::const_iterator i = m_precursorList.begin (); i != m_precursorList.end (); ++i) { @@ -138,10 +146,14 @@ RoutingTableEntry::GetPrecursors (std::vector & prec) const != prec.end (); ++j) { if (*j == *i) - result = false; + { + result = false; + } } if (result) - prec.push_back (*i); + { + prec.push_back (*i); + } } } @@ -150,7 +162,9 @@ RoutingTableEntry::Invalidate (Time badLinkLifetime) { NS_LOG_FUNCTION (this << badLinkLifetime.GetSeconds ()); if (m_flag == INVALID) - return; + { + return; + } m_flag = INVALID; m_reqCount = 0; m_lifeTime = badLinkLifetime + Simulator::Now (); @@ -181,7 +195,7 @@ RoutingTableEntry::Print (Ptr stream) const } } *os << "\t"; - *os << std::setiosflags (std::ios::fixed) << + *os << std::setiosflags (std::ios::fixed) << std::setiosflags (std::ios::left) << std::setprecision (2) << std::setw (14) << (m_lifeTime - Simulator::Now ()).GetSeconds (); *os << "\t" << m_hops << "\n"; @@ -191,8 +205,8 @@ RoutingTableEntry::Print (Ptr stream) const The Routing Table */ -RoutingTable::RoutingTable (Time t) : - m_badLinkLifetime (t) +RoutingTable::RoutingTable (Time t) + : m_badLinkLifetime (t) { } @@ -251,7 +265,9 @@ RoutingTable::AddRoute (RoutingTableEntry & rt) NS_LOG_FUNCTION (this); Purge (); if (rt.GetFlag () != IN_SEARCH) - rt.SetRreqCnt (0); + { + rt.SetRreqCnt (0); + } std::pair::iterator, bool> result = m_ipv4AddressEntry.insert (std::make_pair (rt.GetDestination (), rt)); return result.second; @@ -336,9 +352,11 @@ RoutingTable::DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface) { NS_LOG_FUNCTION (this); if (m_ipv4AddressEntry.empty ()) - return; + { + return; + } for (std::map::iterator i = - m_ipv4AddressEntry.begin (); i != m_ipv4AddressEntry.end ();) + m_ipv4AddressEntry.begin (); i != m_ipv4AddressEntry.end (); ) { if (i->second.GetInterface () == iface) { @@ -347,7 +365,9 @@ RoutingTable::DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface) m_ipv4AddressEntry.erase (tmp); } else - ++i; + { + ++i; + } } } @@ -356,9 +376,11 @@ RoutingTable::Purge () { NS_LOG_FUNCTION (this); if (m_ipv4AddressEntry.empty ()) - return; + { + return; + } for (std::map::iterator i = - m_ipv4AddressEntry.begin (); i != m_ipv4AddressEntry.end ();) + m_ipv4AddressEntry.begin (); i != m_ipv4AddressEntry.end (); ) { if (i->second.GetLifeTime () < Seconds (0)) { @@ -375,9 +397,11 @@ RoutingTable::Purge () ++i; } else - ++i; + { + ++i; + } } - else + else { ++i; } @@ -389,9 +413,11 @@ RoutingTable::Purge (std::map &table) const { NS_LOG_FUNCTION (this); if (table.empty ()) - return; + { + return; + } for (std::map::iterator i = - table.begin (); i != table.end ();) + table.begin (); i != table.end (); ) { if (i->second.GetLifeTime () < Seconds (0)) { @@ -408,9 +434,11 @@ RoutingTable::Purge (std::map &table) const ++i; } else - ++i; + { + ++i; + } } - else + else { ++i; } From 31bad4422dc13512a3db98183c13e646ec693671 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 11:53:24 -0700 Subject: [PATCH 045/551] aodv: Fix Doxygen warnings --- src/aodv/helper/aodv-helper.h | 11 +- src/aodv/model/aodv-dpd.h | 12 +- src/aodv/model/aodv-id-cache.h | 36 ++- src/aodv/model/aodv-neighbor.h | 51 +++- src/aodv/model/aodv-packet.h | 364 ++++++++++++++++++++++--- src/aodv/model/aodv-routing-protocol.h | 150 +++++++--- src/aodv/model/aodv-rqueue.h | 174 ++++++++++-- src/aodv/model/aodv-rtable.h | 276 ++++++++++++++++--- 8 files changed, 896 insertions(+), 178 deletions(-) diff --git a/src/aodv/helper/aodv-helper.h b/src/aodv/helper/aodv-helper.h index d39fed42452..bf83cc59ce8 100644 --- a/src/aodv/helper/aodv-helper.h +++ b/src/aodv/helper/aodv-helper.h @@ -26,8 +26,7 @@ #include "ns3/node-container.h" #include "ns3/ipv4-routing-helper.h" -namespace ns3 -{ +namespace ns3 { /** * \ingroup aodv * \brief Helper class that adds AODV routing to nodes. @@ -35,11 +34,11 @@ namespace ns3 class AodvHelper : public Ipv4RoutingHelper { public: - AodvHelper(); + AodvHelper (); /** - * \returns pointer to clone of this OlsrHelper - * + * \returns pointer to clone of this AodvHelper + * * \internal * This method is mainly for internal use by the other helpers; * clients are expected to free the dynamic memory allocated by this method @@ -51,7 +50,7 @@ class AodvHelper : public Ipv4RoutingHelper * \returns a newly-created routing protocol * * This method will be called by ns3::InternetStackHelper::Install - * + * * \todo support installing AODV on the subset of all available IP interfaces */ virtual Ptr Create (Ptr node) const; diff --git a/src/aodv/model/aodv-dpd.h b/src/aodv/model/aodv-dpd.h index 6f886ae5c94..d91a18a4685 100644 --- a/src/aodv/model/aodv-dpd.h +++ b/src/aodv/model/aodv-dpd.h @@ -28,13 +28,11 @@ #include "ns3/packet.h" #include "ns3/ipv4-header.h" -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { /** * \ingroup aodv - * + * * \brief Helper class used to remember already seen packets and detect duplicates. * * Currently duplicate detection is based on uinique packet ID given by Packet::GetUid () @@ -44,7 +42,9 @@ class DuplicatePacketDetection { public: /// C-tor - DuplicatePacketDetection (Time lifetime) : m_idCache (lifetime) {} + DuplicatePacketDetection (Time lifetime) : m_idCache (lifetime) + { + } /// Check that the packet is duplicated. If not, save information about this packet. bool IsDuplicate (Ptr p, const Ipv4Header & header); /// Set duplicate records lifetimes diff --git a/src/aodv/model/aodv-id-cache.h b/src/aodv/model/aodv-id-cache.h index 559827a98c0..863b23bacd5 100644 --- a/src/aodv/model/aodv-id-cache.h +++ b/src/aodv/model/aodv-id-cache.h @@ -33,20 +33,20 @@ #include "ns3/simulator.h" #include -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { /** * \ingroup aodv - * + * * \brief Unique packets identification cache used for simple duplicate detection. */ class IdCache { public: /// c-tor - IdCache (Time lifetime) : m_lifetime (lifetime) {} + IdCache (Time lifetime) : m_lifetime (lifetime) + { + } /// Check that entry (addr, id) exists in cache. Add entry, if it doesn't exist. bool IsDuplicate (Ipv4Address addr, uint32_t id); /// Remove all expired entries @@ -54,9 +54,15 @@ class IdCache /// Return number of entries in cache uint32_t GetSize (); /// Set lifetime for future added entries. - void SetLifetime (Time lifetime) { m_lifetime = lifetime; } + void SetLifetime (Time lifetime) + { + m_lifetime = lifetime; + } /// Return lifetime for existing entries in cache - Time GetLifeTime () const { return m_lifetime; } + Time GetLifeTime () const + { + return m_lifetime; + } private: /// Unique packet ID struct UniqueId @@ -68,8 +74,17 @@ class IdCache /// When record will expire Time m_expire; }; + /** + * \brief IsExpired structure + */ struct IsExpired { + /** + * \brief Check if the entry is expired + * + * \param u UniqueId entry + * \return true if expired, false otherwise + */ bool operator() (const struct UniqueId & u) const { return (u.m_expire < Simulator::Now ()); @@ -81,6 +96,7 @@ class IdCache Time m_lifetime; }; -} -} +} // namespace aodv +} // namespace ns3 + #endif /* AODV_ID_CACHE_H */ diff --git a/src/aodv/model/aodv-neighbor.h b/src/aodv/model/aodv-neighbor.h index 3e4952e387e..d1bb4597a61 100644 --- a/src/aodv/model/aodv-neighbor.h +++ b/src/aodv/model/aodv-neighbor.h @@ -37,10 +37,8 @@ #include "ns3/arp-cache.h" #include -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { class RoutingProtocol; /** * \ingroup aodv @@ -54,14 +52,27 @@ class Neighbors /// Neighbor description struct Neighbor { + /// Neighbor IPv4 address Ipv4Address m_neighborAddress; + /// Neighbor MAC address Mac48Address m_hardwareAddress; + /// Neighbor expire time Time m_expireTime; + /// Neighbor close indicator bool close; - Neighbor (Ipv4Address ip, Mac48Address mac, Time t) : - m_neighborAddress (ip), m_hardwareAddress (mac), m_expireTime (t), - close (false) + /** + * \brief Neighbor structure constructor + * + * \param ip Ipv4Address entry + * \param mac Mac48Address entry + * \param t Time expire time + */ + Neighbor (Ipv4Address ip, Mac48Address mac, Time t) + : m_neighborAddress (ip), + m_hardwareAddress (mac), + m_expireTime (t), + close (false) { } }; @@ -76,19 +87,31 @@ class Neighbors /// Schedule m_ntimer. void ScheduleTimer (); /// Remove all entries - void Clear () { m_nb.clear (); } + void Clear () + { + m_nb.clear (); + } /// Add ARP cache to be used to allow layer 2 notifications processing void AddArpCache (Ptr); /// Don't use given ARP cache any more (interface is down) void DelArpCache (Ptr); /// Get callback to ProcessTxError - Callback GetTxErrorCallback () const { return m_txErrorCallback; } - + Callback GetTxErrorCallback () const + { + return m_txErrorCallback; + } + /// Handle link failure callback - void SetCallback (Callback cb) { m_handleLinkFailure = cb; } + void SetCallback (Callback cb) + { + m_handleLinkFailure = cb; + } /// Handle link failure callback - Callback GetCallback () const { return m_handleLinkFailure; } + Callback GetCallback () const + { + return m_handleLinkFailure; + } private: /// link failure callback @@ -108,7 +131,7 @@ class Neighbors void ProcessTxError (WifiMacHeader const &); }; -} -} +} // namespace aodv +} // namespace ns3 #endif /* AODVNEIGHBOR_H */ diff --git a/src/aodv/model/aodv-packet.h b/src/aodv/model/aodv-packet.h index b35c0e9a8d8..592da5b74de 100644 --- a/src/aodv/model/aodv-packet.h +++ b/src/aodv/model/aodv-packet.h @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -38,6 +38,10 @@ namespace ns3 { namespace aodv { +/** +* \ingroup aodv +* \brief MessageType enumeration +*/ enum MessageType { AODVTYPE_RREQ = 1, //!< AODVTYPE_RREQ @@ -56,7 +60,10 @@ class TypeHeader : public Header /// c-tor TypeHeader (MessageType t = AODVTYPE_RREQ); - // Header serialization/deserialization + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); TypeId GetInstanceTypeId () const; uint32_t GetSerializedSize () const; @@ -65,15 +72,31 @@ class TypeHeader : public Header void Print (std::ostream &os) const; /// Return type - MessageType Get () const { return m_type; } + MessageType Get () const + { + return m_type; + } /// Check that type if valid - bool IsValid () const { return m_valid; } + bool IsValid () const + { + return m_valid; + } + /** + * \brief Comparison operator + * \param o header to compare + * \return true if the headers are equal + */ bool operator== (TypeHeader const & o) const; private: - MessageType m_type; - bool m_valid; + MessageType m_type; ///< type of the message + bool m_valid; ///< Indicates if the message is valid }; +/** + * \brief Stream output operator + * \param os output stream + * \return updated stream + */ std::ostream & operator<< (std::ostream & os, TypeHeader const & h); /** @@ -97,7 +120,7 @@ std::ostream & operator<< (std::ostream & os, TypeHeader const & h); +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \endverbatim */ -class RreqHeader : public Header +class RreqHeader : public Header { public: /// c-tor @@ -106,7 +129,10 @@ class RreqHeader : public Header uint32_t dstSeqNo = 0, Ipv4Address origin = Ipv4Address (), uint32_t originSeqNo = 0); - // Header serialization/deserialization + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); TypeId GetInstanceTypeId () const; uint32_t GetSerializedSize () const; @@ -115,31 +141,144 @@ class RreqHeader : public Header void Print (std::ostream &os) const; // Fields - void SetHopCount (uint8_t count) { m_hopCount = count; } - uint8_t GetHopCount () const { return m_hopCount; } - void SetId (uint32_t id) { m_requestID = id; } - uint32_t GetId () const { return m_requestID; } - void SetDst (Ipv4Address a) { m_dst = a; } - Ipv4Address GetDst () const { return m_dst; } - void SetDstSeqno (uint32_t s) { m_dstSeqNo = s; } - uint32_t GetDstSeqno () const { return m_dstSeqNo; } - void SetOrigin (Ipv4Address a) { m_origin = a; } - Ipv4Address GetOrigin () const { return m_origin; } - void SetOriginSeqno (uint32_t s) { m_originSeqNo = s; } - uint32_t GetOriginSeqno () const { return m_originSeqNo; } + /** + * \brief Set the hop count + * \param count the hop count + */ + void SetHopCount (uint8_t count) + { + m_hopCount = count; + } + /** + * \brief Get the hop count + * \return the hop count + */ + uint8_t GetHopCount () const + { + return m_hopCount; + } + /** + * \brief Set the request ID + * \param id the request ID + */ + void SetId (uint32_t id) + { + m_requestID = id; + } + /** + * \brief Get the request ID + * \return the request ID + */ + uint32_t GetId () const + { + return m_requestID; + } + /** + * \brief Set the destination address + * \param a the destination address + */ + void SetDst (Ipv4Address a) + { + m_dst = a; + } + /** + * \brief Get the destination address + * \return the destination address + */ + Ipv4Address GetDst () const + { + return m_dst; + } + /** + * \brief Set the destination sequence number + * \param s the destination sequence number + */ + void SetDstSeqno (uint32_t s) + { + m_dstSeqNo = s; + } + /** + * \brief Get the destination sequence number + * \return the destination sequence number + */ + uint32_t GetDstSeqno () const + { + return m_dstSeqNo; + } + /** + * \brief Set the origin address + * \param a the origin address + */ + void SetOrigin (Ipv4Address a) + { + m_origin = a; + } + /** + * \brief Get the origin address + * \return the origin address + */ + Ipv4Address GetOrigin () const + { + return m_origin; + } + /** + * \brief Set the origin sequence number + * \param s the origin sequence number + */ + void SetOriginSeqno (uint32_t s) + { + m_originSeqNo = s; + } + /** + * \brief Get the origin sequence number + * \return the origin sequence number + */ + uint32_t GetOriginSeqno () const + { + return m_originSeqNo; + } // Flags + /** + * \brief Set the gratuitous RREP flag + * \param f the gratuitous RREP flag + */ void SetGratiousRrep (bool f); + /** + * \brief Get the gratuitous RREP flag + * \return the gratuitous RREP flag + */ bool GetGratiousRrep () const; + /** + * \brief Set the Destination only flag + * \param f the Destiantion only flag + */ void SetDestinationOnly (bool f); + /** + * \brief Get the Destination only flag + * \return the Destination only flag + */ bool GetDestinationOnly () const; + /** + * \brief Set the unknown sequence number flag + * \param f the unknown sequence number flag + */ void SetUnknownSeqno (bool f); + /** + * \brief Get the unknown sequence number flag + * \return the unknown sequence number flag + */ bool GetUnknownSeqno () const; + /** + * \brief Comparison operator + * \param o RREQ header to compare + * \return true if the RREQ headers are equal + */ bool operator== (RreqHeader const & o) const; private: uint8_t m_flags; ///< |J|R|G|D|U| bit flags, see RFC - uint8_t m_reserved; ///< Not used + uint8_t m_reserved; ///< Not used (must be 0) uint8_t m_hopCount; ///< Hop Count uint32_t m_requestID; ///< RREQ ID Ipv4Address m_dst; ///< Destination IP Address @@ -148,6 +287,11 @@ class RreqHeader : public Header uint32_t m_originSeqNo; ///< Source Sequence Number }; +/** + * \brief Stream output operator + * \param os output stream + * \return updated stream + */ std::ostream & operator<< (std::ostream & os, RreqHeader const &); /** @@ -176,7 +320,10 @@ class RrepHeader : public Header RrepHeader (uint8_t prefixSize = 0, uint8_t hopCount = 0, Ipv4Address dst = Ipv4Address (), uint32_t dstSeqNo = 0, Ipv4Address origin = Ipv4Address (), Time lifetime = MilliSeconds (0)); - // Header serialization/deserialization + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); TypeId GetInstanceTypeId () const; uint32_t GetSerializedSize () const; @@ -185,26 +332,111 @@ class RrepHeader : public Header void Print (std::ostream &os) const; // Fields - void SetHopCount (uint8_t count) { m_hopCount = count; } - uint8_t GetHopCount () const { return m_hopCount; } - void SetDst (Ipv4Address a) { m_dst = a; } - Ipv4Address GetDst () const { return m_dst; } - void SetDstSeqno (uint32_t s) { m_dstSeqNo = s; } - uint32_t GetDstSeqno () const { return m_dstSeqNo; } - void SetOrigin (Ipv4Address a) { m_origin = a; } - Ipv4Address GetOrigin () const { return m_origin; } + /** + * \brief Set the hop count + * \param count the hop count + */ + void SetHopCount (uint8_t count) + { + m_hopCount = count; + } + /** + * \brief Get the hop count + * \return the hop count + */ + uint8_t GetHopCount () const + { + return m_hopCount; + } + /** + * \brief Set the destination address + * \param a the destination address + */ + void SetDst (Ipv4Address a) + { + m_dst = a; + } + /** + * \brief Get the destination address + * \return the destination address + */ + Ipv4Address GetDst () const + { + return m_dst; + } + /** + * \brief Set the destination sequence number + * \param s the destination sequence number + */ + void SetDstSeqno (uint32_t s) + { + m_dstSeqNo = s; + } + /** + * \brief Get the destination sequence number + * \return the destination sequence number + */ + uint32_t GetDstSeqno () const + { + return m_dstSeqNo; + } + /** + * \brief Set the origin address + * \param a the origin address + */ + void SetOrigin (Ipv4Address a) + { + m_origin = a; + } + /** + * \brief Get the origin address + * \return the origin address + */ + Ipv4Address GetOrigin () const + { + return m_origin; + } + /** + * \brief Set the lifetime + * \param t the lifetime + */ void SetLifeTime (Time t); + /** + * \brief Get the lifetime + * \return the lifetime + */ Time GetLifeTime () const; // Flags + /** + * \brief Set the ack required flag + * \param f the ack required flag + */ void SetAckRequired (bool f); + /** + * \brief get the ack required flag + * \return the ack required flag + */ bool GetAckRequired () const; + /** + * \brief Set the prefix size + * \param sz the prefix size + */ void SetPrefixSize (uint8_t sz); + /** + * \brief Set the pefix size + * \return the prefix size + */ uint8_t GetPrefixSize () const; /// Configure RREP to be a Hello message void SetHello (Ipv4Address src, uint32_t srcSeqNo, Time lifetime); + /** + * \brief Comparison operator + * \param o RREP header to compare + * \return true if the RREP headers are equal + */ bool operator== (RrepHeader const & o) const; private: uint8_t m_flags; ///< A - acknowledgment required flag @@ -216,6 +448,11 @@ class RrepHeader : public Header uint32_t m_lifeTime; ///< Lifetime (in milliseconds) }; +/** + * \brief Stream output operator + * \param os output stream + * \return updated stream + */ std::ostream & operator<< (std::ostream & os, RrepHeader const &); /** @@ -235,7 +472,10 @@ class RrepAckHeader : public Header /// c-tor RrepAckHeader (); - // Header serialization/deserialization + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); TypeId GetInstanceTypeId () const; uint32_t GetSerializedSize () const; @@ -243,10 +483,21 @@ class RrepAckHeader : public Header uint32_t Deserialize (Buffer::Iterator start); void Print (std::ostream &os) const; + /** + * \brief Comparison operator + * \param o RREP header to compare + * \return true if the RREQ headers are equal + */ bool operator== (RrepAckHeader const & o) const; private: - uint8_t m_reserved; + uint8_t m_reserved; ///< Not used (must be 0) }; + +/** + * \brief Stream output operator + * \param os output stream + * \return updated stream + */ std::ostream & operator<< (std::ostream & os, RrepAckHeader const &); @@ -275,7 +526,10 @@ class RerrHeader : public Header /// c-tor RerrHeader (); - // Header serialization/deserialization + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); TypeId GetInstanceTypeId () const; uint32_t GetSerializedSize () const; @@ -284,32 +538,60 @@ class RerrHeader : public Header void Print (std::ostream &os) const; // No delete flag + /** + * \brief Set the no delete flag + * \param f the no delete flag + */ void SetNoDelete (bool f); + /** + * \brief Get the no delete flag + * \return the no delete flag + */ bool GetNoDelete () const; /** - * Add unreachable node address and its sequence number in RERR header - *\return false if we already added maximum possible number of unreachable destinations + * \brief Add unreachable node address and its sequence number in RERR header + * \param dst unreachable IPv4 address + * \param seqNo unreachable sequence number + * \return false if we already added maximum possible number of unreachable destinations */ bool AddUnDestination (Ipv4Address dst, uint32_t seqNo); - /** Delete pair (address + sequence number) from REER header, if the number of unreachable destinations > 0 + /** + * \brief Delete pair (address + sequence number) from REER header, if the number of unreachable destinations > 0 + * \param un unreachable pair (address + sequence number) * \return true on success */ bool RemoveUnDestination (std::pair & un); /// Clear header void Clear (); /// Return number of unreachable destinations in RERR message - uint8_t GetDestCount () const { return (uint8_t)m_unreachableDstSeqNo.size (); } + uint8_t GetDestCount () const + { + return (uint8_t)m_unreachableDstSeqNo.size (); + } + + /** + * \brief Comparison operator + * \param o RERR header to compare + * \return true if the RERR headers are equal + */ bool operator== (RerrHeader const & o) const; private: uint8_t m_flag; ///< No delete flag - uint8_t m_reserved; ///< Not used + uint8_t m_reserved; ///< Not used (must be 0) /// List of Unreachable destination: IP addresses and sequence numbers std::map m_unreachableDstSeqNo; }; +/** + * \brief Stream output operator + * \param os output stream + * \return updated stream + */ std::ostream & operator<< (std::ostream & os, RerrHeader const &); -} -} + +} // namespace aodv +} // namespace ns3 + #endif /* AODVPACKET_H */ diff --git a/src/aodv/model/aodv-routing-protocol.h b/src/aodv/model/aodv-routing-protocol.h index a379c03217e..476eb66e13d 100644 --- a/src/aodv/model/aodv-routing-protocol.h +++ b/src/aodv/model/aodv-routing-protocol.h @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -41,24 +41,26 @@ #include "ns3/ipv4-l3-protocol.h" #include -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { /** * \ingroup aodv - * + * * \brief AODV routing protocol */ class RoutingProtocol : public Ipv4RoutingProtocol { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); static const uint32_t AODV_PORT; /// c-tor RoutingProtocol (); - virtual ~RoutingProtocol(); + virtual ~RoutingProtocol (); virtual void DoDispose (); // Inherited from Ipv4RoutingProtocol @@ -72,35 +74,112 @@ class RoutingProtocol : public Ipv4RoutingProtocol virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address); virtual void SetIpv4 (Ptr ipv4); virtual void PrintRoutingTable (Ptr stream, Time::Unit unit = Time::S) const; - + // Handle protocol parameters - Time GetMaxQueueTime () const { return m_maxQueueTime; } + /** + * Get maximum queue time + * \returns the maximum queue time + */ + Time GetMaxQueueTime () const + { + return m_maxQueueTime; + } + /** + * Set the maximum queue time + * \param t the maximum queue time + */ void SetMaxQueueTime (Time t); - uint32_t GetMaxQueueLen () const { return m_maxQueueLen; } + /** + * Get the maximum queue length + * \returns the maximum queue length + */ + uint32_t GetMaxQueueLen () const + { + return m_maxQueueLen; + } + /** + * Set the maximum queue length + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len); - bool GetDesinationOnlyFlag () const { return m_destinationOnly; } - void SetDesinationOnlyFlag (bool f) { m_destinationOnly = f; } - bool GetGratuitousReplyFlag () const { return m_gratuitousReply; } - void SetGratuitousReplyFlag (bool f) { m_gratuitousReply = f; } - void SetHelloEnable (bool f) { m_enableHello = f; } - bool GetHelloEnable () const { return m_enableHello; } - void SetBroadcastEnable (bool f) { m_enableBroadcast = f; } - bool GetBroadcastEnable () const { return m_enableBroadcast; } + /** + * Get destination only flag + * \returns the destination only flag + */ + bool GetDesinationOnlyFlag () const + { + return m_destinationOnly; + } + /** + * Set destination only flag + * \param f the destination only flag + */ + void SetDesinationOnlyFlag (bool f) + { + m_destinationOnly = f; + } + /** + * Get gratuitous reply flag + * \returns the gratuitous reply flag + */ + bool GetGratuitousReplyFlag () const + { + return m_gratuitousReply; + } + /** + * Set gratuitous reply flag + * \param f the gratuitous reply flag + */ + void SetGratuitousReplyFlag (bool f) + { + m_gratuitousReply = f; + } + /** + * Set hello enable + * \param f the hello enable flag + */ + void SetHelloEnable (bool f) + { + m_enableHello = f; + } + /** + * Get hello enable flag + * \returns the enable hello flag + */ + bool GetHelloEnable () const + { + return m_enableHello; + } + /** + * Set broadcast enable flag + * \param f enable broadcast flag + */ + void SetBroadcastEnable (bool f) + { + m_enableBroadcast = f; + } + /** + * Get broadcast enable flag + * \returns the broadcast enable flag + */ + bool GetBroadcastEnable () const + { + return m_enableBroadcast; + } - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * \return the number of stream indices assigned by this model - */ + /** + * Assign a fixed random variable stream number to the random variables + * used by this model. Return the number of streams (possibly zero) that + * have been assigned. + * + * \param stream first stream index to use + * \return the number of stream indices assigned by this model + */ int64_t AssignStreams (int64_t stream); protected: virtual void DoInitialize (void); private: - // Protocol parameters. uint32_t m_rreqRetries; ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route uint16_t m_ttlStart; ///< Initial TTL value for RREQ. @@ -147,7 +226,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol /// Raw subnet directed broadcast socket per each IP interface, map socket -> iface address (IP + mask) std::map< Ptr, Ipv4InterfaceAddress > m_socketSubnetBroadcastAddresses; /// Loopback device used to defer RREQ until packet will be fully formed - Ptr m_lo; + Ptr m_lo; /// Routing table RoutingTable m_routingTable; @@ -249,6 +328,12 @@ class RoutingProtocol : public Ipv4RoutingProtocol void SendRerrWhenNoRouteToForward (Ipv4Address dst, uint32_t dstSeqNo, Ipv4Address origin); /// @} + /** + * Send packet to desitnation scoket + * \param socket - destination node socket + * \param packet - packet to send + * \param destination - destination node IP address + */ void SendTo (Ptr socket, Ptr packet, Ipv4Address destination); /// Hello timer @@ -271,11 +356,12 @@ class RoutingProtocol : public Ipv4RoutingProtocol void AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout); /// Provides uniform random variables. - Ptr m_uniformRandomVariable; + Ptr m_uniformRandomVariable; /// Keep track of the last bcast time Time m_lastBcastTime; }; -} -} +} //namespace aodv +} //namespace ns3 + #endif /* AODVROUTINGPROTOCOL_H */ diff --git a/src/aodv/model/aodv-rqueue.h b/src/aodv/model/aodv-rqueue.h index 3dc24346aa5..581624e0112 100644 --- a/src/aodv/model/aodv-rqueue.h +++ b/src/aodv/model/aodv-rqueue.h @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -43,18 +43,25 @@ namespace aodv { class QueueEntry { public: + /// IPv4 routing unicast forward callback typedef typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback; + /// IPv4 routing error callback typedef typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback; /// c-tor QueueEntry (Ptr pa = 0, Ipv4Header const & h = Ipv4Header (), UnicastForwardCallback ucb = UnicastForwardCallback (), - ErrorCallback ecb = ErrorCallback (), Time exp = Simulator::Now ()) : - m_packet (pa), m_header (h), m_ucb (ucb), m_ecb (ecb), - m_expire (exp + Simulator::Now ()) - {} + ErrorCallback ecb = ErrorCallback (), Time exp = Simulator::Now ()) + : m_packet (pa), + m_header (h), + m_ucb (ucb), + m_ecb (ecb), + m_expire (exp + Simulator::Now ()) + { + } /** - * Compare queue entries + * \brief Compare queue entries + * \param o QueueEntry to compare * \return true if equal */ bool operator== (QueueEntry const & o) const @@ -63,19 +70,88 @@ class QueueEntry } // Fields - UnicastForwardCallback GetUnicastForwardCallback () const { return m_ucb; } - void SetUnicastForwardCallback (UnicastForwardCallback ucb) { m_ucb = ucb; } - ErrorCallback GetErrorCallback () const { return m_ecb; } - void SetErrorCallback (ErrorCallback ecb) { m_ecb = ecb; } - Ptr GetPacket () const { return m_packet; } - void SetPacket (Ptr p) { m_packet = p; } - Ipv4Header GetIpv4Header () const { return m_header; } - void SetIpv4Header (Ipv4Header h) { m_header = h; } - void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } - Time GetExpireTime () const { return m_expire - Simulator::Now (); } + /** + * Get unicast forward callback + * \returns unicast callback + */ + UnicastForwardCallback GetUnicastForwardCallback () const + { + return m_ucb; + } + /** + * Set unicast forward callback + * \param ucb The unicast callback + */ + void SetUnicastForwardCallback (UnicastForwardCallback ucb) + { + m_ucb = ucb; + } + /** + * Get error callback + * \returns the error callback + */ + ErrorCallback GetErrorCallback () const + { + return m_ecb; + } + /** + * Set error callback + * \param ecb The error callback + */ + void SetErrorCallback (ErrorCallback ecb) + { + m_ecb = ecb; + } + /** + * Get packet from entry + * \returns the packet + */ + Ptr GetPacket () const + { + return m_packet; + } + /** + * Set packet in entry + * \param p The packet + */ + void SetPacket (Ptr p) + { + m_packet = p; + } + /** + * Get IPv4 header + * \returns the IPv4 header + */ + Ipv4Header GetIpv4Header () const + { + return m_header; + } + /** + * Set IPv4 header + * \param h the IPv4 header + */ + void SetIpv4Header (Ipv4Header h) + { + m_header = h; + } + /** + * Set expire time + * \param exp The expiration time + */ + void SetExpireTime (Time exp) + { + m_expire = exp + Simulator::Now (); + } + /** + * Get expire time + * \returns the expiration time + */ + Time GetExpireTime () const + { + return m_expire - Simulator::Now (); + } private: - /// Data packet Ptr m_packet; /// IP header @@ -90,15 +166,16 @@ class QueueEntry /** * \ingroup aodv * \brief AODV route request queue - * + * * Since AODV is an on demand routing we queue requests while looking for route. */ class RequestQueue { public: /// Default c-tor - RequestQueue (uint32_t maxLen, Time routeToQueueTimeout) : - m_maxLen (maxLen), m_queueTimeout (routeToQueueTimeout) + RequestQueue (uint32_t maxLen, Time routeToQueueTimeout) + : m_maxLen (maxLen), + m_queueTimeout (routeToQueueTimeout) { } /// Push entry in queue, if there is no entry with the same packet and destination address in queue. @@ -111,15 +188,43 @@ class RequestQueue bool Find (Ipv4Address dst); /// Number of entries uint32_t GetSize (); - + // Fields - uint32_t GetMaxQueueLen () const { return m_maxLen; } - void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } - Time GetQueueTimeout () const { return m_queueTimeout; } - void SetQueueTimeout (Time t) { m_queueTimeout = t; } + /** + * Get maximum queue length + * \returns the maximum queue length + */ + uint32_t GetMaxQueueLen () const + { + return m_maxLen; + } + /** + * Set maximum queue length + * \param len The maximum queue length + */ + void SetMaxQueueLen (uint32_t len) + { + m_maxLen = len; + } + /** + * Get queue timeout + * \returns the queue timeout + */ + Time GetQueueTimeout () const + { + return m_queueTimeout; + } + /** + * Set queue timeout + * \param t The queue timeout + */ + void SetQueueTimeout (Time t) + { + m_queueTimeout = t; + } private: - + /// The queue std::vector m_queue; /// Remove all expired entries void Purge (); @@ -129,11 +234,20 @@ class RequestQueue uint32_t m_maxLen; /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_queueTimeout; - static bool IsEqual (QueueEntry en, const Ipv4Address dst) { return (en.GetIpv4Header ().GetDestination () == dst); } + /** + * Determine if queue matches a destination address + * \param en The queue entry + * \param dst The destination IPv4 address + * \returns true if the queue entry matches the desination address + */ + static bool IsEqual (QueueEntry en, const Ipv4Address dst) + { + return (en.GetIpv4Header ().GetDestination () == dst); + } }; -} -} +} // namespace aodv +} // namespace ns3 #endif /* AODV_RQUEUE_H */ diff --git a/src/aodv/model/aodv-rtable.h b/src/aodv/model/aodv-rtable.h index 537238b2c84..59218005903 100644 --- a/src/aodv/model/aodv-rtable.h +++ b/src/aodv/model/aodv-rtable.h @@ -15,10 +15,10 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Based on + * Based on * NS-2 AODV model developed by the CMU/MONARCH group and optimized and * tuned by Samir Das and Mahesh Marina, University of Cincinnati; - * + * * AODV-UU implementation by Erik Nordström of Uppsala University * http://core.it.uu.se/core/index.php/AODV-UU * @@ -89,57 +89,244 @@ class RoutingTableEntry /// Delete all precursors void DeleteAllPrecursors (); /** - * Check that precursor list empty - * \return true if precursor list empty + * Check that precursor list is empty + * \return true if precursor list is empty */ bool IsPrecursorListEmpty () const; /** - * Inserts precursors in vector prec if they does not yet exist in vector + * Inserts precursors in output parameter prec if they do not yet exist in vector + * \param prec vector of precursor addresses */ void GetPrecursors (std::vector & prec) const; //\} /// Mark entry as "down" (i.e. disable it) void Invalidate (Time badLinkLifetime); - + // Fields - Ipv4Address GetDestination () const { return m_ipv4Route->GetDestination (); } - Ptr GetRoute () const { return m_ipv4Route; } - void SetRoute (Ptr r) { m_ipv4Route = r; } - void SetNextHop (Ipv4Address nextHop) { m_ipv4Route->SetGateway (nextHop); } - Ipv4Address GetNextHop () const { return m_ipv4Route->GetGateway (); } - void SetOutputDevice (Ptr dev) { m_ipv4Route->SetOutputDevice (dev); } - Ptr GetOutputDevice () const { return m_ipv4Route->GetOutputDevice (); } - Ipv4InterfaceAddress GetInterface () const { return m_iface; } - void SetInterface (Ipv4InterfaceAddress iface) { m_iface = iface; } - void SetValidSeqNo (bool s) { m_validSeqNo = s; } - bool GetValidSeqNo () const { return m_validSeqNo; } - void SetSeqNo (uint32_t sn) { m_seqNo = sn; } - uint32_t GetSeqNo () const { return m_seqNo; } - void SetHop (uint16_t hop) { m_hops = hop; } - uint16_t GetHop () const { return m_hops; } - void SetLifeTime (Time lt) { m_lifeTime = lt + Simulator::Now (); } - Time GetLifeTime () const { return m_lifeTime - Simulator::Now (); } - void SetFlag (RouteFlags flag) { m_flag = flag; } - RouteFlags GetFlag () const { return m_flag; } - void SetRreqCnt (uint8_t n) { m_reqCount = n; } - uint8_t GetRreqCnt () const { return m_reqCount; } - void IncrementRreqCnt () { m_reqCount++; } - void SetUnidirectional (bool u) { m_blackListState = u; } - bool IsUnidirectional () const { return m_blackListState; } - void SetBlacklistTimeout (Time t) { m_blackListTimeout = t; } - Time GetBlacklistTimeout () const { return m_blackListTimeout; } + /** + * Get destination address function + * \returns the IPv4 destiantion address + */ + Ipv4Address GetDestination () const + { + return m_ipv4Route->GetDestination (); + } + /** + * Get route function + * \returns The IPv4 route + */ + Ptr GetRoute () const + { + return m_ipv4Route; + } + /** + * Set route function + * \param r the IPv4 route + */ + void SetRoute (Ptr r) + { + m_ipv4Route = r; + } + /** + * Set next hop address + * \param nextHop the next hop IPv4 address + */ + void SetNextHop (Ipv4Address nextHop) + { + m_ipv4Route->SetGateway (nextHop); + } + /** + * Get next hop address + * \returns the next hop address + */ + Ipv4Address GetNextHop () const + { + return m_ipv4Route->GetGateway (); + } + /** + * Set output device + * \param dev The output device + */ + void SetOutputDevice (Ptr dev) + { + m_ipv4Route->SetOutputDevice (dev); + } + /** + * Get output device + * \returns the output device + */ + Ptr GetOutputDevice () const + { + return m_ipv4Route->GetOutputDevice (); + } + /** + * Get the Ipv4InterfaceAddress + * \returns the Ipv4InterfaceAddress + */ + Ipv4InterfaceAddress GetInterface () const + { + return m_iface; + } + /** + * Set the Ipv4InterfaceAddress + * \param iface The Ipv4InterfaceAddress + */ + void SetInterface (Ipv4InterfaceAddress iface) + { + m_iface = iface; + } + /** + * Set the valid sequence number + * \param s the sequence number + */ + void SetValidSeqNo (bool s) + { + m_validSeqNo = s; + } + /** + * Get the valid sequence number + * \returns the valid sequence number + */ + bool GetValidSeqNo () const + { + return m_validSeqNo; + } + /** + * Set the sequence number + * \param sn the sequence number + */ + void SetSeqNo (uint32_t sn) + { + m_seqNo = sn; + } + /** + * Get the sequence number + * \returns the sequence number + */ + uint32_t GetSeqNo () const + { + return m_seqNo; + } + /** + * Set the number of hops + * \param hop the number of hops + */ + void SetHop (uint16_t hop) + { + m_hops = hop; + } + /** + * Get the number of hops + * \returns the number of hops + */ + uint16_t GetHop () const + { + return m_hops; + } + /** + * Set the lifetime + * \param lt The lifetime + */ + void SetLifeTime (Time lt) + { + m_lifeTime = lt + Simulator::Now (); + } + /** + * Get the lifetime + * \returns the lifetime + */ + Time GetLifeTime () const + { + return m_lifeTime - Simulator::Now (); + } + /** + * Set the route flags + * \param flag the route flags + */ + void SetFlag (RouteFlags flag) + { + m_flag = flag; + } + /** + * Get the route flags + * \returns the route flags + */ + RouteFlags GetFlag () const + { + return m_flag; + } + /** + * Set the RREQ count + * \param n the RREQ count + */ + void SetRreqCnt (uint8_t n) + { + m_reqCount = n; + } + /** + * Get the RREQ count + * \returns the RREQ count + */ + uint8_t GetRreqCnt () const + { + return m_reqCount; + } + /** + * Increment the RREQ count + */ + void IncrementRreqCnt () + { + m_reqCount++; + } + /** + * Set the unidirectional flag + * \param u the uni directional flag + */ + void SetUnidirectional (bool u) + { + m_blackListState = u; + } + /** + * Get the unidirectional flag + * \returns the unidirectional flag + */ + bool IsUnidirectional () const + { + return m_blackListState; + } + /** + * Set the blacklist timeout + * \param t the blacklist timeout value + */ + void SetBlacklistTimeout (Time t) + { + m_blackListTimeout = t; + } + /** + * Get the blacklist timeout value + * \returns the blacklist timeout value + */ + Time GetBlacklistTimeout () const + { + return m_blackListTimeout; + } /// RREP_ACK timer Timer m_ackTimer; /** * \brief Compare destination address + * \param dst IP address to compare * \return true if equal */ bool operator== (Ipv4Address const dst) const { return (m_ipv4Route->GetDestination () == dst); } + /** + * Print packet to trace file + * \param stream The output stream + */ void Print (Ptr stream) const; private: @@ -151,7 +338,7 @@ class RoutingTableEntry uint16_t m_hops; /** * \brief Expiration or deletion time of the route - * Lifetime field in the routing table plays dual role -- + * Lifetime field in the routing table plays dual role: * for an active route it is the expiration time, and for an invalid route * it is the deletion time. */ @@ -191,8 +378,14 @@ class RoutingTable RoutingTable (Time t); ///\name Handle life time of invalid route //\{ - Time GetBadLinkLifetime () const { return m_badLinkLifetime; } - void SetBadLinkLifetime (Time t) { m_badLinkLifetime = t; } + Time GetBadLinkLifetime () const + { + return m_badLinkLifetime; + } + void SetBadLinkLifetime (Time t) + { + m_badLinkLifetime = t; + } //\} /** * Add routing table entry if it doesn't yet exist in routing table @@ -222,17 +415,21 @@ class RoutingTable /// Lookup routing entries with next hop Address dst and not empty list of precursors. void GetListOfDestinationWithNextHop (Ipv4Address nextHop, std::map & unreachable); /** - * Update routing entries with this destinations as follows: + * Update routing entries with this destination as follows: * 1. The destination sequence number of this routing entry, if it * exists and is valid, is incremented. * 2. The entry is invalidated by marking the route entry as invalid * 3. The Lifetime field is updated to current time plus DELETE_PERIOD. + * \param unreachable routes to invalidate */ void InvalidateRoutesWithDst (std::map const & unreachable); /// Delete all route from interface with address iface void DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface); /// Delete all entries from routing table - void Clear () { m_ipv4AddressEntry.clear (); } + void Clear () + { + m_ipv4AddressEntry.clear (); + } /// Delete all outdated entries and invalidate valid entry if Lifetime is expired void Purge (); /** Mark entry as unidirectional (e.g. add this neighbor to "blacklist" for blacklistTimeout period) @@ -245,6 +442,7 @@ class RoutingTable void Print (Ptr stream) const; private: + /// The routing table std::map m_ipv4AddressEntry; /// Deletion time for invalid routes Time m_badLinkLifetime; @@ -252,7 +450,7 @@ class RoutingTable void Purge (std::map &table) const; }; -} -} +} // namespace aodv +} // namespace ns3 #endif /* AODV_RTABLE_H */ From 8e57835333e46cb04076feb4376753e5e7814625 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 11 May 2017 11:54:04 -0700 Subject: [PATCH 046/551] aodv: Fix various Doxygen and coding style issues --- src/aodv/examples/aodv.cc | 16 +- src/aodv/test/aodv-id-cache-test-suite.cc | 46 +++-- src/aodv/test/aodv-regression.cc | 52 +++--- src/aodv/test/aodv-regression.h | 6 +- src/aodv/test/aodv-test-suite.cc | 207 +++++++++++++++++----- src/aodv/test/bug-772.cc | 34 ++-- src/aodv/test/bug-772.h | 6 +- src/aodv/test/loopback.cc | 56 +++--- 8 files changed, 301 insertions(+), 122 deletions(-) diff --git a/src/aodv/examples/aodv.cc b/src/aodv/examples/aodv.cc index e17c1a94cd7..b73b5204d1a 100644 --- a/src/aodv/examples/aodv.cc +++ b/src/aodv/examples/aodv.cc @@ -34,6 +34,8 @@ using namespace ns3; /** + * \ingroup aodv-examples + * \ingroup examples * \brief Test script. * * This script creates 1-dimensional grid topology and then ping last node from the first one: @@ -46,7 +48,12 @@ class AodvExample { public: AodvExample (); - /// Configure script parameters, \return true on successful configuration + /** + * \brief Configure script parameters + * \param argc is the command line argument count + * \param argv is the command line arguments + * \return true on successful configuration + */ bool Configure (int argc, char **argv); /// Run simulation void Run (); @@ -68,14 +75,21 @@ class AodvExample bool printRoutes; // network + /// nodes used in the example NodeContainer nodes; + /// devices used in the example NetDeviceContainer devices; + /// interfaces used in the example Ipv4InterfaceContainer interfaces; private: + /// Create the nodes void CreateNodes (); + /// Create the devices void CreateDevices (); + /// Create the network void InstallInternetStack (); + /// Create the simulation applications void InstallApplications (); }; diff --git a/src/aodv/test/aodv-id-cache-test-suite.cc b/src/aodv/test/aodv-id-cache-test-suite.cc index a57a18c9658..429077e7c0f 100644 --- a/src/aodv/test/aodv-id-cache-test-suite.cc +++ b/src/aodv/test/aodv-id-cache-test-suite.cc @@ -28,27 +28,39 @@ #include "ns3/aodv-id-cache.h" #include "ns3/test.h" -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { + +/** + * \ingroup aodv + * \defgroup aodv-test AODV module tests + */ -//----------------------------------------------------------------------------- -// Tests -//----------------------------------------------------------------------------- -/// Unit test for id cache + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for id cache + */ class IdCacheTest : public TestCase { public: - IdCacheTest () : TestCase ("Id Cache"), cache (Seconds (10)) - {} + IdCacheTest () : TestCase ("Id Cache"), + cache (Seconds (10)) + { + } virtual void DoRun (); private: + /// Timeout test function #1 void CheckTimeout1 (); + /// Timeout test function #2 void CheckTimeout2 (); + /// Timeout test function #3 void CheckTimeout3 (); + /// ID cache IdCache cache; }; @@ -92,7 +104,13 @@ IdCacheTest::CheckTimeout3 () { NS_TEST_EXPECT_MSG_EQ (cache.GetSize (), 0, "All records expire"); } -//----------------------------------------------------------------------------- + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Id Cache Test Suite + */ class IdCacheTestSuite : public TestSuite { public: @@ -100,7 +118,7 @@ class IdCacheTestSuite : public TestSuite { AddTestCase (new IdCacheTest, TestCase::QUICK); } -} g_idCacheTestSuite; +} g_idCacheTestSuite; ///< the test suite -} -} +} // namespace aodv +} // namespace ns3 diff --git a/src/aodv/test/aodv-regression.cc b/src/aodv/test/aodv-regression.cc index f181fbfad15..277f0866585 100644 --- a/src/aodv/test/aodv-regression.cc +++ b/src/aodv/test/aodv-regression.cc @@ -42,13 +42,16 @@ using namespace ns3; -//----------------------------------------------------------------------------- -// Test suite -//----------------------------------------------------------------------------- +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief AODV regression test suite + */ class AodvRegressionTestSuite : public TestSuite { public: - AodvRegressionTestSuite () : TestSuite ("routing-aodv-regression", SYSTEM) + AodvRegressionTestSuite () : TestSuite ("routing-aodv-regression", SYSTEM) { SetDataDir (NS_TEST_SOURCEDIR); // General RREQ-RREP-RRER test case @@ -58,21 +61,24 @@ class AodvRegressionTestSuite : public TestSuite // \bugid{772} UDP test case AddTestCase (new Bug772ChainTest ("udp-chain-test", "ns3::UdpSocketFactory", Seconds (3), 10), TestCase::QUICK); } -} g_aodvRegressionTestSuite; - - -//----------------------------------------------------------------------------- -// ChainRegressionTest -//----------------------------------------------------------------------------- -ChainRegressionTest::ChainRegressionTest (const char * const prefix, Time t, uint32_t size, Time arpAliveTimeout) : - TestCase ("AODV chain regression test"), - m_nodes (0), - m_prefix (prefix), - m_time (t), - m_size (size), - m_step (120), - m_arpAliveTimeout (arpAliveTimeout), - m_seq (0) +} g_aodvRegressionTestSuite; ///< the test suite + + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Chain Regression Test + */ +ChainRegressionTest::ChainRegressionTest (const char * const prefix, Time t, uint32_t size, Time arpAliveTimeout) + : TestCase ("AODV chain regression test"), + m_nodes (0), + m_prefix (prefix), + m_time (t), + m_size (size), + m_step (120), + m_arpAliveTimeout (arpAliveTimeout), + m_seq (0) { } @@ -165,17 +171,17 @@ ChainRegressionTest::CreateDevices () wifiPhy.Set ("TxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test // This test suite output was originally based on YansErrorRateModel - wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel"); + wifiPhy.SetErrorRateModel ("ns3::YansErrorRateModel"); WifiHelper wifi; wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate6Mbps"), "RtsCtsThreshold", StringValue ("2200")); - NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, *m_nodes); + NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, *m_nodes); // Assign fixed stream numbers to wifi and channel random variables streamsUsed += wifi.AssignStreams (devices, streamsUsed); // Assign 6 streams per device NS_TEST_ASSERT_MSG_EQ (streamsUsed, (devices.GetN () * 6), "Stream assignment mismatch"); streamsUsed += wifiChannel.AssignStreams (chan, streamsUsed); - // Assign 0 streams per channel for this configuration + // Assign 0 streams per channel for this configuration NS_TEST_ASSERT_MSG_EQ (streamsUsed, (devices.GetN () * 6), "Stream assignment mismatch"); // 2. Setup TCP/IP & AODV @@ -188,7 +194,7 @@ ChainRegressionTest::CreateDevices () NS_TEST_ASSERT_MSG_EQ (streamsUsed, (devices.GetN () * 8) + m_size, "Stream assignment mismatch"); streamsUsed += aodv.AssignStreams (*m_nodes, streamsUsed); // AODV uses m_size more streams - NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 8) + (2*m_size)), "Stream assignment mismatch"); + NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 8) + (2 * m_size)), "Stream assignment mismatch"); Ipv4AddressHelper address; address.SetBase ("10.1.1.0", "255.255.255.0"); diff --git a/src/aodv/test/aodv-regression.h b/src/aodv/test/aodv-regression.h index 79675d98cab..ec2abd8fb07 100644 --- a/src/aodv/test/aodv-regression.h +++ b/src/aodv/test/aodv-regression.h @@ -30,7 +30,7 @@ using namespace ns3; /** * \ingroup aodv - * + * * \brief AODV chain regression test * * This script creates 1-dimensional grid topology and then ping last node from the first one: @@ -42,7 +42,7 @@ using namespace ns3; * We want to demonstrate in this script * 1) route establishing * 2) broken link detection both from layer 2 information and hello messages. - * + * * \verbatim Expected packets time diagram. 1 2 3 4 5 @@ -155,7 +155,7 @@ class ChainRegressionTest : public TestCase public: /** * Create test case - * + * * \param prefix Unique file names prefix * \param size Number of nodes in the chain * \param time Simulation time diff --git a/src/aodv/test/aodv-test-suite.cc b/src/aodv/test/aodv-test-suite.cc index caa4d2e6a4a..47128288afd 100644 --- a/src/aodv/test/aodv-test-suite.cc +++ b/src/aodv/test/aodv-test-suite.cc @@ -24,20 +24,34 @@ #include "ns3/aodv-rtable.h" #include "ns3/ipv4-route.h" -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { -/// Unit test for neighbors +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for neighbors + */ struct NeighborTest : public TestCase { - NeighborTest () : TestCase ("Neighbor"), neighbor (0) { } + NeighborTest () : TestCase ("Neighbor"), + neighbor (0) + { + } virtual void DoRun (); + /** + * Handler test function + * \param addr the IPv4 address of the neighbor + */ void Handler (Ipv4Address addr); + /// Check timeout function 1 void CheckTimeout1 (); + /// Check timeout function 2 void CheckTimeout2 (); + /// Check timeout function 3 void CheckTimeout3 (); + /// The Neighbors Neighbors * neighbor; }; @@ -94,10 +108,16 @@ NeighborTest::DoRun () Simulator::Run (); Simulator::Destroy (); } -//----------------------------------------------------------------------------- + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Type header test case + */ struct TypeHeaderTest : public TestCase { - TypeHeaderTest () : TestCase ("AODV TypeHeader") + TypeHeaderTest () : TestCase ("AODV TypeHeader") { } virtual void DoRun () @@ -114,11 +134,16 @@ struct TypeHeaderTest : public TestCase NS_TEST_EXPECT_MSG_EQ (h, h2, "Round trip serialization works"); } }; -//----------------------------------------------------------------------------- -/// Unit test for RREQ + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for RREQ + */ struct RreqHeaderTest : public TestCase { - RreqHeaderTest () : TestCase ("AODV RREQ") + RreqHeaderTest () : TestCase ("AODV RREQ") { } virtual void DoRun () @@ -162,11 +187,18 @@ struct RreqHeaderTest : public TestCase } }; -//----------------------------------------------------------------------------- -/// Unit test for RREP + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for RREP + */ struct RrepHeaderTest : public TestCase { - RrepHeaderTest () : TestCase ("AODV RREP") {} + RrepHeaderTest () : TestCase ("AODV RREP") + { + } virtual void DoRun () { RrepHeader h (/*prefixSize*/ 0, /*hopCount*/ 12, /*dst*/ Ipv4Address ("1.2.3.4"), /*dstSeqNo*/ 2, @@ -207,8 +239,13 @@ struct RrepHeaderTest : public TestCase NS_TEST_EXPECT_MSG_EQ (h, h2, "Round trip serialization works"); } }; -//----------------------------------------------------------------------------- -/// Unit test for RREP-ACK + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for RREP-ACK + */ struct RrepAckHeaderTest : public TestCase { RrepAckHeaderTest () : TestCase ("AODV RREP-ACK") @@ -225,8 +262,13 @@ struct RrepAckHeaderTest : public TestCase NS_TEST_EXPECT_MSG_EQ (h, h2, "Round trip serialization works"); } }; -//----------------------------------------------------------------------------- -/// Unit test for RERR + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for RERR + */ struct RerrHeaderTest : public TestCase { RerrHeaderTest () : TestCase ("AODV RERR") @@ -253,15 +295,54 @@ struct RerrHeaderTest : public TestCase NS_TEST_EXPECT_MSG_EQ (h, h2, "Round trip serialization works"); } }; -//----------------------------------------------------------------------------- -/// Unit test for AODV routing table entry + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for AODV routing table entry + */ struct QueueEntryTest : public TestCase { - QueueEntryTest () : TestCase ("QueueEntry") {} - void Unicast (Ptr route, Ptr packet, const Ipv4Header & header) {} - void Error (Ptr, const Ipv4Header &, Socket::SocketErrno) {} - void Unicast2 (Ptr route, Ptr packet, const Ipv4Header & header) {} - void Error2 (Ptr, const Ipv4Header &, Socket::SocketErrno) {} + QueueEntryTest () : TestCase ("QueueEntry") + { + } + /** + * Unicast test function + * \param route the IPv4 route + * \param packet the packet + * \param header the IPv4 header + */ + void Unicast (Ptr route, Ptr packet, const Ipv4Header & header) + { + } + /** + * Error test function + * \param p The packet + * \param h The header + * \param e the socket error + */ + void Error (Ptr p, const Ipv4Header & h, Socket::SocketErrno e) + { + } + /** + * Unicast 2 testfunction + * \param route The IPv4 route + * \param packet The packet + * \param header The header + */ + void Unicast2 (Ptr route, Ptr packet, const Ipv4Header & header) + { + } + /** + * Error2 test function + * \param p The packet + * \param h The header + * \param e the socket error + */ + void Error2 (Ptr p, const Ipv4Header & h, Socket::SocketErrno e) + { + } virtual void DoRun () { Ptr packet = Create (); @@ -295,13 +376,35 @@ struct QueueEntryTest : public TestCase /// Unit test for RequestQueue struct AodvRqueueTest : public TestCase { - AodvRqueueTest () : TestCase ("Rqueue"), q (64, Seconds (30)) {} + AodvRqueueTest () : TestCase ("Rqueue"), + q (64, Seconds (30)) + { + } virtual void DoRun (); - void Unicast (Ptr route, Ptr packet, const Ipv4Header & header) {} - void Error (Ptr, const Ipv4Header &, Socket::SocketErrno) {} + /** + * Unicast test function + * \param route the IPv4 route + * \param packet the packet + * \param header the IPv4 header + */ + void Unicast (Ptr route, Ptr packet, const Ipv4Header & header) + { + } + /** + * Error test function + * \param p The packet + * \param h The header + * \param e the socket error + */ + void Error (Ptr p, const Ipv4Header & h, Socket::SocketErrno e) + { + } + /// Check size limit function void CheckSizeLimit (); + /// Check timeout function void CheckTimeout (); + /// Request queue RequestQueue q; }; @@ -374,11 +477,15 @@ AodvRqueueTest::CheckSizeLimit () QueueEntry e1 (packet, header, ucb, ecb, Seconds (1)); for (uint32_t i = 0; i < q.GetMaxQueueLen (); ++i) - q.Enqueue (e1); + { + q.Enqueue (e1); + } NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial"); for (uint32_t i = 0; i < q.GetMaxQueueLen (); ++i) - q.Enqueue (e1); + { + q.Enqueue (e1); + } NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial"); } @@ -387,11 +494,18 @@ AodvRqueueTest::CheckTimeout () { NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 0, "Must be empty now"); } -//----------------------------------------------------------------------------- -/// Unit test for AODV routing table entry + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for AODV routing table entry + */ struct AodvRtableEntryTest : public TestCase { - AodvRtableEntryTest () : TestCase ("RtableEntry") {} + AodvRtableEntryTest () : TestCase ("RtableEntry") + { + } virtual void DoRun () { Ptr dev; @@ -466,11 +580,18 @@ struct AodvRtableEntryTest : public TestCase Simulator::Destroy (); } }; -//----------------------------------------------------------------------------- -/// Unit test for AODV routing table + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief Unit test for AODV routing table + */ struct AodvRtableTest : public TestCase { - AodvRtableTest () : TestCase ("Rtable") {} + AodvRtableTest () : TestCase ("Rtable") + { + } virtual void DoRun () { RoutingTable rtable (Seconds (2)); @@ -519,7 +640,13 @@ struct AodvRtableTest : public TestCase Simulator::Destroy (); } }; -//----------------------------------------------------------------------------- + +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief AODV test suite + */ class AodvTestSuite : public TestSuite { public: @@ -536,7 +663,7 @@ class AodvTestSuite : public TestSuite AddTestCase (new AodvRtableEntryTest, TestCase::QUICK); AddTestCase (new AodvRtableTest, TestCase::QUICK); } -} g_aodvTestSuite; +} g_aodvTestSuite; ///< the test suite -} -} +} // namespace aodv +} // namespace ns3 diff --git a/src/aodv/test/bug-772.cc b/src/aodv/test/bug-772.cc index c9b57f723c6..79492bcf509 100644 --- a/src/aodv/test/bug-772.cc +++ b/src/aodv/test/bug-772.cc @@ -48,16 +48,16 @@ using namespace ns3; //----------------------------------------------------------------------------- // UdpChainTest //----------------------------------------------------------------------------- -Bug772ChainTest::Bug772ChainTest (const char * const prefix, const char * const proto, Time t, uint32_t size) : - TestCase ("Bug 772 UDP and TCP chain regression test"), - m_nodes (0), - m_prefix (prefix), - m_proto (proto), - m_time (t), - m_size (size), - m_step (120), - m_port (9), - m_receivedPackets (0) +Bug772ChainTest::Bug772ChainTest (const char * const prefix, const char * const proto, Time t, uint32_t size) + : TestCase ("Bug 772 UDP and TCP chain regression test"), + m_nodes (0), + m_prefix (prefix), + m_proto (proto), + m_time (t), + m_size (size), + m_step (120), + m_port (9), + m_receivedPackets (0) { } @@ -89,8 +89,8 @@ Bug772ChainTest::DoRun () RngSeedManager::SetSeed (12345); RngSeedManager::SetRun (7); - // Default of 3 will cause packet loss - Config::SetDefault ("ns3::ArpCache::PendingQueueSize", UintegerValue (10)); + // Default of 3 will cause packet loss + Config::SetDefault ("ns3::ArpCache::PendingQueueSize", UintegerValue (10)); CreateNodes (); CreateDevices (); @@ -138,14 +138,14 @@ Bug772ChainTest::CreateDevices () wifiPhy.Set ("RxGain", DoubleValue (1.0)); //this configuration should go away in future revision to the test WifiHelper wifi; wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate6Mbps"), "RtsCtsThreshold", StringValue ("2200")); - NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, *m_nodes); + NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, *m_nodes); // Assign fixed stream numbers to wifi and channel random variables streamsUsed += wifi.AssignStreams (devices, streamsUsed); // Assign 6 streams per device NS_TEST_ASSERT_MSG_EQ (streamsUsed, (devices.GetN () * 6), "Stream assignment mismatch"); streamsUsed += wifiChannel.AssignStreams (chan, streamsUsed); - // Assign 0 streams per channel for this configuration + // Assign 0 streams per channel for this configuration NS_TEST_ASSERT_MSG_EQ (streamsUsed, (devices.GetN () * 6), "Stream assignment mismatch"); // 2. Setup TCP/IP & AODV @@ -155,10 +155,10 @@ Bug772ChainTest::CreateDevices () internetStack.Install (*m_nodes); streamsUsed += internetStack.AssignStreams (*m_nodes, streamsUsed); // Expect to use (3*m_size) more streams for internet stack random variables - NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 6) + (3*m_size)), "Stream assignment mismatch"); + NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 6) + (3 * m_size)), "Stream assignment mismatch"); streamsUsed += aodv.AssignStreams (*m_nodes, streamsUsed); // Expect to use m_size more streams for AODV - NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 6) + (3*m_size) + m_size), "Stream assignment mismatch"); + NS_TEST_ASSERT_MSG_EQ (streamsUsed, ((devices.GetN () * 6) + (3 * m_size) + m_size), "Stream assignment mismatch"); Ipv4AddressHelper address; address.SetBase ("10.1.1.0", "255.255.255.0"); Ipv4InterfaceContainer interfaces = address.Assign (devices); @@ -166,7 +166,7 @@ Bug772ChainTest::CreateDevices () // 3. Setup UDP source and sink m_sendSocket = Socket::CreateSocket (m_nodes->Get (0), TypeId::LookupByName (m_proto)); m_sendSocket->Bind (); - m_sendSocket->Connect (InetSocketAddress (interfaces.GetAddress (m_size-1), m_port)); + m_sendSocket->Connect (InetSocketAddress (interfaces.GetAddress (m_size - 1), m_port)); m_sendSocket->SetAllowBroadcast (true); Simulator::ScheduleWithContext (m_sendSocket->GetNode ()->GetId (), Seconds (1.0), &Bug772ChainTest::SendData, this, m_sendSocket); diff --git a/src/aodv/test/bug-772.h b/src/aodv/test/bug-772.h index 4d58f1aa596..ec782da347e 100644 --- a/src/aodv/test/bug-772.h +++ b/src/aodv/test/bug-772.h @@ -30,9 +30,9 @@ using namespace ns3; /** * \ingroup aodv - * + * * \brief AODV deferred route lookup test case (see \bugid{772}) - * + * * UDP packet transfers are delayed while a route is found and then while * ARP completes. Eight packets should be sent, queued until the path * becomes functional, and then delivered. @@ -42,7 +42,7 @@ class Bug772ChainTest : public TestCase public: /** * Create test case - * + * * \param prefix Unique file names prefix * \param proto ns3::UdpSocketFactory or ns3::TcpSocketFactory * \param size Number of nodes in the chain diff --git a/src/aodv/test/loopback.cc b/src/aodv/test/loopback.cc index 4740a7b94f0..9949d5787fd 100644 --- a/src/aodv/test/loopback.cc +++ b/src/aodv/test/loopback.cc @@ -41,10 +41,8 @@ #include "ns3/names.h" #include -namespace ns3 -{ -namespace aodv -{ +namespace ns3 { +namespace aodv { /** * \ingroup aodv @@ -54,14 +52,26 @@ namespace aodv class LoopbackTestCase : public TestCase { uint32_t m_count; //!< number of packet received; - Ptr m_txSocket; - Ptr m_echoSocket; - Ptr m_rxSocket; - uint16_t m_echoSendPort; - uint16_t m_echoReplyPort; - + Ptr m_txSocket; //!< transmit socket; + Ptr m_echoSocket; //!< echo socket; + Ptr m_rxSocket; //!< receive socket; + uint16_t m_echoSendPort; //!< echo send port; + uint16_t m_echoReplyPort; //!< echo reply port; + + /** + * Send data function + * \param socket The socket to send data + */ void SendData (Ptr socket); + /** + * Receive packet function + * \param socket The socket to receive data + */ void ReceivePkt (Ptr socket); + /** + * Echo data function + * \param socket The socket to echo data + */ void EchoData (Ptr socket); public: @@ -69,8 +79,9 @@ class LoopbackTestCase : public TestCase void DoRun (); }; -LoopbackTestCase::LoopbackTestCase () : - TestCase ("UDP Echo 127.0.0.1 test"), m_count (0) +LoopbackTestCase::LoopbackTestCase () + : TestCase ("UDP Echo 127.0.0.1 test"), + m_count (0) { m_echoSendPort = 1233; m_echoReplyPort = 1234; @@ -80,7 +91,7 @@ void LoopbackTestCase::ReceivePkt (Ptr socket) { Ptr receivedPacket = socket->Recv (std::numeric_limits::max (), 0); - m_count ++; + m_count++; } void @@ -124,7 +135,7 @@ LoopbackTestCase::DoRun () wifiPhy.SetChannel (wifiChannel.Create ()); WifiHelper wifi; wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("OfdmRate6Mbps"), "RtsCtsThreshold", StringValue ("2200")); - NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, nodes); + NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, nodes); // Setup TCP/IP & AODV AodvHelper aodv; // Use default parameters here @@ -150,7 +161,7 @@ LoopbackTestCase::DoRun () Simulator::ScheduleWithContext (m_txSocket->GetNode ()->GetId (), Seconds (1.0), &LoopbackTestCase::SendData, this, m_txSocket); - // Run + // Run Simulator::Stop (Seconds (5)); Simulator::Run (); @@ -164,9 +175,12 @@ LoopbackTestCase::DoRun () NS_TEST_ASSERT_MSG_EQ (m_count, 4, "Exactly 4 echo replies must be delivered."); } -//----------------------------------------------------------------------------- -// Test suite -//----------------------------------------------------------------------------- +/** + * \ingroup aodv-test + * \ingroup tests + * + * \brief AODV Loopback test suite + */ class AodvLoopbackTestSuite : public TestSuite { public: @@ -176,8 +190,8 @@ class AodvLoopbackTestSuite : public TestSuite // UDP Echo loopback test case AddTestCase (new LoopbackTestCase (), TestCase::QUICK); } -} g_aodvLoopbackTestSuite; +} g_aodvLoopbackTestSuite; ///< the test suite -} -} +} // namespace aodv +} // namespace ns3 From 7600254f3de4110f01cf76d5c896a05372940654 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 11 May 2017 12:59:17 -0700 Subject: [PATCH 047/551] aodv: Fix some misspelled methods --- src/aodv/model/aodv-packet.cc | 6 +++--- src/aodv/model/aodv-packet.h | 4 ++-- src/aodv/model/aodv-routing-protocol.cc | 8 ++++---- src/aodv/model/aodv-routing-protocol.h | 4 ++-- src/aodv/test/aodv-test-suite.cc | 6 +++--- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/aodv/model/aodv-packet.cc b/src/aodv/model/aodv-packet.cc index 4a54a2ecd17..08cb170f7d1 100644 --- a/src/aodv/model/aodv-packet.cc +++ b/src/aodv/model/aodv-packet.cc @@ -214,7 +214,7 @@ RreqHeader::Print (std::ostream &os) const os << "RREQ ID " << m_requestID << " destination: ipv4 " << m_dst << " sequence number " << m_dstSeqNo << " source: ipv4 " << m_origin << " sequence number " << m_originSeqNo - << " flags:" << " Gratuitous RREP " << (*this).GetGratiousRrep () + << " flags:" << " Gratuitous RREP " << (*this).GetGratuitousRrep () << " Destination only " << (*this).GetDestinationOnly () << " Unknown sequence number " << (*this).GetUnknownSeqno (); } @@ -227,7 +227,7 @@ operator<< (std::ostream & os, RreqHeader const & h) } void -RreqHeader::SetGratiousRrep (bool f) +RreqHeader::SetGratuitousRrep (bool f) { if (f) { @@ -240,7 +240,7 @@ RreqHeader::SetGratiousRrep (bool f) } bool -RreqHeader::GetGratiousRrep () const +RreqHeader::GetGratuitousRrep () const { return (m_flags & (1 << 5)); } diff --git a/src/aodv/model/aodv-packet.h b/src/aodv/model/aodv-packet.h index 592da5b74de..ad0a191d35c 100644 --- a/src/aodv/model/aodv-packet.h +++ b/src/aodv/model/aodv-packet.h @@ -243,12 +243,12 @@ class RreqHeader : public Header * \brief Set the gratuitous RREP flag * \param f the gratuitous RREP flag */ - void SetGratiousRrep (bool f); + void SetGratuitousRrep (bool f); /** * \brief Get the gratuitous RREP flag * \return the gratuitous RREP flag */ - bool GetGratiousRrep () const; + bool GetGratuitousRrep () const; /** * \brief Set the Destination only flag * \param f the Destiantion only flag diff --git a/src/aodv/model/aodv-routing-protocol.cc b/src/aodv/model/aodv-routing-protocol.cc index 6d627e37a0f..dc67f88fba0 100644 --- a/src/aodv/model/aodv-routing-protocol.cc +++ b/src/aodv/model/aodv-routing-protocol.cc @@ -277,8 +277,8 @@ RoutingProtocol::GetTypeId (void) MakeBooleanChecker ()) .AddAttribute ("DestinationOnly", "Indicates only the destination may respond to this RREQ.", BooleanValue (false), - MakeBooleanAccessor (&RoutingProtocol::SetDesinationOnlyFlag, - &RoutingProtocol::GetDesinationOnlyFlag), + MakeBooleanAccessor (&RoutingProtocol::SetDestinationOnlyFlag, + &RoutingProtocol::GetDestinationOnlyFlag), MakeBooleanChecker ()) .AddAttribute ("EnableHello", "Indicates whether a hello messages enable.", BooleanValue (true), @@ -1027,7 +1027,7 @@ RoutingProtocol::SendRequest (Ipv4Address dst) if (m_gratuitousReply) { - rreqHeader.SetGratiousRrep (true); + rreqHeader.SetGratuitousRrep (true); } if (m_destinationOnly) { @@ -1358,7 +1358,7 @@ RoutingProtocol::RecvRequest (Ptr p, Ipv4Address receiver, Ipv4Address s if (!rreqHeader.GetDestinationOnly () && toDst.GetFlag () == VALID) { m_routingTable.LookupRoute (origin, toOrigin); - SendReplyByIntermediateNode (toDst, toOrigin, rreqHeader.GetGratiousRrep ()); + SendReplyByIntermediateNode (toDst, toOrigin, rreqHeader.GetGratuitousRrep ()); return; } rreqHeader.SetDstSeqno (toDst.GetSeqNo ()); diff --git a/src/aodv/model/aodv-routing-protocol.h b/src/aodv/model/aodv-routing-protocol.h index 476eb66e13d..86422b12720 100644 --- a/src/aodv/model/aodv-routing-protocol.h +++ b/src/aodv/model/aodv-routing-protocol.h @@ -106,7 +106,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol * Get destination only flag * \returns the destination only flag */ - bool GetDesinationOnlyFlag () const + bool GetDestinationOnlyFlag () const { return m_destinationOnly; } @@ -114,7 +114,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol * Set destination only flag * \param f the destination only flag */ - void SetDesinationOnlyFlag (bool f) + void SetDestinationOnlyFlag (bool f) { m_destinationOnly = f; } diff --git a/src/aodv/test/aodv-test-suite.cc b/src/aodv/test/aodv-test-suite.cc index 47128288afd..cf0db0a473f 100644 --- a/src/aodv/test/aodv-test-suite.cc +++ b/src/aodv/test/aodv-test-suite.cc @@ -150,7 +150,7 @@ struct RreqHeaderTest : public TestCase { RreqHeader h (/*flags*/ 0, /*reserved*/ 0, /*hopCount*/ 6, /*requestID*/ 1, /*dst*/ Ipv4Address ("1.2.3.4"), /*dstSeqNo*/ 40, /*origin*/ Ipv4Address ("4.3.2.1"), /*originSeqNo*/ 10); - NS_TEST_EXPECT_MSG_EQ (h.GetGratiousRrep (), false, "trivial"); + NS_TEST_EXPECT_MSG_EQ (h.GetGratuitousRrep (), false, "trivial"); NS_TEST_EXPECT_MSG_EQ (h.GetDestinationOnly (), false, "trivial"); NS_TEST_EXPECT_MSG_EQ (h.GetHopCount (), 6, "trivial"); NS_TEST_EXPECT_MSG_EQ (h.GetId (), 1, "trivial"); @@ -159,8 +159,8 @@ struct RreqHeaderTest : public TestCase NS_TEST_EXPECT_MSG_EQ (h.GetOrigin (), Ipv4Address ("4.3.2.1"), "trivial"); NS_TEST_EXPECT_MSG_EQ (h.GetOriginSeqno (), 10, "trivial"); - h.SetGratiousRrep (true); - NS_TEST_EXPECT_MSG_EQ (h.GetGratiousRrep (), true, "trivial"); + h.SetGratuitousRrep (true); + NS_TEST_EXPECT_MSG_EQ (h.GetGratuitousRrep (), true, "trivial"); h.SetDestinationOnly (true); NS_TEST_EXPECT_MSG_EQ (h.GetDestinationOnly (), true, "trivial"); h.SetUnknownSeqno (true); From be2f49a23eb0534c2d48b2a7d8449f3cb514759b Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 11 May 2017 13:17:33 -0700 Subject: [PATCH 048/551] aodv: Rescan bindings --- src/aodv/bindings/modulegen__gcc_ILP32.py | 23 ++++++++++++++--------- src/aodv/bindings/modulegen__gcc_LP64.py | 23 ++++++++++++++--------- 2 files changed, 28 insertions(+), 18 deletions(-) diff --git a/src/aodv/bindings/modulegen__gcc_ILP32.py b/src/aodv/bindings/modulegen__gcc_ILP32.py index 1a0fff2545e..bef68afd0f0 100644 --- a/src/aodv/bindings/modulegen__gcc_ILP32.py +++ b/src/aodv/bindings/modulegen__gcc_ILP32.py @@ -5139,10 +5139,15 @@ def register_Ns3ArpCacheEntry_methods(root_module, cls): cls.add_method('SetIpv4Address', 'void', [param('ns3::Ipv4Address', 'destination')]) + ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddress(ns3::Address macAddress) [member function] + cls.add_method('SetMacAddress', + 'void', + [param('ns3::Address', 'macAddress')]) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddresss(ns3::Address macAddress) [member function] cls.add_method('SetMacAddresss', 'void', - [param('ns3::Address', 'macAddress')]) + [param('ns3::Address', 'macAddress')], + deprecated=True) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::UpdateSeen() [member function] cls.add_method('UpdateSeen', 'void', @@ -7804,8 +7809,8 @@ def register_Ns3AodvRoutingProtocol_methods(root_module, cls): 'bool', [], is_const=True) - ## aodv-routing-protocol.h (module 'aodv'): bool ns3::aodv::RoutingProtocol::GetDesinationOnlyFlag() const [member function] - cls.add_method('GetDesinationOnlyFlag', + ## aodv-routing-protocol.h (module 'aodv'): bool ns3::aodv::RoutingProtocol::GetDestinationOnlyFlag() const [member function] + cls.add_method('GetDestinationOnlyFlag', 'bool', [], is_const=True) @@ -7873,8 +7878,8 @@ def register_Ns3AodvRoutingProtocol_methods(root_module, cls): cls.add_method('SetBroadcastEnable', 'void', [param('bool', 'f')]) - ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetDesinationOnlyFlag(bool f) [member function] - cls.add_method('SetDesinationOnlyFlag', + ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetDestinationOnlyFlag(bool f) [member function] + cls.add_method('SetDestinationOnlyFlag', 'void', [param('bool', 'f')]) ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetGratuitousReplyFlag(bool f) [member function] @@ -8309,8 +8314,8 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## aodv-packet.h (module 'aodv'): bool ns3::aodv::RreqHeader::GetGratiousRrep() const [member function] - cls.add_method('GetGratiousRrep', + ## aodv-packet.h (module 'aodv'): bool ns3::aodv::RreqHeader::GetGratuitousRrep() const [member function] + cls.add_method('GetGratuitousRrep', 'bool', [], is_const=True) @@ -8376,8 +8381,8 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls): cls.add_method('SetDstSeqno', 'void', [param('uint32_t', 's')]) - ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetGratiousRrep(bool f) [member function] - cls.add_method('SetGratiousRrep', + ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetGratuitousRrep(bool f) [member function] + cls.add_method('SetGratuitousRrep', 'void', [param('bool', 'f')]) ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetHopCount(uint8_t count) [member function] diff --git a/src/aodv/bindings/modulegen__gcc_LP64.py b/src/aodv/bindings/modulegen__gcc_LP64.py index 1a0fff2545e..bef68afd0f0 100644 --- a/src/aodv/bindings/modulegen__gcc_LP64.py +++ b/src/aodv/bindings/modulegen__gcc_LP64.py @@ -5139,10 +5139,15 @@ def register_Ns3ArpCacheEntry_methods(root_module, cls): cls.add_method('SetIpv4Address', 'void', [param('ns3::Ipv4Address', 'destination')]) + ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddress(ns3::Address macAddress) [member function] + cls.add_method('SetMacAddress', + 'void', + [param('ns3::Address', 'macAddress')]) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddresss(ns3::Address macAddress) [member function] cls.add_method('SetMacAddresss', 'void', - [param('ns3::Address', 'macAddress')]) + [param('ns3::Address', 'macAddress')], + deprecated=True) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::UpdateSeen() [member function] cls.add_method('UpdateSeen', 'void', @@ -7804,8 +7809,8 @@ def register_Ns3AodvRoutingProtocol_methods(root_module, cls): 'bool', [], is_const=True) - ## aodv-routing-protocol.h (module 'aodv'): bool ns3::aodv::RoutingProtocol::GetDesinationOnlyFlag() const [member function] - cls.add_method('GetDesinationOnlyFlag', + ## aodv-routing-protocol.h (module 'aodv'): bool ns3::aodv::RoutingProtocol::GetDestinationOnlyFlag() const [member function] + cls.add_method('GetDestinationOnlyFlag', 'bool', [], is_const=True) @@ -7873,8 +7878,8 @@ def register_Ns3AodvRoutingProtocol_methods(root_module, cls): cls.add_method('SetBroadcastEnable', 'void', [param('bool', 'f')]) - ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetDesinationOnlyFlag(bool f) [member function] - cls.add_method('SetDesinationOnlyFlag', + ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetDestinationOnlyFlag(bool f) [member function] + cls.add_method('SetDestinationOnlyFlag', 'void', [param('bool', 'f')]) ## aodv-routing-protocol.h (module 'aodv'): void ns3::aodv::RoutingProtocol::SetGratuitousReplyFlag(bool f) [member function] @@ -8309,8 +8314,8 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## aodv-packet.h (module 'aodv'): bool ns3::aodv::RreqHeader::GetGratiousRrep() const [member function] - cls.add_method('GetGratiousRrep', + ## aodv-packet.h (module 'aodv'): bool ns3::aodv::RreqHeader::GetGratuitousRrep() const [member function] + cls.add_method('GetGratuitousRrep', 'bool', [], is_const=True) @@ -8376,8 +8381,8 @@ def register_Ns3AodvRreqHeader_methods(root_module, cls): cls.add_method('SetDstSeqno', 'void', [param('uint32_t', 's')]) - ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetGratiousRrep(bool f) [member function] - cls.add_method('SetGratiousRrep', + ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetGratuitousRrep(bool f) [member function] + cls.add_method('SetGratuitousRrep', 'void', [param('bool', 'f')]) ## aodv-packet.h (module 'aodv'): void ns3::aodv::RreqHeader::SetHopCount(uint8_t count) [member function] From 1030751455e896149a9dccc75519e03ae3f8bfbf Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Fri, 12 May 2017 07:41:42 -0700 Subject: [PATCH 049/551] wifi: Break reference cycles for valgrind --- src/wifi/examples/test-interference-helper.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/wifi/examples/test-interference-helper.cc b/src/wifi/examples/test-interference-helper.cc index 87b5781a52a..215eced0590 100644 --- a/src/wifi/examples/test-interference-helper.cc +++ b/src/wifi/examples/test-interference-helper.cc @@ -229,6 +229,9 @@ InterferenceExperiment::Run (struct InterferenceExperiment::Input input) Simulator::Run (); Simulator::Destroy (); + m_txB->Dispose (); + m_txA->Dispose (); + rx->Dispose (); if(checkResults && (m_droppedA == expectRxASuccessfull || m_droppedB == expectRxBSuccessfull)) { From dfe5fb5ca992b36c79b7b0888803e90ae08ce567 Mon Sep 17 00:00:00 2001 From: "Peter D. Barnes, Jr." Date: Fri, 12 May 2017 10:29:43 -0700 Subject: [PATCH 050/551] tcp: doxy: correct formal args in callback typedef --- src/internet/model/tcp-socket-base.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/internet/model/tcp-socket-base.h b/src/internet/model/tcp-socket-base.h index 755474e803f..fff9eb0f8d7 100644 --- a/src/internet/model/tcp-socket-base.h +++ b/src/internet/model/tcp-socket-base.h @@ -484,8 +484,8 @@ class TcpSocketBase : public TcpSocket * TracedCallback signature for tcp packet transmission or reception events. * * \param [in] packet The packet. - * \param [in] ipv4 - * \param [in] interface + * \param [in] header The TcpHeader + * \param [in] socket This socket */ typedef void (* TcpTxRxTracedCallback)(const Ptr packet, const TcpHeader& header, const Ptr socket); From fcedeea0cf689a9e740f4bca700e5d6bae28b2cb Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 15 May 2017 02:36:07 +0200 Subject: [PATCH 051/551] dsr: doxygen updates --- src/dsr/model/dsr-errorbuff.h | 45 ++++++++++++++++++---- src/dsr/model/dsr-gratuitous-reply-table.h | 12 +++++- src/dsr/model/dsr-maintain-buff.h | 28 ++++++++++++-- src/dsr/model/dsr-option-header.h | 2 + src/dsr/model/dsr-options.h | 1 + src/dsr/model/dsr-passive-buff.h | 21 +++++++++- src/dsr/model/dsr-rcache.h | 22 ++++++++--- src/dsr/model/dsr-routing.h | 26 +++++++++++-- src/dsr/model/dsr-rreq-table.cc | 8 ++-- src/dsr/model/dsr-rreq-table.h | 6 ++- src/dsr/model/dsr-rsendbuff.h | 7 +++- src/dsr/test/dsr-test-suite.cc | 2 +- 12 files changed, 152 insertions(+), 28 deletions(-) diff --git a/src/dsr/model/dsr-errorbuff.h b/src/dsr/model/dsr-errorbuff.h index 31d81ac2f77..a3ee87688fa 100644 --- a/src/dsr/model/dsr-errorbuff.h +++ b/src/dsr/model/dsr-errorbuff.h @@ -209,13 +209,29 @@ class DsrErrorBuffer * \return true if entry added */ bool Enqueue (DsrErrorBuffEntry & entry); - /// Return first found (the earliest) entry for given destination + /** + * Return first found (the earliest) entry for given destination + * \param [in] dst The destination to look for + * \param [out] entry The entry + * \return true if an entry is found + */ bool Dequeue (Ipv4Address dst, DsrErrorBuffEntry & entry); - /// Remove all packets with the error link + /** + * Remove all packets with the error link + * \param source The source + * \param nextHop The next hop + */ void DropPacketForErrLink (Ipv4Address source, Ipv4Address nextHop); - /// Finds whether a packet with destination dst exists in the queue + /** + * Finds whether a packet with destination dst exists in the queue + * \param dst The destination + * \return true if a packet is found. + */ bool Find (Ipv4Address dst); - /// Number of entries + /** + * Returns the number of entries in the queue. + * \return the number of entries in the queue. + */ uint32_t GetSize (); // Fields @@ -265,15 +281,30 @@ class DsrErrorBuffer std::vector m_errorBuffer; /// Remove all expired entries void Purge (); - /// Notify that packet is dropped from queue by timeout + /** + * Notify that packet is dropped from queue by timeout + * \param en Error Buffer Entry + * \param reason Drop reason. + */ + /// void Drop (DsrErrorBuffEntry en, std::string reason); - /// Notify that packet is dropped from queue by timeout + /** + * Notify that packet is dropped from queue by link error + * \param en Error Buffer Entry + * \param reason Drop reason. + */ void DropLink (DsrErrorBuffEntry en, std::string reason); /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_errorBufferTimeout; - /// Check if the send buffer entry is the same or not + /** + * Check if the send buffer entry is the same or not + * \param en Buffer Entry + * \param link Link description. + * \return true if the entry is compatible with the link description (source and next hop) + */ + /// static bool LinkEqual (DsrErrorBuffEntry en, const std::vector link) { return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1])); diff --git a/src/dsr/model/dsr-gratuitous-reply-table.h b/src/dsr/model/dsr-gratuitous-reply-table.h index bd36e8914cd..30a972129aa 100644 --- a/src/dsr/model/dsr-gratuitous-reply-table.h +++ b/src/dsr/model/dsr-gratuitous-reply-table.h @@ -56,7 +56,7 @@ struct GraReplyEntry * * \param t IPv4 address to reply to * \param f IPv4 address to hear from - * \param h gratitious hold off time + * \param h gratuitous hold off time */ GraReplyEntry (Ipv4Address t, Ipv4Address f, Time h) : m_replyTo (t), @@ -82,18 +82,26 @@ class DsrGraReply : public Object virtual ~DsrGraReply (); /// Set the gratuitous reply table size + /// \param g The gratuitous reply table size void SetGraTableSize (uint32_t g) { GraReplyTableSize = g; } /// Get the gratuitous reply table size + /// \returns The gratuitous reply table size uint32_t GetGraTableSize () const { return GraReplyTableSize; } /// Add a new gratuitous reply entry + /// \param graTableEntry The gratuitous reply entry + /// \return true on success bool AddEntry (GraReplyEntry & graTableEntry); - /// Update the route entry if found, create a new one if not + /// Update the route entry if found + /// \param replyTo Entry directed to + /// \param replyFrom Entry heard from + /// \param gratReplyHoldoff New gratuitous reply holdoff time + /// \return true on success bool FindAndUpdate (Ipv4Address replyTo, Ipv4Address replyFrom, Time gratReplyHoldoff); /// Remove all expired entries void Purge (); diff --git a/src/dsr/model/dsr-maintain-buff.h b/src/dsr/model/dsr-maintain-buff.h index a68e5f27733..4319bbf71e7 100644 --- a/src/dsr/model/dsr-maintain-buff.h +++ b/src/dsr/model/dsr-maintain-buff.h @@ -401,14 +401,23 @@ class DsrMaintainBuffer { } /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + /// \param entry Maintain Buffer Entry + /// \return true on success adding the Entry. bool Enqueue (DsrMaintainBuffEntry & entry); /// Return first found (the earliest) entry for given destination + /// \param [in] dst Entry destination + /// \param [out] entry The Entry found (if any). + /// \return true on success bool Dequeue (Ipv4Address dst, DsrMaintainBuffEntry & entry); - /// Remove all packets with destination IP address dst + /// Remove all packets with next hop IP address dst + /// \param nextHop Next hop in the route. void DropPacketWithNextHop (Ipv4Address nextHop); - /// Finds whether a packet with destination dst exists in the queue + /// Finds whether a packet with next hop dst exists in the queue + /// \param nextHop Next hop in the route. + /// \return true if there is a packet directed to the next hop. bool Find (Ipv4Address nextHop); /// Number of entries + /// \return The number of entries. uint32_t GetSize (); // Fields @@ -444,13 +453,23 @@ class DsrMaintainBuffer { m_maintainBufferTimeout = t; } - /// Verify if all the elements in the maintainence buffer entry is the same + /// Verify if all the elements in the maintenance buffer entry is the same + /// \note For real this function checks if at most one entry is equal. If it is, + /// that entry is removed. Further entries are NOT checked. This could be a bug. + /// \param entry The Entry to check + /// \return true if an Entry was found and removed. bool AllEqual (DsrMaintainBuffEntry & entry); /// Verify if the maintain buffer entry is the same in every field for link ack + /// \param entry The Entry to check + /// \return true if an Entry was found and removed. bool LinkEqual (DsrMaintainBuffEntry & entry); /// Verify if the maintain buffer entry is the same in every field for network ack + /// \param entry The Entry to check + /// \return true if an Entry was found and removed. bool NetworkEqual (DsrMaintainBuffEntry & entry); /// Verify if the maintain buffer entry is the same in every field for promiscuous ack + /// \param entry The Entry to check + /// \return true if an Entry was found and removed. bool PromiscEqual (DsrMaintainBuffEntry & entry); private: @@ -465,6 +484,9 @@ class DsrMaintainBuffer /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_maintainBufferTimeout; /// Verify if the maintain buffer is equal or not + /// \param en The Entry to check + /// \param nextHop The next hop to check + /// \return true if an Entry next hop is equal to the function second parameter static bool IsEqual (DsrMaintainBuffEntry en, const Ipv4Address nextHop) { return (en.GetNextHop () == nextHop); diff --git a/src/dsr/model/dsr-option-header.h b/src/dsr/model/dsr-option-header.h index 1f616089e92..ea7fc8cc62f 100644 --- a/src/dsr/model/dsr-option-header.h +++ b/src/dsr/model/dsr-option-header.h @@ -774,6 +774,7 @@ class DsrOptionRerrHeader : public DsrOptionHeader virtual Ipv4Address GetErrorSrc () const; /** * \brief Set the salvage value of the packet + * \param salvage The salvage value of the packet */ virtual void SetSalvage (uint8_t salvage); /** @@ -909,6 +910,7 @@ class DsrOptionRerrUnreachHeader : public DsrOptionRerrHeader virtual Ipv4Address GetErrorSrc () const; /** * \brief Set the salvage value of the packet + * \param salvage The salvage value of the packet */ virtual void SetSalvage (uint8_t salvage); /** diff --git a/src/dsr/model/dsr-options.h b/src/dsr/model/dsr-options.h index 917e17f9f5b..33f2f401b97 100644 --- a/src/dsr/model/dsr-options.h +++ b/src/dsr/model/dsr-options.h @@ -161,6 +161,7 @@ class DsrOptions : public Object Ipv4Address ReverseSearchNextTwoHop (Ipv4Address ipv4Address, std::vector& vec); /** * \brief Print out the elements in the route vector + * \param vec The route vector to print. */ void PrintVector (std::vector& vec); /** diff --git a/src/dsr/model/dsr-passive-buff.h b/src/dsr/model/dsr-passive-buff.h index 3e509099dfc..4dc3f198793 100644 --- a/src/dsr/model/dsr-passive-buff.h +++ b/src/dsr/model/dsr-passive-buff.h @@ -268,14 +268,26 @@ class DsrPassiveBuffer : public Object virtual ~DsrPassiveBuffer (); /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + /// \param entry Buffer Entry + /// \return true on success adding the Entry. bool Enqueue (DsrPassiveBuffEntry & entry); /// Return first found (the earliest) entry for given destination + /// \param [in] dst Entry destination + /// \param [out] entry The Entry found (if any). + /// \return true on success bool Dequeue (Ipv4Address dst, DsrPassiveBuffEntry & entry); /// Finds whether a packet with destination dst exists in the queue - bool Find (Ipv4Address dst); + /// \param dst Destination. + /// \return true if there is a packet. + bool Find (Ipv4Address dst); /// Check if all the entries in passive buffer entry is all equal or not + /// \note For real this function checks if at most one entry is equal. If it is, + /// that entry is removed. Further entries are NOT checked. This could be a bug. + /// \param entry The Entry to check + /// \return true if an Entry was found and removed. bool AllEqual (DsrPassiveBuffEntry & entry); /// Number of entries + /// \return The number of entries. uint32_t GetSize (); // Fields @@ -318,14 +330,21 @@ class DsrPassiveBuffer : public Object /// Remove all expired entries void Purge (); /// Notify that packet is dropped from queue by timeout + /// \param en BuffEntry Buffer entry + /// \param reason Drop reason void Drop (DsrPassiveBuffEntry en, std::string reason); /// Notify that packet is dropped from queue by timeout + /// \param en BuffEntry Buffer entry + /// \param reason Drop reason void DropLink (DsrPassiveBuffEntry en, std::string reason); /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_passiveBufferTimeout; /// Check if the send buffer entry is the same or not + /// \param en The Entry to check + /// \param link The link to check + /// \return true if an Entry source and Next hop are equal to the Link parameters static bool LinkEqual (DsrPassiveBuffEntry en, const std::vector link) { return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1])); diff --git a/src/dsr/model/dsr-rcache.h b/src/dsr/model/dsr-rcache.h index 2349f78fec1..d85148dc8ac 100644 --- a/src/dsr/model/dsr-rcache.h +++ b/src/dsr/model/dsr-rcache.h @@ -140,6 +140,7 @@ class DsrLinkStab public: /** * \brief Constructor + * \param linkStab duration of the link stability */ DsrLinkStab (Time linkStab = Simulator::Now ()); /** @@ -231,6 +232,7 @@ class DsrRouteCacheEntry virtual ~DsrRouteCacheEntry (); /// Mark entry as "down" (i.e. disable it) + /// \param badLinkLifetime Time before purging the link for real. void Invalidate (Time badLinkLifetime); // Fields @@ -317,6 +319,7 @@ class DsrRouteCacheEntry /** * \brief Print necessary fields + * \param os the output stream */ void Print (std::ostream & os) const; /** @@ -386,6 +389,7 @@ class DsrRouteCache : public Object /** * \brief Remove the aged route cache entries when the route cache is full + * \param rtVector the route cache to scan. */ void RemoveLastEntry (std::list & rtVector); /** @@ -614,6 +618,7 @@ class DsrRouteCache : public Object /// Delete all outdated entries and invalidate valid entry if Lifetime is expired void Purge (); /// Print route cache + /// \param os the output stream void Print (std::ostream &os); //------------------------------------------------------------------------------------------ @@ -715,6 +720,7 @@ class DsrRouteCache : public Object } /// Handle link failure callback + /// \param cb the callback to be set void SetCallback (Callback cb) { m_handleLinkFailure = cb; @@ -727,14 +733,15 @@ class DsrRouteCache : public Object private: /** - * \brief assignment operator + * \brief assignment operator - defined but not implemented to avoid misuse. + * \return */ DsrRouteCache & operator= (DsrRouteCache const &); DsrRouteCacheEntry::IP_VECTOR m_vector; ///< The route vector to save the ip addresses for intermediate nodes. uint32_t m_maxCacheLen; ///< The maximum number of packets that we allow a routing protocol to buffer. Time RouteCacheTimeout; ///< The maximum period of time that dsr is allowed to for an unused route. Time m_badLinkLifetime; ///< The time for which the neighboring node is put into the blacklist. - /** + /* * Define the parameters for link cache type */ uint32_t m_stabilityDecrFactor; ///< stability decrease factor @@ -777,7 +784,7 @@ class DsrRouteCache : public Object * \brief used by LookupRoute when LinkCache * \param id the ip address we are looking for * \param rt the route cache entry to store the found one - * \return true if route rute found + * \return true if route route found */ bool LookupRoute_Link (Ipv4Address id, DsrRouteCacheEntry & rt); /** @@ -851,9 +858,14 @@ class DsrRouteCache : public Object Time m_delay; ///< This timeout deals with the passive ack - Mac48Address LookupMacAddress (Ipv4Address); ///< Find MAC address by IP using list of ARP caches + /// Find MAC address by IP using list of ARP caches + /// \param addr the IPv4 address to look for + /// \return The MAC address + Mac48Address LookupMacAddress (Ipv4Address addr); - void ProcessTxError (WifiMacHeader const &); ///< Process layer 2 TX error notification + /// Process layer 2 TX error notification + /// \param hdr Wi-Fi Mac Header + void ProcessTxError (WifiMacHeader const &hdr); }; } // namespace dsr } // namespace ns3 diff --git a/src/dsr/model/dsr-routing.h b/src/dsr/model/dsr-routing.h index f6f9ce9d77c..e1b8f1234fc 100644 --- a/src/dsr/model/dsr-routing.h +++ b/src/dsr/model/dsr-routing.h @@ -203,6 +203,7 @@ class DsrRouting : public IpL4Protocol Ptr GetNodeWithAddress (Ipv4Address ipv4Address); /** * \brief Print the route vector. + * \param vec the vector to print. */ void PrintVector (std::vector& vec); /** @@ -394,21 +395,21 @@ class DsrRouting : public IpL4Protocol void SalvagePacket (Ptr packet, Ipv4Address source, Ipv4Address dst, uint8_t protocol); /** * \brief Schedule the packet retransmission based on link-layer acknowledgment - * \param mb maintainenace buffer entry + * \param mb maintenance buffer entry * \param protocol the protocol number */ void ScheduleLinkPacketRetry (DsrMaintainBuffEntry & mb, uint8_t protocol); /** * \brief Schedule the packet retransmission based on passive acknowledgment - * \param mb maintainenace buffer entry + * \param mb maintenance buffer entry * \param protocol the protocol number */ void SchedulePassivePacketRetry (DsrMaintainBuffEntry & mb, uint8_t protocol); /** * \brief Schedule the packet retransmission based on network layer acknowledgment - * \param mb maintainenace buffer entry + * \param mb maintenance buffer entry * \param isFirst see if this is the first packet retry or not * \param protocol the protocol number */ @@ -417,21 +418,35 @@ class DsrRouting : public IpL4Protocol uint8_t protocol); /** * \brief This function deals with packet retransmission timer expire using link acknowledgment + * \param mb maintenance buffer entry + * \param protocol the protocol number */ void LinkScheduleTimerExpire (DsrMaintainBuffEntry & mb, uint8_t protocol); /** * \brief This function deals with packet retransmission timer expire using network acknowledgment + * \param mb maintenance buffer entry + * \param protocol the protocol number */ void NetworkScheduleTimerExpire (DsrMaintainBuffEntry & mb, uint8_t protocol); /** * \brief This function deals with packet retransmission timer expire using passive acknowledgment + * \param mb maintenance buffer entry + * \param protocol the protocol number */ void PassiveScheduleTimerExpire (DsrMaintainBuffEntry & mb, uint8_t protocol); /** * \brief Forward the packet using the route saved in the source route option header + * \param packet The packet + * \param sourceRoute Source route saved in option header + * \param ipv4Header IPv4 Header + * \param source source address + * \param destination destination address + * \param targetAddress target address + * \param protocol protocol number + * \param route route */ void ForwardPacket (Ptr packet, DsrOptionSRHeader &sourceRoute, @@ -443,6 +458,9 @@ class DsrRouting : public IpL4Protocol Ptr route); /** * \brief Broadcast the route request packet in subnet + * \param source source address + * \param destination destination address + * \param protocol protocol number */ void SendInitialRequest (Ipv4Address source, Ipv4Address destination, @@ -640,6 +658,8 @@ class DsrRouting : public IpL4Protocol void Start (); /** * \brief Send the route error message when the link breaks to the next hop. + * \param nextHop next hop address + * \param protocol protocol number */ void SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop, uint8_t protocol); /** diff --git a/src/dsr/model/dsr-rreq-table.cc b/src/dsr/model/dsr-rreq-table.cc index ef033fe25a4..6514eb23508 100644 --- a/src/dsr/model/dsr-rreq-table.cc +++ b/src/dsr/model/dsr-rreq-table.cc @@ -63,13 +63,13 @@ DsrRreqTable::~DsrRreqTable () } void -DsrRreqTable::RemoveLeastExpire (std::map & rreqDstMap) +DsrRreqTable::RemoveLeastExpire () { NS_LOG_FUNCTION (this); Ipv4Address firstExpire; Time max = Seconds (0.0); for (std::map::const_iterator i = - rreqDstMap.begin (); i != rreqDstMap.end (); ++i) + m_rreqDstMap.begin (); i != m_rreqDstMap.end (); ++i) { Ipv4Address dst = i->first; RreqTableEntry rreqTableEntry = i->second; @@ -79,7 +79,7 @@ DsrRreqTable::RemoveLeastExpire (std::map & rreqDs firstExpire = dst; } } - rreqDstMap.erase (firstExpire); + m_rreqDstMap.erase (firstExpire); } void @@ -96,7 +96,7 @@ DsrRreqTable::FindAndUpdate (Ipv4Address dst) */ if (m_rreqDstMap.size () >= m_requestTableSize) { - RemoveLeastExpire (m_rreqDstMap); + RemoveLeastExpire (); NS_LOG_INFO ("The request table size after erase " << (uint32_t)m_rreqDstMap.size ()); } RreqTableEntry rreqTableEntry; diff --git a/src/dsr/model/dsr-rreq-table.h b/src/dsr/model/dsr-rreq-table.h index 1001593434d..41bca4531e4 100644 --- a/src/dsr/model/dsr-rreq-table.h +++ b/src/dsr/model/dsr-rreq-table.h @@ -288,12 +288,16 @@ class DsrRreqTable : public Object } /// Remove the least used entry - void RemoveLeastExpire (std::map & rreqDstMap); + void RemoveLeastExpire (); /// Find the entry in the route request queue to see if already exists + /// \param dst Destination IP void FindAndUpdate (Ipv4Address dst); /// Remove route request entry for dst + /// \param dst Destination IP void RemoveRreqEntry (Ipv4Address dst); /// Get the request count number for one destination address + /// \param dst Destination IP + /// \return the route request counter uint32_t GetRreqCnt (Ipv4Address dst); /** diff --git a/src/dsr/model/dsr-rsendbuff.h b/src/dsr/model/dsr-rsendbuff.h index 70fdf02b2d6..5a195a33f48 100644 --- a/src/dsr/model/dsr-rsendbuff.h +++ b/src/dsr/model/dsr-rsendbuff.h @@ -251,7 +251,12 @@ class DsrSendBuffer private: std::vector m_sendBuffer; ///< The send buffer to cache unsent packet void Purge (); ///< Remove all expired entries - void Drop (DsrSendBuffEntry en, std::string reason); ///< Notify that packet is dropped from queue by timeout + + /// Notify that packet is dropped from queue by timeout + /// \param en BuffEntry Buffer entry + /// \param reason Drop reason + void Drop (DsrSendBuffEntry en, std::string reason); + uint32_t m_maxLen; ///< The maximum number of packets that we allow a routing protocol to buffer. Time m_sendBufferTimeout; ///< The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. /** diff --git a/src/dsr/test/dsr-test-suite.cc b/src/dsr/test/dsr-test-suite.cc index 55b81017834..005ee9717da 100644 --- a/src/dsr/test/dsr-test-suite.cc +++ b/src/dsr/test/dsr-test-suite.cc @@ -54,7 +54,7 @@ using namespace dsr; // ----------------------------------------------------------------------------- /** - * \ingroup dsr-test + * \ingroup dsr * \defgroup dsr-test DSR routing module tests */ From c29b7c953bd23384ffcf3e65c17506f47c0fbd61 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 15 May 2017 03:39:13 +0200 Subject: [PATCH 052/551] dsr: rescan bindings --- src/dsr/bindings/callbacks_list.py | 1 + src/dsr/bindings/modulegen__gcc_ILP32.py | 112 ++++++++++++++++++++--- src/dsr/bindings/modulegen__gcc_LP64.py | 112 ++++++++++++++++++++--- 3 files changed, 197 insertions(+), 28 deletions(-) diff --git a/src/dsr/bindings/callbacks_list.py b/src/dsr/bindings/callbacks_list.py index e92b31276ab..c512b538517 100644 --- a/src/dsr/bindings/callbacks_list.py +++ b/src/dsr/bindings/callbacks_list.py @@ -3,6 +3,7 @@ ['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ipv4Address', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::Ipv4Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::WifiMacHeader const*', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::Ipv4Address', 'ns3::Ipv4Address', 'unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], diff --git a/src/dsr/bindings/modulegen__gcc_ILP32.py b/src/dsr/bindings/modulegen__gcc_ILP32.py index 893dfd78231..750fd177138 100644 --- a/src/dsr/bindings/modulegen__gcc_ILP32.py +++ b/src/dsr/bindings/modulegen__gcc_ILP32.py @@ -562,6 +562,10 @@ def register_types(module): module.add_class('SsidChecker', import_from_module='ns.wifi', parent=root_module['ns3::AttributeChecker']) ## ssid.h (module 'wifi'): ns3::SsidValue [class] module.add_class('SsidValue', import_from_module='ns.wifi', parent=root_module['ns3::AttributeValue']) + ## string.h (module 'core'): ns3::StringChecker [class] + module.add_class('StringChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## string.h (module 'core'): ns3::StringValue [class] + module.add_class('StringValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) ## supported-rates.h (module 'wifi'): ns3::SupportedRates [class] module.add_class('SupportedRates', import_from_module='ns.wifi', parent=root_module['ns3::WifiInformationElement']) ## tcp-l4-protocol.h (module 'internet'): ns3::TcpL4Protocol [class] @@ -839,7 +843,6 @@ def register_types_ns3_dsr(module): module.add_container('std::list< std::vector< ns3::Ipv4Address > >', 'std::vector< ns3::Ipv4Address >', container_type=u'list') module.add_container('std::list< ns3::dsr::DsrRouteCacheEntry >', 'ns3::dsr::DsrRouteCacheEntry', container_type=u'list') module.add_container('std::vector< std::string >', 'std::string', container_type=u'vector') - module.add_container('std::map< ns3::Ipv4Address, ns3::dsr::RreqTableEntry >', ('ns3::Ipv4Address', 'ns3::dsr::RreqTableEntry'), container_type=u'map') module.add_container('std::vector< ns3::dsr::DsrSendBuffEntry >', 'ns3::dsr::DsrSendBuffEntry', container_type=u'vector') def register_types_ns3_internal(module): @@ -1061,6 +1064,8 @@ def register_methods(root_module): register_Ns3Ssid_methods(root_module, root_module['ns3::Ssid']) register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker']) register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue']) + register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker']) + register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue']) register_Ns3SupportedRates_methods(root_module, root_module['ns3::SupportedRates']) register_Ns3TcpL4Protocol_methods(root_module, root_module['ns3::TcpL4Protocol']) register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue']) @@ -2103,10 +2108,10 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_constructor([param('ns3::InterferenceHelper const &', 'arg0')]) ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::InterferenceHelper() [constructor] cls.add_constructor([]) - ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(uint32_t size, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] + ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] cls.add_method('Add', 'ns3::Ptr< ns3::InterferenceHelper::Event >', - [param('uint32_t', 'size'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) + [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::AddForeignSignal(ns3::Time duration, double rxPower) [member function] cls.add_method('AddForeignSignal', 'void', @@ -2123,10 +2128,11 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_method('EraseEvents', 'void', []) - ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) [member function] + ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) const [member function] cls.add_method('GetEnergyDuration', 'ns3::Time', - [param('double', 'energyW')]) + [param('double', 'energyW')], + is_const=True) ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::GetErrorRateModel() const [member function] cls.add_method('GetErrorRateModel', 'ns3::Ptr< ns3::ErrorRateModel >', @@ -3818,6 +3824,8 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] @@ -3826,6 +3834,11 @@ def register_Ns3Vector2D_methods(root_module, cls): cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -3833,6 +3846,8 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] @@ -3841,6 +3856,11 @@ def register_Ns3Vector3D_methods(root_module, cls): cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -7729,10 +7749,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'int64_t', [param('int64_t', 'stream')], is_virtual=True) - ## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] + ## wifi-phy.h (module 'wifi'): static ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] cls.add_method('CalculatePlcpPreambleAndHeaderDuration', 'ns3::Time', - [param('ns3::WifiTxVector', 'txVector')]) + [param('ns3::WifiTxVector', 'txVector')], + is_static=True) ## wifi-phy.h (module 'wifi'): double ns3::WifiPhy::CalculateSnr(ns3::WifiTxVector txVector, double ber) const [member function] cls.add_method('CalculateSnr', 'double', @@ -7872,6 +7893,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'ns3::Ptr< ns3::ErrorRateModel >', [], is_const=True) + ## wifi-phy.h (module 'wifi'): ns3::Ptr ns3::WifiPhy::GetFrameCaptureModel() const [member function] + cls.add_method('GetFrameCaptureModel', + 'ns3::Ptr< ns3::FrameCaptureModel >', + [], + is_const=True) ## wifi-phy.h (module 'wifi'): uint16_t ns3::WifiPhy::GetFrequency() const [member function] cls.add_method('GetFrequency', 'uint16_t', @@ -8589,6 +8615,10 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('SetErrorRateModel', 'void', [param('ns3::Ptr< ns3::ErrorRateModel >', 'rate')]) + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrameCaptureModel(ns3::Ptr rate) [member function] + cls.add_method('SetFrameCaptureModel', + 'void', + [param('ns3::Ptr< ns3::FrameCaptureModel >', 'rate')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrequency(uint16_t freq) [member function] cls.add_method('SetFrequency', 'void', @@ -9838,10 +9868,15 @@ def register_Ns3ArpCacheEntry_methods(root_module, cls): cls.add_method('SetIpv4Address', 'void', [param('ns3::Ipv4Address', 'destination')]) + ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddress(ns3::Address macAddress) [member function] + cls.add_method('SetMacAddress', + 'void', + [param('ns3::Address', 'macAddress')]) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddresss(ns3::Address macAddress) [member function] cls.add_method('SetMacAddresss', 'void', - [param('ns3::Address', 'macAddress')]) + [param('ns3::Address', 'macAddress')], + deprecated=True) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::UpdateSeen() [member function] cls.add_method('UpdateSeen', 'void', @@ -10441,6 +10476,10 @@ def register_Ns3DcaTxop_methods(root_module, cls): cls.add_method('SetMinCw', 'void', [param('uint32_t', 'minCw')]) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxDroppedCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + cls.add_method('SetTxDroppedCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxFailedCallback(ns3::Callback callback) [member function] cls.add_method('SetTxFailedCallback', 'void', @@ -10557,6 +10596,11 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::TxDroppedPacket(ns3::Ptr item) [member function] + cls.add_method('TxDroppedPacket', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem const >', 'item')], + visibility='protected') return def register_Ns3DcfManager_methods(root_module, cls): @@ -14376,6 +14420,46 @@ def register_Ns3SsidValue_methods(root_module, cls): [param('ns3::Ssid const &', 'value')]) return +def register_Ns3StringChecker_methods(root_module, cls): + ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] + cls.add_constructor([]) + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) + return + +def register_Ns3StringValue_methods(root_module, cls): + ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] + cls.add_constructor([]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] + cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, is_virtual=True) + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_virtual=True) + ## string.h (module 'core'): std::string ns3::StringValue::Get() const [member function] + cls.add_method('Get', + 'std::string', + [], + is_const=True) + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, is_virtual=True) + ## string.h (module 'core'): void ns3::StringValue::Set(std::string const & value) [member function] + cls.add_method('Set', + 'void', + [param('std::string const &', 'value')]) + return + def register_Ns3SupportedRates_methods(root_module, cls): cls.add_output_stream_operator() ## supported-rates.h (module 'wifi'): ns3::SupportedRates::SupportedRates() [constructor] @@ -17149,10 +17233,10 @@ def register_Ns3DsrDsrRouteCache_methods(root_module, cls): cls.add_method('IsNeighbor', 'bool', [param('ns3::Ipv4Address', 'addr')]) - ## dsr-rcache.h (module 'dsr'): ns3::Mac48Address ns3::dsr::DsrRouteCache::LookupMacAddress(ns3::Ipv4Address arg0) [member function] + ## dsr-rcache.h (module 'dsr'): ns3::Mac48Address ns3::dsr::DsrRouteCache::LookupMacAddress(ns3::Ipv4Address addr) [member function] cls.add_method('LookupMacAddress', 'ns3::Mac48Address', - [param('ns3::Ipv4Address', 'arg0')]) + [param('ns3::Ipv4Address', 'addr')]) ## dsr-rcache.h (module 'dsr'): bool ns3::dsr::DsrRouteCache::LookupRoute(ns3::Ipv4Address id, ns3::dsr::DsrRouteCacheEntry & rt) [member function] cls.add_method('LookupRoute', 'bool', @@ -17169,10 +17253,10 @@ def register_Ns3DsrDsrRouteCache_methods(root_module, cls): cls.add_method('PrintVector', 'void', [param('std::vector< ns3::Ipv4Address > &', 'vec')]) - ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::ProcessTxError(ns3::WifiMacHeader const & arg0) [member function] + ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::ProcessTxError(ns3::WifiMacHeader const & hdr) [member function] cls.add_method('ProcessTxError', 'void', - [param('ns3::WifiMacHeader const &', 'arg0')]) + [param('ns3::WifiMacHeader const &', 'hdr')]) ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::Purge() [member function] cls.add_method('Purge', 'void', @@ -17805,10 +17889,10 @@ def register_Ns3DsrDsrRreqTable_methods(root_module, cls): cls.add_method('PurgeNeighbor', 'void', []) - ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveLeastExpire(std::map, std::allocator > > & rreqDstMap) [member function] + ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveLeastExpire() [member function] cls.add_method('RemoveLeastExpire', 'void', - [param('std::map< ns3::Ipv4Address, ns3::dsr::RreqTableEntry > &', 'rreqDstMap')]) + []) ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveRreqEntry(ns3::Ipv4Address dst) [member function] cls.add_method('RemoveRreqEntry', 'void', diff --git a/src/dsr/bindings/modulegen__gcc_LP64.py b/src/dsr/bindings/modulegen__gcc_LP64.py index 893dfd78231..750fd177138 100644 --- a/src/dsr/bindings/modulegen__gcc_LP64.py +++ b/src/dsr/bindings/modulegen__gcc_LP64.py @@ -562,6 +562,10 @@ def register_types(module): module.add_class('SsidChecker', import_from_module='ns.wifi', parent=root_module['ns3::AttributeChecker']) ## ssid.h (module 'wifi'): ns3::SsidValue [class] module.add_class('SsidValue', import_from_module='ns.wifi', parent=root_module['ns3::AttributeValue']) + ## string.h (module 'core'): ns3::StringChecker [class] + module.add_class('StringChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) + ## string.h (module 'core'): ns3::StringValue [class] + module.add_class('StringValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue']) ## supported-rates.h (module 'wifi'): ns3::SupportedRates [class] module.add_class('SupportedRates', import_from_module='ns.wifi', parent=root_module['ns3::WifiInformationElement']) ## tcp-l4-protocol.h (module 'internet'): ns3::TcpL4Protocol [class] @@ -839,7 +843,6 @@ def register_types_ns3_dsr(module): module.add_container('std::list< std::vector< ns3::Ipv4Address > >', 'std::vector< ns3::Ipv4Address >', container_type=u'list') module.add_container('std::list< ns3::dsr::DsrRouteCacheEntry >', 'ns3::dsr::DsrRouteCacheEntry', container_type=u'list') module.add_container('std::vector< std::string >', 'std::string', container_type=u'vector') - module.add_container('std::map< ns3::Ipv4Address, ns3::dsr::RreqTableEntry >', ('ns3::Ipv4Address', 'ns3::dsr::RreqTableEntry'), container_type=u'map') module.add_container('std::vector< ns3::dsr::DsrSendBuffEntry >', 'ns3::dsr::DsrSendBuffEntry', container_type=u'vector') def register_types_ns3_internal(module): @@ -1061,6 +1064,8 @@ def register_methods(root_module): register_Ns3Ssid_methods(root_module, root_module['ns3::Ssid']) register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker']) register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue']) + register_Ns3StringChecker_methods(root_module, root_module['ns3::StringChecker']) + register_Ns3StringValue_methods(root_module, root_module['ns3::StringValue']) register_Ns3SupportedRates_methods(root_module, root_module['ns3::SupportedRates']) register_Ns3TcpL4Protocol_methods(root_module, root_module['ns3::TcpL4Protocol']) register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue']) @@ -2103,10 +2108,10 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_constructor([param('ns3::InterferenceHelper const &', 'arg0')]) ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::InterferenceHelper() [constructor] cls.add_constructor([]) - ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(uint32_t size, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] + ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] cls.add_method('Add', 'ns3::Ptr< ns3::InterferenceHelper::Event >', - [param('uint32_t', 'size'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) + [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::AddForeignSignal(ns3::Time duration, double rxPower) [member function] cls.add_method('AddForeignSignal', 'void', @@ -2123,10 +2128,11 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_method('EraseEvents', 'void', []) - ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) [member function] + ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) const [member function] cls.add_method('GetEnergyDuration', 'ns3::Time', - [param('double', 'energyW')]) + [param('double', 'energyW')], + is_const=True) ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::GetErrorRateModel() const [member function] cls.add_method('GetErrorRateModel', 'ns3::Ptr< ns3::ErrorRateModel >', @@ -3818,6 +3824,8 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] @@ -3826,6 +3834,11 @@ def register_Ns3Vector2D_methods(root_module, cls): cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -3833,6 +3846,8 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] @@ -3841,6 +3856,11 @@ def register_Ns3Vector3D_methods(root_module, cls): cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -7729,10 +7749,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'int64_t', [param('int64_t', 'stream')], is_virtual=True) - ## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] + ## wifi-phy.h (module 'wifi'): static ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] cls.add_method('CalculatePlcpPreambleAndHeaderDuration', 'ns3::Time', - [param('ns3::WifiTxVector', 'txVector')]) + [param('ns3::WifiTxVector', 'txVector')], + is_static=True) ## wifi-phy.h (module 'wifi'): double ns3::WifiPhy::CalculateSnr(ns3::WifiTxVector txVector, double ber) const [member function] cls.add_method('CalculateSnr', 'double', @@ -7872,6 +7893,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'ns3::Ptr< ns3::ErrorRateModel >', [], is_const=True) + ## wifi-phy.h (module 'wifi'): ns3::Ptr ns3::WifiPhy::GetFrameCaptureModel() const [member function] + cls.add_method('GetFrameCaptureModel', + 'ns3::Ptr< ns3::FrameCaptureModel >', + [], + is_const=True) ## wifi-phy.h (module 'wifi'): uint16_t ns3::WifiPhy::GetFrequency() const [member function] cls.add_method('GetFrequency', 'uint16_t', @@ -8589,6 +8615,10 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('SetErrorRateModel', 'void', [param('ns3::Ptr< ns3::ErrorRateModel >', 'rate')]) + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrameCaptureModel(ns3::Ptr rate) [member function] + cls.add_method('SetFrameCaptureModel', + 'void', + [param('ns3::Ptr< ns3::FrameCaptureModel >', 'rate')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrequency(uint16_t freq) [member function] cls.add_method('SetFrequency', 'void', @@ -9838,10 +9868,15 @@ def register_Ns3ArpCacheEntry_methods(root_module, cls): cls.add_method('SetIpv4Address', 'void', [param('ns3::Ipv4Address', 'destination')]) + ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddress(ns3::Address macAddress) [member function] + cls.add_method('SetMacAddress', + 'void', + [param('ns3::Address', 'macAddress')]) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::SetMacAddresss(ns3::Address macAddress) [member function] cls.add_method('SetMacAddresss', 'void', - [param('ns3::Address', 'macAddress')]) + [param('ns3::Address', 'macAddress')], + deprecated=True) ## arp-cache.h (module 'internet'): void ns3::ArpCache::Entry::UpdateSeen() [member function] cls.add_method('UpdateSeen', 'void', @@ -10441,6 +10476,10 @@ def register_Ns3DcaTxop_methods(root_module, cls): cls.add_method('SetMinCw', 'void', [param('uint32_t', 'minCw')]) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxDroppedCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + cls.add_method('SetTxDroppedCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxFailedCallback(ns3::Callback callback) [member function] cls.add_method('SetTxFailedCallback', 'void', @@ -10557,6 +10596,11 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::TxDroppedPacket(ns3::Ptr item) [member function] + cls.add_method('TxDroppedPacket', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem const >', 'item')], + visibility='protected') return def register_Ns3DcfManager_methods(root_module, cls): @@ -14376,6 +14420,46 @@ def register_Ns3SsidValue_methods(root_module, cls): [param('ns3::Ssid const &', 'value')]) return +def register_Ns3StringChecker_methods(root_module, cls): + ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] + cls.add_constructor([]) + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) + return + +def register_Ns3StringValue_methods(root_module, cls): + ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] + cls.add_constructor([]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] + cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] + cls.add_method('Copy', + 'ns3::Ptr< ns3::AttributeValue >', + [], + is_const=True, is_virtual=True) + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + cls.add_method('DeserializeFromString', + 'bool', + [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_virtual=True) + ## string.h (module 'core'): std::string ns3::StringValue::Get() const [member function] + cls.add_method('Get', + 'std::string', + [], + is_const=True) + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + cls.add_method('SerializeToString', + 'std::string', + [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], + is_const=True, is_virtual=True) + ## string.h (module 'core'): void ns3::StringValue::Set(std::string const & value) [member function] + cls.add_method('Set', + 'void', + [param('std::string const &', 'value')]) + return + def register_Ns3SupportedRates_methods(root_module, cls): cls.add_output_stream_operator() ## supported-rates.h (module 'wifi'): ns3::SupportedRates::SupportedRates() [constructor] @@ -17149,10 +17233,10 @@ def register_Ns3DsrDsrRouteCache_methods(root_module, cls): cls.add_method('IsNeighbor', 'bool', [param('ns3::Ipv4Address', 'addr')]) - ## dsr-rcache.h (module 'dsr'): ns3::Mac48Address ns3::dsr::DsrRouteCache::LookupMacAddress(ns3::Ipv4Address arg0) [member function] + ## dsr-rcache.h (module 'dsr'): ns3::Mac48Address ns3::dsr::DsrRouteCache::LookupMacAddress(ns3::Ipv4Address addr) [member function] cls.add_method('LookupMacAddress', 'ns3::Mac48Address', - [param('ns3::Ipv4Address', 'arg0')]) + [param('ns3::Ipv4Address', 'addr')]) ## dsr-rcache.h (module 'dsr'): bool ns3::dsr::DsrRouteCache::LookupRoute(ns3::Ipv4Address id, ns3::dsr::DsrRouteCacheEntry & rt) [member function] cls.add_method('LookupRoute', 'bool', @@ -17169,10 +17253,10 @@ def register_Ns3DsrDsrRouteCache_methods(root_module, cls): cls.add_method('PrintVector', 'void', [param('std::vector< ns3::Ipv4Address > &', 'vec')]) - ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::ProcessTxError(ns3::WifiMacHeader const & arg0) [member function] + ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::ProcessTxError(ns3::WifiMacHeader const & hdr) [member function] cls.add_method('ProcessTxError', 'void', - [param('ns3::WifiMacHeader const &', 'arg0')]) + [param('ns3::WifiMacHeader const &', 'hdr')]) ## dsr-rcache.h (module 'dsr'): void ns3::dsr::DsrRouteCache::Purge() [member function] cls.add_method('Purge', 'void', @@ -17805,10 +17889,10 @@ def register_Ns3DsrDsrRreqTable_methods(root_module, cls): cls.add_method('PurgeNeighbor', 'void', []) - ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveLeastExpire(std::map, std::allocator > > & rreqDstMap) [member function] + ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveLeastExpire() [member function] cls.add_method('RemoveLeastExpire', 'void', - [param('std::map< ns3::Ipv4Address, ns3::dsr::RreqTableEntry > &', 'rreqDstMap')]) + []) ## dsr-rreq-table.h (module 'dsr'): void ns3::dsr::DsrRreqTable::RemoveRreqEntry(ns3::Ipv4Address dst) [member function] cls.add_method('RemoveRreqEntry', 'void', From d9b8695742b6bdaafca1fb741b6ff0a2da6d84e3 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 14 May 2017 21:26:26 -0700 Subject: [PATCH 053/551] config-store: Doxygen updates (based on Robert Ammon's original patch) --- .../examples/config-store-save.cc | 12 +- .../model/attribute-default-iterator.h | 5 + src/config-store/model/attribute-iterator.h | 124 +++++++++++++++++- src/config-store/model/config-store.h | 45 ++++++- src/config-store/model/display-functions.cc | 19 ++- src/config-store/model/file-config.h | 16 ++- src/config-store/model/gtk-config-store.h | 6 + src/config-store/model/model-node-creator.h | 31 ++++- src/config-store/model/model-typeid-creator.h | 25 +++- src/config-store/model/raw-text-config.h | 11 +- src/config-store/model/xml-config.h | 7 +- 11 files changed, 276 insertions(+), 25 deletions(-) diff --git a/src/config-store/examples/config-store-save.cc b/src/config-store/examples/config-store-save.cc index 783b6d309f9..047bafae8d7 100644 --- a/src/config-store/examples/config-store-save.cc +++ b/src/config-store/examples/config-store-save.cc @@ -6,9 +6,19 @@ using namespace ns3; +/** + * \ingroup configstore-examples + * \ingroup examples + * + * \brief Example class to demonstrate use of the ns-3 Config Store + */ class ConfigExample : public Object { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void) { static TypeId tid = TypeId ("ns3::ConfigExample") .SetParent () @@ -19,7 +29,7 @@ class ConfigExample : public Object ; return tid; } - int16_t m_int16; + int16_t m_int16; ///< value to configure }; NS_OBJECT_ENSURE_REGISTERED (ConfigExample); diff --git a/src/config-store/model/attribute-default-iterator.h b/src/config-store/model/attribute-default-iterator.h index b5981cb26e4..8384abbfb6f 100644 --- a/src/config-store/model/attribute-default-iterator.h +++ b/src/config-store/model/attribute-default-iterator.h @@ -25,6 +25,11 @@ namespace ns3 { +/** + * \ingroup configstore + * + * \brief Iterator to iterate on the default values of attributes of an ns3::Object + */ class AttributeDefaultIterator { public: diff --git a/src/config-store/model/attribute-iterator.h b/src/config-store/model/attribute-iterator.h index 5821651a87b..b6c096fff05 100644 --- a/src/config-store/model/attribute-iterator.h +++ b/src/config-store/model/attribute-iterator.h @@ -29,7 +29,8 @@ namespace ns3 { /** * \ingroup configstore * - * This class is used internally by ConfigStore and GtkConfigStore. + * \brief Iterator to iterate on the values of attributes of an ns3::Object + * \note This class is used internally by ConfigStore and GtkConfigStore. */ class AttributeIterator { @@ -37,37 +38,154 @@ class AttributeIterator AttributeIterator (); virtual ~AttributeIterator (); + /** + * Start the processs of iterating all objects from the root namespace object + */ void Iterate (void); protected: + /** + * Get the current attribute path + * \returns the current path string + */ std::string GetCurrentPath (void) const; private: + /** + * This method visits and performs a config-store action (such as saving + * to a text file) on the attribute values corresponding to the input + * object pointer and attribute name. + * + * \param object the object visited + * \param name the attribute name + */ virtual void DoVisitAttribute (Ptr object, std::string name) = 0; + /** + * This method is called to start the process of visiting the input object + * \param object the object visited + */ virtual void DoStartVisitObject (Ptr object); + /** + * This method is called to end the process of visiting the currently + * visited object. + */ virtual void DoEndVisitObject (void); + /** + * Visit the attribute of type ns3::PointerValue, with the provided name, + * found on the object pointed to by the first argument. + * + * \param object the object on which the attribute of type PointerValue resides + * \param name the attribute name provided + * \param [in] value Ptr to the ns3::Object pointed to by the attribute + */ virtual void DoStartVisitPointerAttribute (Ptr object, std::string name, Ptr value); + /** + * End the visit to the attribute of type ns3::PointerValue. + */ virtual void DoEndVisitPointerAttribute (void); + /** + * Visit the attribute of type ns3::ObjectVectorValue, with the + * provided name, found on the object pointed to by the first argument. + * + * \note type name ObjectVectorValue is an alias for ObjectPtrContainerValue + * + * \param object the object on which the attribute of type ObjectVectorValue +resides + * \param name the attribute name provided + * \param [in] vector the ObjectPtrContainerValue corresponding to the named attribute + */ virtual void DoStartVisitArrayAttribute (Ptr object, std::string name, const ObjectPtrContainerValue &vector); + /** + * End the visit to the attribute of type ns3::ObjectVectorValue. + */ virtual void DoEndVisitArrayAttribute (void); + /** + * Start to visit the object found in the input array at the provided index + * \param vector the array + * \param index the index into the array + * \param [in] item the array item to visit + */ virtual void DoStartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr item); + /** + * End the visit to the array item + */ virtual void DoEndVisitArrayItem (void); + /** + * Perform the iteration + * \param object the object visited + */ void DoIterate (Ptr object); + /** + * Check if this object has already been examined + * \param object the object to check + * \returns true if object has been examined + */ bool IsExamined (Ptr object); + /** + * Get current attribute path + * \param attr the current attribute string + * \returns the current path string + */ std::string GetCurrentPath (std::string attr) const; + /** + * Visit attribute to perform a config store operation on it + * \param object the current object + * \param name the attribute name + */ void VisitAttribute (Ptr object, std::string name); + /** + * Start to visit an object to visit its attributes + * \param object the current object + */ void StartVisitObject (Ptr object); + /** + * End the visit to the object + */ void EndVisitObject (void); + /** + * Visit the attribute of type ns3::PointerValue, with the provided name, + * found on the object pointed to by the first argument. + * + * \param object the object on which the attribute of type PointerValue resides + * \param name the attribute name provided + * \param [in] value Ptr to the ns3::Object pointed to by the attribute + */ void StartVisitPointerAttribute (Ptr object, std::string name, Ptr value); + /** + * End the visit to the attribute of type ns3::PointerValue. + */ void EndVisitPointerAttribute (void); + /** + * Visit the attribute of type ns3::ObjectVectorValue, with the + * provided name, found on the object pointed to by the first argument. + * + * \note type name ObjectVectorValue is an alias for ObjectPtrContainerValue + * + * \param object the object on which the attribute of type ObjectVectorValue +resides + * \param name the attribute name provided + * \param [in] vector the ObjectPtrContainerValue corresponding to the named attribute + */ void StartVisitArrayAttribute (Ptr object, std::string name, const ObjectPtrContainerValue &vector); + /** + * End the visit to the attribute of type ns3::ObjectVectorValue. + */ void EndVisitArrayAttribute (void); + /** + * Start to visit the object found in the input array at the provided index + * \param vector the array + * \param index the index into the array + * \param [in] item the array item to visit + */ void StartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr item); + /** + * End the visit to the array item + */ void EndVisitArrayItem (void); - std::vector > m_examined; - std::vector m_currentPath; + std::vector > m_examined; ///< list of attributes examined + std::vector m_currentPath; ///< current attribute path }; } // namespace ns3 diff --git a/src/config-store/model/config-store.h b/src/config-store/model/config-store.h index 7ebba977d12..cc051be2a2d 100644 --- a/src/config-store/model/config-store.h +++ b/src/config-store/model/config-store.h @@ -31,6 +31,11 @@ namespace ns3 { * * \brief Store and load simulation attribute configuration * + * ns-3 Objects and their attribute values (default, and per-instance values) + * are stored in a specialized internal database. The config-store module + * permits these values to be imported and exported to formats of + * different types (e.g. XML files, raw text files, or a GTK-based UI). + * * While it is possible to generate a sample config file and lightly * edit it to change a couple of values, there are cases where this * process will not work because the same value on the same object @@ -54,33 +59,65 @@ namespace ns3 { class ConfigStore : public ObjectBase { public: +/** + * \enum Mode for ConfigStore operation + * \brief store / load mode + */ enum Mode { LOAD, SAVE, NONE }; +/** + * \enum FileFormat for ConfigStore operation + * \brief file format + */ + /// store format enum FileFormat { XML, RAW_TEXT }; + + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; ConfigStore (); ~ConfigStore (); + /** + * Set the mode of operation + * \param mode mode of operation + */ void SetMode (enum Mode mode); + /** + * Set the file format + * \param format the file format + */ void SetFileFormat (enum FileFormat format); + /** + * Set the filename + * \param filename the file name + */ void SetFilename (std::string filename); + /** + * Configure the default values + */ void ConfigureDefaults (void); + /** + * Configure the attribute values + */ void ConfigureAttributes (void); private: - enum Mode m_mode; - enum FileFormat m_fileFormat; - std::string m_filename; - FileConfig *m_file; + enum Mode m_mode; ///< store mode + enum FileFormat m_fileFormat; ///< store format + std::string m_filename; ///< store file name + FileConfig *m_file; ///< configuration file }; /** diff --git a/src/config-store/model/display-functions.cc b/src/config-store/model/display-functions.cc index bf8dbfa118a..3a28f9d365e 100644 --- a/src/config-store/model/display-functions.cc +++ b/src/config-store/model/display-functions.cc @@ -256,6 +256,9 @@ create_view (GtkTreeStore *model) /** * This is the action done when the user presses on the save button. * It will save the config to a file. + * + * \param button (unused) + * \param user_data */ void save_clicked (GtkButton *button, gpointer user_data) @@ -417,7 +420,15 @@ cell_edited_callback_config_default (GtkCellRendererText *cell, gchar *path_stri * This function is used to display a tooltip whenever the user puts the mouse * over a type ID or an attribute. It will give the type and the possible values of * an attribute value and the type of the object for an attribute object or a - * typeID object + * typeID object + + * \param widget is the display object + * \param x is the x position + * \param y is the y position + * \param keyboard_tip + * \param tooltip is the tooltip information to be displayed + * \param user_data + * \return false if the tooltip is not displayed */ gboolean cell_tooltip_callback_config_default (GtkWidget *widget, gint x, gint y, @@ -479,6 +490,9 @@ cell_tooltip_callback_config_default (GtkWidget *widget, gint x, gint y, /** * This is the action done when the user presses on the save button. * It will save the config to a file. + * + * \param button (unused) + * \param user_data */ void save_clicked_default (GtkButton *button, gpointer user_data) @@ -510,6 +524,9 @@ save_clicked_default (GtkButton *button, gpointer user_data) /** * If the user presses the button load, it will load the config file into memory. + * + * \param button (unused) + * \param user_data */ void load_clicked_default (GtkButton *button, gpointer user_data) diff --git a/src/config-store/model/file-config.h b/src/config-store/model/file-config.h index bf474e0268a..6809340039d 100644 --- a/src/config-store/model/file-config.h +++ b/src/config-store/model/file-config.h @@ -27,21 +27,35 @@ namespace ns3 { /** * \ingroup configstore + * \brief base class for ConfigStore classes using files * */ class FileConfig { public: virtual ~FileConfig (); + /** + * Set the file name + * \param filename the filename + */ virtual void SetFilename (std::string filename) = 0; + /** + * Load or save the default values + */ virtual void Default (void) = 0; + /** + * Load or save the global values + */ virtual void Global (void) = 0; + /** + * Load or save the attributes values + */ virtual void Attributes (void) = 0; }; /** * \ingroup configstore - * + * \brief A dummy class (does nothing) */ class NoneFileConfig : public FileConfig { diff --git a/src/config-store/model/gtk-config-store.h b/src/config-store/model/gtk-config-store.h index 37105e4cc51..f4280c4fd82 100644 --- a/src/config-store/model/gtk-config-store.h +++ b/src/config-store/model/gtk-config-store.h @@ -32,7 +32,13 @@ class GtkConfigStore public: GtkConfigStore (); + /** + * Process default values + */ void ConfigureDefaults (void); + /** + * Process attribute values + */ void ConfigureAttributes (void); }; diff --git a/src/config-store/model/model-node-creator.h b/src/config-store/model/model-node-creator.h index 822983b408a..0aa4ba88fd9 100644 --- a/src/config-store/model/model-node-creator.h +++ b/src/config-store/model/model-node-creator.h @@ -28,8 +28,17 @@ enum COL_NODE = 0, COL_LAST }; +/** + * \ingroup configstore + * \brief A class used in the implementation of the GtkConfigStore + */ struct ModelNode { +/** + * \enum node type + * \brief node type structure + * + */ enum { // store object + attribute name @@ -42,13 +51,14 @@ struct ModelNode NODE_VECTOR_ITEM, // store object NODE_OBJECT - } type; - std::string name; - Ptr object; - uint32_t index; + } type; ///< node type + std::string name; ///< node name + Ptr object; ///< the object + uint32_t index; ///< index }; /** * \ingroup configstore + * \brief ModelCreator class * */ class ModelCreator : public AttributeIterator @@ -56,6 +66,10 @@ class ModelCreator : public AttributeIterator public: ModelCreator (); + /** + * Allocate attribute tree + * \param treestore GtkTreeStore * + */ void Build (GtkTreeStore *treestore); private: virtual void DoVisitAttribute (Ptr object, std::string name); @@ -69,10 +83,15 @@ class ModelCreator : public AttributeIterator virtual void DoStartVisitArrayItem (const ObjectPtrContainerValue &vector, uint32_t index, Ptr item); virtual void DoEndVisitArrayItem (void); + /** + * Add item to attribute tree + * \param node The model node + */ void Add (ModelNode *node); + /// Remove current tree item void Remove (void); - GtkTreeStore *m_treestore; - std::vector m_iters; + GtkTreeStore *m_treestore; ///< attribute tree + std::vector m_iters; ///< attribute tree item }; } diff --git a/src/config-store/model/model-typeid-creator.h b/src/config-store/model/model-typeid-creator.h index 63cc2c20724..1e0cc1202cf 100644 --- a/src/config-store/model/model-typeid-creator.h +++ b/src/config-store/model/model-typeid-creator.h @@ -28,22 +28,37 @@ enum COL_TYPEID = 0, COL_LASTID }; +/** + * \ingroup configstore + * \brief A class used in the implementation of the GtkConfigStore + */ struct ModelTypeid { + /** + * \enum node type + * \brief Whether the node represents an attribute or TypeId + */ enum { // store TypeId + attribute name +defaultValue and index NODE_ATTRIBUTE, // store TypeId NODE_TYPEID - } type; + } type; ///< node type + /// TypeId name std::string name; + /// TypeId default value std::string defaultValue; - //The TypeId object and if it is an attribute, it's the TypeId object of the attribute + /// The TypeId object and if it is an attribute, it's the TypeId object of the attribute TypeId tid; - //stores the index of the attribute in list of attributes for a given TypeId + /// stores the index of the attribute in list of attributes for a given TypeId uint32_t index; }; + +/** + * \ingroup configstore + * \brief ModelTypeIdCreator class + */ class ModelTypeidCreator : public AttributeDefaultIterator { public: @@ -74,9 +89,9 @@ class ModelTypeidCreator : public AttributeDefaultIterator * Removes the last GtkTreeIterator from m_iters */ void Remove (void); - //this is the TreeStore model corresponding to the view + /// this is the TreeStore model corresponding to the view GtkTreeStore *m_treestore; - //This contains a vector of iterators used to build the TreeStore + /// This contains a vector of iterators used to build the TreeStore std::vector m_iters; }; } diff --git a/src/config-store/model/raw-text-config.h b/src/config-store/model/raw-text-config.h index a74f6b07f76..35e4f33f6d2 100644 --- a/src/config-store/model/raw-text-config.h +++ b/src/config-store/model/raw-text-config.h @@ -29,6 +29,7 @@ namespace ns3 { /** * \ingroup configstore + * \brief A class to enable saving of configuration store in a raw text file * */ class RawTextConfigSave : public FileConfig @@ -41,11 +42,13 @@ class RawTextConfigSave : public FileConfig virtual void Global (void); virtual void Attributes (void); private: + /// Config store output stream std::ofstream *m_os; }; /** * \ingroup configstore + * \brief A class to enable loading of configuration store from a raw text file * */ class RawTextConfigLoad : public FileConfig @@ -58,7 +61,13 @@ class RawTextConfigLoad : public FileConfig virtual void Global (void); virtual void Attributes (void); private: - std::string Strip (std::string value); + /** + * Strip out attribute value + * \param value the input string + * \returns the updated string + */ + std::string Strip (std::string value); + /// Config store input stream std::ifstream *m_is; }; diff --git a/src/config-store/model/xml-config.h b/src/config-store/model/xml-config.h index f88bdc368a2..3bd5c376f99 100644 --- a/src/config-store/model/xml-config.h +++ b/src/config-store/model/xml-config.h @@ -30,6 +30,7 @@ namespace ns3 { /** * \ingroup configstore + * \brief A class to enable saving of configuration store in an XML file * */ class XmlConfigSave : public FileConfig @@ -43,12 +44,12 @@ class XmlConfigSave : public FileConfig virtual void Global (void); virtual void Attributes (void); private: - xmlTextWriterPtr m_writer; + xmlTextWriterPtr m_writer; ///< XML writer }; /** * \ingroup configstore - * + * \brief A class to enable loading of configuration store from an XML file */ class XmlConfigLoad : public FileConfig { @@ -61,7 +62,7 @@ class XmlConfigLoad : public FileConfig virtual void Global (void); virtual void Attributes (void); private: - std::string m_filename; + std::string m_filename; ///< the file name }; } // namespace ns3 From e31ae8502878d66bff495a201924a94db0aaae24 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 16 May 2017 15:35:15 +0300 Subject: [PATCH 054/551] wifi: Fix comments in DcfManager --- src/wifi/model/dcf-manager.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/wifi/model/dcf-manager.h b/src/wifi/model/dcf-manager.h index fd6b51f26f9..9a3ec200c6a 100644 --- a/src/wifi/model/dcf-manager.h +++ b/src/wifi/model/dcf-manager.h @@ -325,10 +325,10 @@ class DcfManager : public Object typedef std::vector States; States m_states; //!< the DCF states - Time m_lastAckTimeoutEnd; //!< the last ack timeout end time + Time m_lastAckTimeoutEnd; //!< the last ACK timeout end time Time m_lastCtsTimeoutEnd; //!< the last CTS timeout end time - Time m_lastNavStart; //!< the last nav start time - Time m_lastNavDuration; //!< the last nav direction time + Time m_lastNavStart; //!< the last NAV start time + Time m_lastNavDuration; //!< the last NAV duration time Time m_lastRxStart; //!< the last receive start time Time m_lastRxDuration; //!< the last receive duration time bool m_lastRxReceivedOk; //!< the last receive OK @@ -336,7 +336,7 @@ class DcfManager : public Object Time m_lastTxStart; //!< the last transmit start time Time m_lastTxDuration; //!< the last transmit duration time Time m_lastBusyStart; //!< the last busy start time - Time m_lastBusyDuration; //!< the last busy duraation time + Time m_lastBusyDuration; //!< the last busy duration time Time m_lastSwitchingStart; //!< the last switching start time Time m_lastSwitchingDuration; //!< the last switching duration time bool m_rxing; //!< flag whether it is in receiving state From 70d2462a17e51f3e66307b45fa8bd972954c8fb4 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sat, 20 May 2017 19:47:42 +0200 Subject: [PATCH 055/551] internet: (fixes #2741) IPv4 fragmentation fails when re-fragmenting a previous last fragment. --- RELEASE_NOTES | 1 + src/internet/model/ipv4-l3-protocol.cc | 12 +++--------- 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index eb4052b54ab..fe9c72682ec 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -103,6 +103,7 @@ Bugs fixed - Bug 2671 - ArpCache::Entry::SetMacAddress is misspelled - Bug 2717 - Fix mask generation for Ipv4RoutingTableEntry::CreateDefaultRoute - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity +- Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. Known issues ------------ diff --git a/src/internet/model/ipv4-l3-protocol.cc b/src/internet/model/ipv4-l3-protocol.cc index 43a198a5c0d..88a4223c86f 100644 --- a/src/internet/model/ipv4-l3-protocol.cc +++ b/src/internet/model/ipv4-l3-protocol.cc @@ -1422,16 +1422,10 @@ Ipv4L3Protocol::DoFragmentation (Ptr packet, const Ipv4Header & ipv4Head uint16_t offset = 0; bool moreFragment = true; - uint16_t originalOffset = 0; - bool alreadyFragmented = false; + uint16_t originalOffset = ipv4Header.GetFragmentOffset(); + bool isLastFragment = ipv4Header.IsLastFragment(); uint32_t currentFragmentablePartSize = 0; - if (!ipv4Header.IsLastFragment()) - { - alreadyFragmented = true; - originalOffset = ipv4Header.GetFragmentOffset(); - } - // IPv4 fragments are all 8 bytes aligned but the last. // The IP payload size is: // floor( ( outIfaceMtu - ipv4Header.GetSerializedSize() ) /8 ) *8 @@ -1453,7 +1447,7 @@ Ipv4L3Protocol::DoFragmentation (Ptr packet, const Ipv4Header & ipv4Head { moreFragment = false; currentFragmentablePartSize = p->GetSize () - offset; - if (alreadyFragmented) + if (!isLastFragment) { fragmentHeader.SetMoreFragments (); } From 296a1015211db744d35b7596057d1a1ea3ab51d7 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sun, 21 May 2017 11:39:05 +0200 Subject: [PATCH 056/551] nix-vector-routing: complete doxygen documentation --- .../examples/nms-p2p-nix.cc | 113 ++++++++------ .../helper/ipv4-nix-vector-helper.h | 3 + .../model/ipv4-nix-vector-routing.h | 139 ++++++++++++------ 3 files changed, 170 insertions(+), 85 deletions(-) diff --git a/src/nix-vector-routing/examples/nms-p2p-nix.cc b/src/nix-vector-routing/examples/nms-p2p-nix.cc index ead1a3b1939..1768d0d092b 100644 --- a/src/nix-vector-routing/examples/nms-p2p-nix.cc +++ b/src/nix-vector-routing/examples/nms-p2p-nix.cc @@ -60,62 +60,91 @@ void Progress () Simulator::Schedule (Seconds (0.1), Progress); } +/** + * \ingroup nix-vector-routing + * 2D array used in nix-vector-routing example "nms-p2p-nix.cc" + */ template class Array2D { - public: - Array2D (const size_t x, const size_t y) : p (new T*[x]), m_xMax (x) - { - for (size_t i = 0; i < m_xMax; i++) - p[i] = new T[y]; - } +public: + /** + * Constructor + * \param x number of rows + * \param y number of columns + */ + Array2D (const size_t x, const size_t y) : + p (new T*[x]), m_xMax (x) + { + for (size_t i = 0; i < m_xMax; i++) + p[i] = new T[y]; + } - ~Array2D (void) - { - for (size_t i = 0; i < m_xMax; i++) - delete[] p[i]; - delete[] p; - p = 0; - } + ~Array2D (void) + { + for (size_t i = 0; i < m_xMax; i++) + delete[] p[i]; + delete[] p; + p = 0; + } - T* operator[] (const size_t i) - { - return p[i]; - } - private: - T** p; - const size_t m_xMax; + /** + * Accessor operator + * \param i index to be retrieved + * \return a pointer to the indexed element + */ + T* operator[] (const size_t i) + { + return p[i]; + } +private: + T** p; //!< Stored elements + const size_t m_xMax; //!< maximum number of rows }; +/** + * \ingroup nix-vector-routing + * 3D array used in nix-vector-routing example "nms-p2p-nix.cc" + */ template class Array3D { - public: - Array3D (const size_t x, const size_t y, const size_t z) - : p (new Array2D*[x]), m_xMax (x) - { - for (size_t i = 0; i < m_xMax; i++) - p[i] = new Array2D (y, z); - } +public: + /** + * Constructor + * \param x number of rows + * \param y number of columns + * \param z number of layers + */ + Array3D (const size_t x, const size_t y, const size_t z) : p (new Array2D*[x]), m_xMax (x) + { + for (size_t i = 0; i < m_xMax; i++) + p[i] = new Array2D (y, z); + } - ~Array3D (void) + ~Array3D (void) + { + for (size_t i = 0; i < m_xMax; i++) { - for (size_t i = 0; i < m_xMax; i++) - { - delete p[i]; - p[i] = 0; - } - delete[] p; - p = 0; + delete p[i]; + p[i] = 0; } + delete[] p; + p = 0; + } - Array2D& operator[] (const size_t i) - { - return *(p[i]); - } - private: - Array2D** p; - const size_t m_xMax; + /** + * Accessor operator + * \param i index to be retrieved + * \return a reference to an Array2D of the indexed element + */ + Array2D& operator[] (const size_t i) + { + return *(p[i]); + } +private: + Array2D** p; //!< Stored elements + const size_t m_xMax; //!< maximum number of rows }; int diff --git a/src/nix-vector-routing/helper/ipv4-nix-vector-helper.h b/src/nix-vector-routing/helper/ipv4-nix-vector-helper.h index acbaaa35a30..cfa41e2056e 100644 --- a/src/nix-vector-routing/helper/ipv4-nix-vector-helper.h +++ b/src/nix-vector-routing/helper/ipv4-nix-vector-helper.h @@ -27,6 +27,8 @@ namespace ns3 { /** + * \ingroup nix-vector-routing + * * \brief Helper class that adds Nix-vector routing to nodes. * * This class is expected to be used in conjunction with @@ -68,6 +70,7 @@ class Ipv4NixVectorHelper : public Ipv4RoutingHelper /** * \brief Assignment operator declared private and not implemented to disallow * assignment and prevent the compiler from happily inserting its own. + * \return Nothing useful. */ Ipv4NixVectorHelper &operator = (const Ipv4NixVectorHelper &); diff --git a/src/nix-vector-routing/model/ipv4-nix-vector-routing.h b/src/nix-vector-routing/model/ipv4-nix-vector-routing.h index c248fe22c25..fb793be4565 100644 --- a/src/nix-vector-routing/model/ipv4-nix-vector-routing.h +++ b/src/nix-vector-routing/model/ipv4-nix-vector-routing.h @@ -57,7 +57,7 @@ class Ipv4NixVectorRouting : public Ipv4RoutingProtocol ~Ipv4NixVectorRouting (); /** * @brief The Interface ID of the Global Router interface. - * + * @return The Interface ID * @see Object::GetObject () */ static TypeId GetTypeId (void); @@ -83,63 +83,117 @@ class Ipv4NixVectorRouting : public Ipv4RoutingProtocol private: - /* flushes the cache which stores nix-vector based on - * destination IP */ + /** + * Flushes the cache which stores nix-vector based on + * destination IP + */ void FlushNixCache (void) const; - /* flushes the cache which stores the Ipv4 route - * based on the destination IP */ + /** + * Flushes the cache which stores the Ipv4 route + * based on the destination IP + */ void FlushIpv4RouteCache (void) const; - /* upon a run-time topology change caches are + /** + * Upon a run-time topology change caches are * flushed and the total number of neighbors is - * reset to zero */ + * reset to zero + */ void ResetTotalNeighbors (void); - /* takes in the source node and dest IP and calls GetNodeByIp, - * BFS, accounting for any output interface specified, and finally - * BuildNixVector to return the built nix-vector */ - Ptr GetNixVector (Ptr, Ipv4Address, Ptr); + /** + * Takes in the source node and dest IP and calls GetNodeByIp, + * BFS, accounting for any output interface specified, and finally + * BuildNixVector to return the built nix-vector + * + * \param source Source node + * \param dest Destination node address + * \param oif Preferred output interface + * \returns The NixVector to be used in routing. + */ + Ptr GetNixVector (Ptr source, Ipv4Address dest, Ptr oif); - /* checks the cache based on dest IP for the nix-vector */ - Ptr GetNixVectorInCache (Ipv4Address); + /** + * Checks the cache based on dest IP for the nix-vector + * \param address Address to check + * \returns The NixVector to be used in routing. + */ + Ptr GetNixVectorInCache (Ipv4Address address); - /* checks the cache based on dest IP for the Ipv4Route */ - Ptr GetIpv4RouteInCache (Ipv4Address); + /** + * Checks the cache based on dest IP for the Ipv4Route + * \param address Address to check + * \returns The cached route. + */ + Ptr GetIpv4RouteInCache (Ipv4Address address); - /* given a net-device returns all the adjacent net-devices, - * essentially getting the neighbors on that channel */ - void GetAdjacentNetDevices (Ptr, Ptr, NetDeviceContainer &); + /** + * Given a net-device returns all the adjacent net-devices, + * essentially getting the neighbors on that channel + * \param [in] netDevice the NetDevice attached to the channel. + * \param [in] channel the channel to check + * \param [out] netDeviceContainer the NetDeviceContainer of the NetDevices in the channel. + */ + void GetAdjacentNetDevices (Ptr netDevice, Ptr channel, NetDeviceContainer & netDeviceContainer); - /* iterates through the node list and finds the one - * corresponding to the given Ipv4Address */ - Ptr GetNodeByIp (Ipv4Address); + /** + * Iterates through the node list and finds the one + * corresponding to the given Ipv4Address + * \param dest detination node IP + * \return The node with the specified IP. + */ + Ptr GetNodeByIp (Ipv4Address dest); - /* Recurses the parent vector, created by BFS and actually builds the nixvector */ + /** + * Recurses the parent vector, created by BFS and actually builds the nixvector + * \param [in] parentVector Parent vector for retracing routes + * \param [in] source Source Node index + * \param [in] dest Destination Node index + * \param [out] nixVector the NixVector to be used for routing + * \returns true on success, false otherwise. + */ bool BuildNixVector (const std::vector< Ptr > & parentVector, uint32_t source, uint32_t dest, Ptr nixVector); - /* special variation of BuildNixVector for when a node is sending to itself */ + /** + * Special variation of BuildNixVector for when a node is sending to itself + * \param [out] nixVector the NixVector to be used for routing + * \returns true on success, false otherwise. + */ bool BuildNixVectorLocal (Ptr nixVector); - /* simple iterates through the nodes net-devices and determines - * how many neighbors it has */ + /** + * Simple iterates through the nodes net-devices and determines + * how many neighbors it has + * \returns the number of neighbors. + */ uint32_t FindTotalNeighbors (void); - /* determine if the netdevice is bridged */ + /** + * Determine if the NetDevice is bridged + * \param nd the NetDevice to check + * \returns the bridging NetDevice (or null if the NetDevice is not bridged) + */ Ptr NetDeviceIsBridged (Ptr nd) const; - /* Nix index is with respect to the neighbors. The net-device index must be - * derived from this */ + /** + * Nix index is with respect to the neighbors. The net-device index must be + * derived from this + * \param [in] nodeIndex Nix Node index + * \param [out] gatewayIp IP address of the gateway + * \returns the index of the NetDevice in the node. + */ uint32_t FindNetDeviceForNixIndex (uint32_t nodeIndex, Ipv4Address & gatewayIp); - /* Breadth first search algorithm - * Param1: total number of nodes - * Param2: Source Node - * Param3: Dest Node - * Param4: (returned) Parent vector for retracing routes - * Param5: specific output interface to use from source node, if not null - * Returns: false if dest not found, true o.w. + /** + * \brief Breadth first search algorithm. + * \param [in] numberOfNodes total number of nodes + * \param [in] source Source Node + * \param [in] dest Destination Node + * \param [out] parentVector Parent vector for retracing routes + * \param [in] oif specific output interface to use from source node, if not null + * \returns false if dest not found, true o.w. */ bool BFS (uint32_t numberOfNodes, Ptr source, @@ -161,28 +215,27 @@ class Ipv4NixVectorRouting : public Ipv4RoutingProtocol virtual void SetIpv4 (Ptr ipv4); virtual void PrintRoutingTable (Ptr stream, Time::Unit unit = Time::S) const; - /* + /** * Flushes routing caches if required. */ void CheckCacheStateAndFlush (void) const; - /* + /** * Flag to mark when caches are dirty and need to be flushed. * Used for lazy cleanup of caches when there are many topology changes. */ static bool g_isCacheDirty; - /* Cache stores nix-vectors based on destination ip */ + /** Cache stores nix-vectors based on destination ip */ mutable NixMap_t m_nixCache; - /* Cache stores Ipv4Routes based on destination ip */ + /** Cache stores Ipv4Routes based on destination ip */ mutable Ipv4RouteMap_t m_ipv4RouteCache; - Ptr m_ipv4; - Ptr m_node; + Ptr m_ipv4; //!< IPv4 object + Ptr m_node; //!< Node object - /* Total neighbors used for nix-vector to determine - * number of bits */ + /** Total neighbors used for nix-vector to determine number of bits */ uint32_t m_totalNeighbors; }; } // namespace ns3 From 5e19bd4b23778c330b8c798c4b406073b6e4b89f Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 22 May 2017 01:22:58 +0200 Subject: [PATCH 057/551] network: doxygen updates (partial) --- src/network/examples/main-packet-header.cc | 18 ++++++++++++++++-- src/network/examples/main-packet-tag.cc | 19 +++++++++++++++++-- src/network/model/buffer.h | 1 + src/network/model/byte-tag-list.h | 3 +++ src/network/model/packet-metadata.h | 13 +++++++++---- src/network/model/packet.h | 4 ++++ src/network/model/socket.h | 2 ++ src/network/utils/error-model.h | 4 ++++ src/network/utils/ethernet-header.h | 2 ++ src/network/utils/inet-socket-address.h | 1 + src/network/utils/ipv4-address.h | 2 ++ src/network/utils/queue.h | 4 +++- src/network/utils/sll-header.h | 4 ++-- 13 files changed, 66 insertions(+), 11 deletions(-) diff --git a/src/network/examples/main-packet-header.cc b/src/network/examples/main-packet-header.cc index 43e69c184f8..5f3afcf91f9 100644 --- a/src/network/examples/main-packet-header.cc +++ b/src/network/examples/main-packet-header.cc @@ -6,7 +6,9 @@ using namespace ns3; -/* A sample Header implementation +/** + * \ingroup network + * A simple example of an Header implementation */ class MyHeader : public Header { @@ -15,9 +17,21 @@ class MyHeader : public Header MyHeader (); virtual ~MyHeader (); + /** + * Set the header data. + * \param data The data. + */ void SetData (uint16_t data); + /** + * Get the header data. + * \return The data. + */ uint16_t GetData (void) const; + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual void Print (std::ostream &os) const; @@ -25,7 +39,7 @@ class MyHeader : public Header virtual uint32_t Deserialize (Buffer::Iterator start); virtual uint32_t GetSerializedSize (void) const; private: - uint16_t m_data; + uint16_t m_data; //!< Header data }; MyHeader::MyHeader () diff --git a/src/network/examples/main-packet-tag.cc b/src/network/examples/main-packet-tag.cc index b0598bf8ecf..ecc3fd684ad 100644 --- a/src/network/examples/main-packet-tag.cc +++ b/src/network/examples/main-packet-tag.cc @@ -24,10 +24,17 @@ using namespace ns3; -// define this class in a public header +/** + * \ingroup network + * A simple example of an Tag implementation + */ class MyTag : public Tag { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual uint32_t GetSerializedSize (void) const; @@ -36,10 +43,18 @@ class MyTag : public Tag virtual void Print (std::ostream &os) const; // these are our accessors to our tag structure + /** + * Set the tag value + * \param value The tag value. + */ void SetSimpleValue (uint8_t value); + /** + * Get the tag value + * \return the tag value. + */ uint8_t GetSimpleValue (void) const; private: - uint8_t m_simpleValue; + uint8_t m_simpleValue; //!< tag value }; TypeId diff --git a/src/network/model/buffer.h b/src/network/model/buffer.h index 373d2e4f086..9c9bd1b5595 100644 --- a/src/network/model/buffer.h +++ b/src/network/model/buffer.h @@ -382,6 +382,7 @@ class Buffer uint32_t GetRemainingSize (void) const; private: + /// Friend class friend class Buffer; /** * Constructor - initializes the iterator to point to the buffer start diff --git a/src/network/model/byte-tag-list.h b/src/network/model/byte-tag-list.h index c10a583dcd9..a8e1cb39577 100644 --- a/src/network/model/byte-tag-list.h +++ b/src/network/model/byte-tag-list.h @@ -87,7 +87,9 @@ class ByteTagList TagBuffer buf; //!< the data for the tag as generated by Tag::Serialize Item (TagBuffer buf); //!< constructs an item with the given TagBuffer private: + /// Friend class friend class ByteTagList; + /// Friend class friend class ByteTagList::Iterator; }; @@ -112,6 +114,7 @@ class ByteTagList */ uint32_t GetOffsetStart (void) const; private: + /// Friend class friend class ByteTagList; /** diff --git a/src/network/model/packet-metadata.h b/src/network/model/packet-metadata.h index 4a82839e5bb..aa4af291776 100644 --- a/src/network/model/packet-metadata.h +++ b/src/network/model/packet-metadata.h @@ -84,10 +84,11 @@ class PacketMetadata */ struct Item { - enum { - PAYLOAD, - HEADER, - TRAILER + /// Type of data in the packet + enum ItemType { + PAYLOAD, //!< Payload + HEADER, //!< Header + TRAILER //!< Trailer } type; //!< metadata type /** * true: this is a fragmented header, trailer, or, payload. @@ -252,6 +253,8 @@ class PacketMetadata /** * \brief Initialize the item iterator to the buffer begin + * \param buffer buffer to initialize. + * \return the buffer iterator. */ ItemIterator BeginItem (Buffer buffer) const; @@ -501,6 +504,7 @@ class PacketMetadata }; friend DataFreeList::~DataFreeList (); + /// Friend class friend class ItemIterator; PacketMetadata (); @@ -596,6 +600,7 @@ class PacketMetadata /** * \brief Get the total size used by the metadata + * \return the metadata used size */ uint32_t GetTotalSize (void) const; diff --git a/src/network/model/packet.h b/src/network/model/packet.h index ae871c9ca89..ead8bd03c2d 100644 --- a/src/network/model/packet.h +++ b/src/network/model/packet.h @@ -87,6 +87,7 @@ class ByteTagIterator */ void GetTag (Tag &tag) const; private: + /// Friend class friend class ByteTagIterator; /** * \brief Constructor @@ -111,6 +112,7 @@ class ByteTagIterator */ Item Next (void); private: + /// Friend class friend class Packet; /** * Copy Constructor @@ -149,6 +151,7 @@ class PacketTagIterator */ void GetTag (Tag &tag) const; private: + /// Friend class friend class PacketTagIterator; /** * Constructor @@ -166,6 +169,7 @@ class PacketTagIterator */ Item Next (void); private: + /// Friend class friend class Packet; /** * Constructor diff --git a/src/network/model/socket.h b/src/network/model/socket.h index d2b13885b5a..2493acba900 100644 --- a/src/network/model/socket.h +++ b/src/network/model/socket.h @@ -1024,6 +1024,8 @@ class Socket : public Object /** * \brief Notify through the callback (if set) that a new connection has been * created. + * \param socket The socket receiving the new connection. + * \param from The address of the node initiating the connection. */ void NotifyNewConnectionCreated (Ptr socket, const Address &from); diff --git a/src/network/utils/error-model.h b/src/network/utils/error-model.h index fb4b21d719b..4104386b1b5 100644 --- a/src/network/utils/error-model.h +++ b/src/network/utils/error-model.h @@ -465,6 +465,10 @@ class ReceiveListErrorModel : public ErrorModel class BinaryErrorModel : public ErrorModel { public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); BinaryErrorModel (); diff --git a/src/network/utils/ethernet-header.h b/src/network/utils/ethernet-header.h index 6273f1506ce..a15240a8e67 100644 --- a/src/network/utils/ethernet-header.h +++ b/src/network/utils/ethernet-header.h @@ -28,6 +28,8 @@ namespace ns3 { /** + * \ingroup network + * * Types of ethernet packets. Indicates the type of the current * header. */ diff --git a/src/network/utils/inet-socket-address.h b/src/network/utils/inet-socket-address.h index 218b5ec815f..095bdb5321d 100644 --- a/src/network/utils/inet-socket-address.h +++ b/src/network/utils/inet-socket-address.h @@ -117,6 +117,7 @@ class InetSocketAddress private: /** * \brief Convert to an Address type + * \return the Address corresponding to this object. */ Address ConvertTo (void) const; diff --git a/src/network/utils/ipv4-address.h b/src/network/utils/ipv4-address.h index 08133a92e00..48a6d515ed8 100644 --- a/src/network/utils/ipv4-address.h +++ b/src/network/utils/ipv4-address.h @@ -204,6 +204,7 @@ class Ipv4Address { /** * \brief Convert to an Address type + * \return the Address corresponding to this object. */ Address ConvertTo (void) const; @@ -294,6 +295,7 @@ class Ipv4Mask { void Set (uint32_t mask); /** * \brief Return the inverse mask in host order. + * \return The inverse mask */ uint32_t GetInverse (void) const; /** diff --git a/src/network/utils/queue.h b/src/network/utils/queue.h index c285672abb9..5eef2b952fe 100644 --- a/src/network/utils/queue.h +++ b/src/network/utils/queue.h @@ -210,7 +210,7 @@ class QueueBase : public Object // a buffer with the date of arrival of past received packets // which are within the average window // so, it is quite costly to do it all the time. - // Hence, it is disabled by default and must be explicitely + // Hence, it is disabled by default and must be explicitly // enabled with this method which specifies the size // of the average window in time units. void EnableRunningAverage (Time averageWindow); @@ -254,6 +254,7 @@ class QueueBase : public Object uint32_t m_maxBytes; //!< max bytes in the queue QueueMode m_mode; //!< queue mode (packets or bytes) + /// Friend class template friend class Queue; }; @@ -330,6 +331,7 @@ class Queue : public QueueBase protected: + /// Const iterator. typedef typename std::list >::const_iterator ConstIterator; /** diff --git a/src/network/utils/sll-header.h b/src/network/utils/sll-header.h index c475994486c..75d0272b2eb 100644 --- a/src/network/utils/sll-header.h +++ b/src/network/utils/sll-header.h @@ -107,9 +107,9 @@ class SllHeader : public Header */ void SetPacketType (PacketType type); - //! Inherited from ObjectBase + // Inherited from ObjectBase virtual TypeId GetInstanceTypeId (void) const; - //! Inherited from Header + // Inherited from Header virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start); From b786ec30024952010c84ce66b71fc4e00efb4141 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 24 May 2017 17:02:17 +0300 Subject: [PATCH 058/551] lte: Fix a typo: s/Componet/Component/ --- src/lte/model/lte-enb-component-carrier-manager.h | 2 +- src/lte/model/lte-enb-mac.h | 4 ++-- src/lte/model/lte-enb-rrc.h | 4 ++-- src/lte/model/lte-ue-rrc.h | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/lte/model/lte-enb-component-carrier-manager.h b/src/lte/model/lte-enb-component-carrier-manager.h index c56e66e0d25..cb19b927be3 100644 --- a/src/lte/model/lte-enb-component-carrier-manager.h +++ b/src/lte/model/lte-enb-component-carrier-manager.h @@ -187,7 +187,7 @@ class LteEnbComponentCarrierManager : public Object * So, LteEnbComponentCarrierManager class will receive function calls that are meant for MAC, and * will forward them to the MAC of the component carriers based on the logic implemented * in LteComponentCarrierManager. This attribute will be initialized by using class that implements - * LteMacSapProvider interface and class that implements LteEnbComponetnCarrierManager base class + * LteMacSapProvider interface and class that implements LteEnbComponentCarrierManager base class * e.g.:EnbMacMemberLteMacSapProvider */ LteMacSapProvider* m_macSapProvider;//!< A pointer to main SAP interface of the MAC instance, which is in this case handled by CCM. diff --git a/src/lte/model/lte-enb-mac.h b/src/lte/model/lte-enb-mac.h index 5d85957572c..e4515741b8c 100644 --- a/src/lte/model/lte-enb-mac.h +++ b/src/lte/model/lte-enb-mac.h @@ -135,8 +135,8 @@ class LteEnbMac : public Object void SetLteEnbPhySapProvider (LteEnbPhySapProvider* s); /** - * \brief Get the eNB-ComponetCarrierManager SAP User - * \return a pointer to the SAP User of the ComponetCarrierManager + * \brief Get the eNB-ComponentCarrierManager SAP User + * \return a pointer to the SAP User of the ComponentCarrierManager */ LteCcmMacSapProvider* GetLteCcmMacSapProvider (); diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 5ae6027e7db..41f8ef58cc7 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -1303,9 +1303,9 @@ class LteEnbRrc : public Object /// Interface to the handover algorithm instance. LteHandoverManagementSapProvider* m_handoverManagementSapProvider; - /// Receive API calls from the LteEnbComponetCarrierManager instance. + /// Receive API calls from the LteEnbComponentCarrierManager instance. LteCcmRrcSapUser* m_ccmRrcSapUser; - /// Interface to the LteEnbComponetCarrierManager instance. + /// Interface to the LteEnbComponentCarrierManager instance. LteCcmRrcSapProvider* m_ccmRrcSapProvider; /// Receive API calls from the ANR instance. diff --git a/src/lte/model/lte-ue-rrc.h b/src/lte/model/lte-ue-rrc.h index 9f275cc400b..db3501393a3 100644 --- a/src/lte/model/lte-ue-rrc.h +++ b/src/lte/model/lte-ue-rrc.h @@ -692,9 +692,9 @@ class LteUeRrc : public Object LteAsSapProvider* m_asSapProvider; ///< AS SAP provider LteAsSapUser* m_asSapUser; ///< AS SAP user - // Receive API calls from the LteUeComponetCarrierManager instance. + // Receive API calls from the LteUeComponentCarrierManager instance. // LteCcmRrcSapUser* m_ccmRrcSapUser; - /// Interface to the LteUeComponetCarrierManage instance. + /// Interface to the LteUeComponentCarrierManage instance. LteUeCcmRrcSapProvider* m_ccmRrcSapProvider; ///< CCM RRC SAP provider LteUeCcmRrcSapUser* m_ccmRrcSapUser; ///< CCM RRC SAP user From c024e94a145d9de7e028f9f59c7afd9c677eb743 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 25 May 2017 14:52:52 +0300 Subject: [PATCH 059/551] lte: Fix a typo: s/nuber/number/ --- src/lte/model/lte-ue-cmac-sap.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-ue-cmac-sap.h b/src/lte/model/lte-ue-cmac-sap.h index dab14af17b8..7ba05d6cedd 100644 --- a/src/lte/model/lte-ue-cmac-sap.h +++ b/src/lte/model/lte-ue-cmac-sap.h @@ -45,7 +45,7 @@ class LteUeCmacSapProvider /// RachConfig structure struct RachConfig { - uint8_t numberOfRaPreambles; ///< nuber of RA preambles + uint8_t numberOfRaPreambles; ///< number of RA preambles uint8_t preambleTransMax; ///< preamble transmit maximum uint8_t raResponseWindowSize; ///< RA response window size }; From 39f4b63dc0a14a5c3d05d0af310cf371c02629df Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 25 May 2017 07:59:28 -0700 Subject: [PATCH 060/551] wimax: Fix additional Doxygen warnings --- src/wimax/model/bandwidth-manager.h | 5 ++++- src/wimax/model/bs-link-manager.h | 7 ++++++- src/wimax/model/bs-net-device.h | 4 +++- src/wimax/model/bs-scheduler-rtps.h | 10 ++++++++-- src/wimax/model/bs-service-flow-manager.h | 4 ++++ src/wimax/model/bs-uplink-scheduler-mbqos.h | 1 + src/wimax/model/burst-profile-manager.h | 5 ++++- src/wimax/model/cid.h | 1 + src/wimax/model/cs-parameters.h | 4 ++++ src/wimax/model/dl-mac-messages.h | 20 +++++++++++++------ src/wimax/model/mac-messages.h | 2 +- src/wimax/model/service-flow.h | 8 ++++++-- src/wimax/model/simple-ofdm-wimax-phy.h | 1 + .../model/snr-to-block-error-rate-manager.h | 1 + src/wimax/model/ss-link-manager.h | 5 ++++- src/wimax/model/ss-scheduler.h | 5 ++++- src/wimax/model/wimax-connection.h | 1 + src/wimax/model/wimax-mac-queue.h | 5 ++++- src/wimax/model/wimax-net-device.h | 5 ++++- src/wimax/model/wimax-phy.h | 1 + src/wimax/model/wimax-tlv.h | 16 ++++++++++++--- 21 files changed, 89 insertions(+), 22 deletions(-) diff --git a/src/wimax/model/bandwidth-manager.h b/src/wimax/model/bandwidth-manager.h index 2fbe9904de1..d272f76b831 100644 --- a/src/wimax/model/bandwidth-manager.h +++ b/src/wimax/model/bandwidth-manager.h @@ -102,7 +102,10 @@ class BandwidthManager : public Object private: /// Bandwidth manager type conversion operator BandwidthManager (const BandwidthManager &); - /// Bandwidth manager assignement operator + /** + * Bandwidth manager assignment operator + * \returns the bandwidth manager + */ BandwidthManager& operator= (const BandwidthManager &); Ptr m_device; ///< the device diff --git a/src/wimax/model/bs-link-manager.h b/src/wimax/model/bs-link-manager.h index 7747011e3f9..08ac8a7adfe 100644 --- a/src/wimax/model/bs-link-manager.h +++ b/src/wimax/model/bs-link-manager.h @@ -67,12 +67,17 @@ class BSLinkManager : public Object void ProcessRangingRequest (Cid cid, RngReq rngreq); /** * \brief Verifies at the end of an invited ranging interval if SS sent ranging message in it or not + * \param cid the connection identifier in which the ranging message was received + * \param uiuc the ranging */ void VerifyInvitedRanging (Cid cid, uint8_t uiuc); private: /// copy constructor (disabled) BSLinkManager (const BSLinkManager &); - /// assignment operator (disabled) + /** + * assignment operator (disabled) + * \returns the BS link manager + */ BSLinkManager & operator= (const BSLinkManager &); /** diff --git a/src/wimax/model/bs-net-device.h b/src/wimax/model/bs-net-device.h index 187217ae369..daf8b97d983 100644 --- a/src/wimax/model/bs-net-device.h +++ b/src/wimax/model/bs-net-device.h @@ -330,8 +330,10 @@ class BaseStationNetDevice : public WimaxNetDevice void CreateMapMessages (void); /** * \brief creates the channel descriptor MAC management messages DCD and UCD + * \param sendDcd true if send DCD + * \param sendUcd true if send UCD */ - void CreateDescriptorMessages (bool sendDcd, bool senUcd); + void CreateDescriptorMessages (bool sendDcd, bool sendUcd); /** * \brief Send burst function */ diff --git a/src/wimax/model/bs-scheduler-rtps.h b/src/wimax/model/bs-scheduler-rtps.h index 7121ab14b50..3f0d495798c 100644 --- a/src/wimax/model/bs-scheduler-rtps.h +++ b/src/wimax/model/bs-scheduler-rtps.h @@ -116,26 +116,32 @@ class BSSchedulerRtps : public BSScheduler * * The method return the UGS connection that have packets to transmits, * according to the MaxLatency specifications. - * \param connection will point to a connection that have packets to be sent + * \param connection will point to a connection that has packets to be sent * \return true if successful */ bool SelectUGSConnection (Ptr &connection); /** * \brief Check for rtPS connections that have packets to transmit. + * \param connection will point to a connection that has packets to be sent + * \returns false if no connection has packets to be sent, true otherwise */ bool SelectRTPSConnection (Ptr &connection); /** * \brief Check for nrtPS connections that have packets to transmit. + * \param connection will point to a connection that has packets to be sent + * \returns false if no connection has packets to be sent, true otherwise */ bool SelectNRTPSConnection (Ptr &connection); /** * \brief Check for BE connections that have packets to transmit. + * \param connection will point to a connection that has packets to be sent + * \returns false if no connection has packets to be sent, true otherwise */ bool SelectBEConnection (Ptr &connection); /** * \brief Selects a connection from the list of connections having packets to be sent . - * \param connection will point to a connection that have packets to be sent + * \param connection will point to a connection that has packets to be sent * \returns false if no connection has packets to be sent, true otherwise */ bool SelectConnection (Ptr &connection); diff --git a/src/wimax/model/bs-service-flow-manager.h b/src/wimax/model/bs-service-flow-manager.h index 02aee2cb691..d824c464536 100644 --- a/src/wimax/model/bs-service-flow-manager.h +++ b/src/wimax/model/bs-service-flow-manager.h @@ -102,6 +102,8 @@ class BsServiceFlowManager : public ServiceFlowManager void AllocateServiceFlows (const DsaReq &dsaReq, Cid cid); /** * \brief add a multicast service flow + * \param sf the service flow + * \param modulation the wimax phy modulation type */ void AddMulticastServiceFlow (ServiceFlow sf, enum WimaxPhy::ModulationType modulation); /** @@ -133,6 +135,8 @@ class BsServiceFlowManager : public ServiceFlowManager uint8_t GetMaxDsaRspRetries (void) const; /** * Create DSA response function + * \param serviceFlow service flow + * \param cid the identifier of the connection on which the message was received */ void ScheduleDsaRsp (ServiceFlow *serviceFlow, Cid cid); Ptr m_device; ///< the device diff --git a/src/wimax/model/bs-uplink-scheduler-mbqos.h b/src/wimax/model/bs-uplink-scheduler-mbqos.h index 2976d060862..d71d015e950 100644 --- a/src/wimax/model/bs-uplink-scheduler-mbqos.h +++ b/src/wimax/model/bs-uplink-scheduler-mbqos.h @@ -257,6 +257,7 @@ class UplinkSchedulerMBQoS : public UplinkScheduler /** * Set requested bandwidth + * \param sfr the service flow record */ void OnSetRequestedBandwidth (ServiceFlowRecord *sfr); diff --git a/src/wimax/model/burst-profile-manager.h b/src/wimax/model/burst-profile-manager.h index 9a9bd088728..128420fec01 100644 --- a/src/wimax/model/burst-profile-manager.h +++ b/src/wimax/model/burst-profile-manager.h @@ -98,7 +98,10 @@ class BurstProfileManager : public Object private: /// Type conversion operator BurstProfileManager (const BurstProfileManager &); - /// Assignment operator + /** + * Assignment operator + * \returns burst profile manager + */ BurstProfileManager& operator= (const BurstProfileManager &); Ptr m_device; ///< the device diff --git a/src/wimax/model/cid.h b/src/wimax/model/cid.h index 298489802b2..79ed8369d0b 100644 --- a/src/wimax/model/cid.h +++ b/src/wimax/model/cid.h @@ -92,6 +92,7 @@ class Cid static Cid InitialRanging (void); private: + /// allow CidFactory class friend access friend class CidFactory; /// equality operator friend bool operator == (const Cid &lhs, const Cid &rhs); diff --git a/src/wimax/model/cs-parameters.h b/src/wimax/model/cs-parameters.h index 064109ace64..e2abf154871 100644 --- a/src/wimax/model/cs-parameters.h +++ b/src/wimax/model/cs-parameters.h @@ -46,10 +46,13 @@ class CsParameters ~CsParameters (); /** * \brief creates a convergence sub-layer parameters from a tlv + * \param tlv the TLV */ CsParameters (Tlv tlv); /** * \brief creates a convergence sub-layer parameters from an ipcs classifier record + * \param classifierDscAction the DCS action type + * \param classifier the IPCS classifier record */ CsParameters (enum Action classifierDscAction, IpcsClassifierRecord classifier); /** @@ -59,6 +62,7 @@ class CsParameters void SetClassifierDscAction (enum Action action); /** * \brief sets the packet classifier rules + * \param packetClassifierRule the IPCS classifier record */ void SetPacketClassifierRule (IpcsClassifierRecord packetClassifierRule); /** diff --git a/src/wimax/model/dl-mac-messages.h b/src/wimax/model/dl-mac-messages.h index a375740b70a..0216bcbe461 100644 --- a/src/wimax/model/dl-mac-messages.h +++ b/src/wimax/model/dl-mac-messages.h @@ -301,20 +301,28 @@ class OfdmDlBurstProfile * \returns the type */ uint8_t GetType (void) const; - /// Get length field + /** \returns the length field */ uint8_t GetLength (void) const; - /// Get DIUC field + /** \returns the DIUC field */ uint8_t GetDiuc (void) const; - /// Get FEC code type functon + /** \returns the FEC code type */ uint8_t GetFecCodeType (void) const; - /// Get size + /** \returns the size */ uint16_t GetSize (void) const; - /// Write item + /** + * Write item + * \param start the starting item iterator + * \returns the iterator + */ Buffer::Iterator Write (Buffer::Iterator start) const; - /// Read item + /** + * Read item + * \param start the starting item iterator + * \returns the iterator + */ Buffer::Iterator Read (Buffer::Iterator start); private: uint8_t m_type; ///< type diff --git a/src/wimax/model/mac-messages.h b/src/wimax/model/mac-messages.h index d8643bc558d..3edaf2c2ff3 100644 --- a/src/wimax/model/mac-messages.h +++ b/src/wimax/model/mac-messages.h @@ -78,7 +78,7 @@ class ManagementMessageType : public Header */ uint8_t GetType (void) const; - /// Get name field + /** \returns the name field */ std::string GetName (void) const; /** * \brief Get the type ID. diff --git a/src/wimax/model/service-flow.h b/src/wimax/model/service-flow.h index dd833c7286b..7044dc743f9 100644 --- a/src/wimax/model/service-flow.h +++ b/src/wimax/model/service-flow.h @@ -138,7 +138,11 @@ class ServiceFlow enum Direction direction, Ptr connection); ~ServiceFlow (void); - /// assignment operator + /** + * assignment operator + * \param o the service flow to assign + * \returns the service flow + */ ServiceFlow & operator = (ServiceFlow const& o); /// Initial values @@ -500,7 +504,7 @@ class ServiceFlow void SetArqSyncLoss (uint16_t syncLoss); /** * Set ARQ deliver in order - * /param inOrder the deliver in order setting + * \param inOrder the deliver in order setting */ void SetArqDeliverInOrder (uint8_t inOrder); /** diff --git a/src/wimax/model/simple-ofdm-wimax-phy.h b/src/wimax/model/simple-ofdm-wimax-phy.h index b2e787fa4cc..f6a5f1be36e 100644 --- a/src/wimax/model/simple-ofdm-wimax-phy.h +++ b/src/wimax/model/simple-ofdm-wimax-phy.h @@ -90,6 +90,7 @@ class SimpleOfdmWimaxPhy : public WimaxPhy void DoAttach (Ptr channel); /** * \brief set the callback function to call when a burst is received + * \param callback the receive callback function */ void SetReceiveCallback (Callback, Ptr > callback); /** diff --git a/src/wimax/model/snr-to-block-error-rate-manager.h b/src/wimax/model/snr-to-block-error-rate-manager.h index 6ef13e6a9d8..73b274877d3 100644 --- a/src/wimax/model/snr-to-block-error-rate-manager.h +++ b/src/wimax/model/snr-to-block-error-rate-manager.h @@ -97,6 +97,7 @@ class SNRToBlockErrorRateManager void ReLoadTraces (void); /** * \brief If activate loss is called with false, all the returned BlcER will be 0 (no losses) + * \param loss true to activates losses */ void ActivateLoss (bool loss); private: diff --git a/src/wimax/model/ss-link-manager.h b/src/wimax/model/ss-link-manager.h index 45de54d34b0..ca50f0a130b 100644 --- a/src/wimax/model/ss-link-manager.h +++ b/src/wimax/model/ss-link-manager.h @@ -134,7 +134,10 @@ class SSLinkManager : public Object private: /// type conversion operator SSLinkManager (const SSLinkManager &); - /// assignment operator + /** + * assignment operator + * \returns SS link manager + */ SSLinkManager & operator= (const SSLinkManager &); /** diff --git a/src/wimax/model/ss-scheduler.h b/src/wimax/model/ss-scheduler.h index a3ef55e0e6a..b84f08691f5 100644 --- a/src/wimax/model/ss-scheduler.h +++ b/src/wimax/model/ss-scheduler.h @@ -82,7 +82,10 @@ class SSScheduler : public Object private: /// type conversion operator SSScheduler (const SSScheduler &); - /// assignment operator + /** + * assignment operator + * \returns the SS scheduler + */ SSScheduler & operator= (const SSScheduler &); /** diff --git a/src/wimax/model/wimax-connection.h b/src/wimax/model/wimax-connection.h index bc820614444..df6968ce28e 100644 --- a/src/wimax/model/wimax-connection.h +++ b/src/wimax/model/wimax-connection.h @@ -132,6 +132,7 @@ class WimaxConnection : public Object typedef std::list > FragmentsQueue; /** * \brief get a queue of received fragments + * \returns the fragments queue */ const FragmentsQueue GetFragmentsQueue (void) const; /** diff --git a/src/wimax/model/wimax-mac-queue.h b/src/wimax/model/wimax-mac-queue.h index 5e4903e1579..163f457cbf2 100644 --- a/src/wimax/model/wimax-mac-queue.h +++ b/src/wimax/model/wimax-mac-queue.h @@ -118,7 +118,10 @@ class WimaxMacQueue : public Object */ Ptr Peek (MacHeaderType::HeaderType packetType, Time &timeStamp) const; - /// Check if queue is empty + /** + * Check if queue is empty + * \returns true if empty + */ bool IsEmpty (void) const; /** diff --git a/src/wimax/model/wimax-net-device.h b/src/wimax/model/wimax-net-device.h index 6a4eaba383e..15dd46eeddc 100644 --- a/src/wimax/model/wimax-net-device.h +++ b/src/wimax/model/wimax-net-device.h @@ -476,7 +476,10 @@ class WimaxNetDevice : public NetDevice private: /// copy constructor (disabled) WimaxNetDevice (const WimaxNetDevice &); - /// assignment operator (disabled) + /** + * assignment operator (disabled) + * \returns the wimax net device + */ WimaxNetDevice & operator= (const WimaxNetDevice &); /// Maximum MSDU size diff --git a/src/wimax/model/wimax-phy.h b/src/wimax/model/wimax-phy.h index a348c0cea51..91cc8273510 100644 --- a/src/wimax/model/wimax-phy.h +++ b/src/wimax/model/wimax-phy.h @@ -114,6 +114,7 @@ class WimaxPhy : public Object virtual void Send (SendParams *params) = 0; /** * \brief Get the type of the physical layer + * \returns the phy type */ virtual PhyType GetPhyType (void) const = 0; /** diff --git a/src/wimax/model/wimax-tlv.h b/src/wimax/model/wimax-tlv.h index f082f79563d..17bfc587145 100644 --- a/src/wimax/model/wimax-tlv.h +++ b/src/wimax/model/wimax-tlv.h @@ -63,7 +63,10 @@ class TlvValue * \returns the */ virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLen ) = 0; - /// Copy function + /** + * Copy function + * \returns the TLV value + */ virtual TlvValue * Copy (void) const = 0; private: }; @@ -141,9 +144,16 @@ class Tlv : public Header * \returns the TLV value */ TlvValue * CopyValue (void) const; - /// assignment operator + /** + * assignment operator + * \param o the TLV to assign + * \returns the TLV + */ Tlv &operator = (Tlv const& o); - /// type conversion operator + /** + * type conversion operator + * \param tlv the TLV + */ Tlv (const Tlv & tlv); private: From c694902493c30865546ef81d14f1d002d1a69e26 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 25 May 2017 08:02:44 -0700 Subject: [PATCH 061/551] bindings: (fixes #2742) Handle pybindgen release versions --- bindings/python/wscript | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/bindings/python/wscript b/bindings/python/wscript index 39479fd2b6c..a10bee87c94 100644 --- a/bindings/python/wscript +++ b/bindings/python/wscript @@ -68,8 +68,14 @@ def options(opt): def split_version(version): - ver = re.split('[.+]', version)[:4] - return (int(ver[0]), int(ver[1]), int(ver[2]), int(ver[3].split('post')[1])) + if (re.search ('post', version)): + # Version format such as '0.17.0.post58+ngcf00cc0' + ver = re.split('[.+]', version)[:4] + return (int(ver[0]), int(ver[1]), int(ver[2]), int(ver[3].split('post')[1])) + else: + # Version format such as '0.18.0' + ver = re.split('[.]', version)[:3] + return (int(ver[0]), int(ver[1]), int(ver[2]), 0) def configure(conf): From f05e1e651df6f01d526b89c52b82b7d9a52cf1be Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 25 May 2017 18:55:21 +0300 Subject: [PATCH 062/551] lte: Comment fixes --- src/lte/model/epc-sgw-pgw-application.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/model/epc-sgw-pgw-application.h b/src/lte/model/epc-sgw-pgw-application.h index d016f20dad5..3c03c42f121 100644 --- a/src/lte/model/epc-sgw-pgw-application.h +++ b/src/lte/model/epc-sgw-pgw-application.h @@ -292,11 +292,11 @@ class EpcSgwPgwApplication : public Application /// EnbInfo structure struct EnbInfo { - Ipv4Address enbAddr; ///< ENB address + Ipv4Address enbAddr; ///< eNB address Ipv4Address sgwAddr; ///< SGW address }; - std::map m_enbInfoByCellId; ///< END infor by cell ID + std::map m_enbInfoByCellId; ///< eNB info by cell ID }; } //namespace ns3 From 4bbf7c5e1bc300e4877de2962d5c4b76fb5d5777 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 24 May 2017 18:41:21 +0300 Subject: [PATCH 063/551] test.py: (fixes #2743) Treat memory leaks as errors without parsing valgrind output Valgrinds prints LEAK SUMMARY even if leak is suppressed. Instead of parsing valgrind output, which is error prone, it is possible to make valgrind treat leaks as errors by passing "--show-leak-kinds=all" argument. --- test.py | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/test.py b/test.py index 15e08e467dd..0ac1575cd44 100755 --- a/test.py +++ b/test.py @@ -754,7 +754,7 @@ def run_job_synchronously(shell_command, directory, valgrind, is_python, build_p path_cmd = os.path.join (NS3_BUILDDIR, shell_command) if valgrind: - cmd = "valgrind --suppressions=%s --leak-check=full --show-reachable=yes --error-exitcode=2 %s" % (suppressions_path, + cmd = "valgrind --suppressions=%s --leak-check=full --show-reachable=yes --error-exitcode=2 --errors-for-leak-kinds=all %s" % (suppressions_path, path_cmd) else: cmd = path_cmd @@ -781,18 +781,6 @@ def run_job_synchronously(shell_command, directory, valgrind, is_python, build_p print(stderr_results) retval = 1 - # - # valgrind sometimes has its own idea about what kind of memory management - # errors are important. We want to detect *any* leaks, so the way to do - # that is to look for the presence of a valgrind leak summary section. - # - # If another error has occurred (like a test suite has failed), we don't - # want to trump that error, so only do the valgrind output scan if the - # test has otherwise passed (return code was zero). - # - if valgrind and retval == 0 and "== LEAK SUMMARY:" in stderr_results: - retval = 2 - if options.verbose: print("Return code = ", retval) print("stderr = ", stderr_results) From 6c0840352d206176ddbe3e4b60c44fd2cbf5bc98 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Sun, 28 May 2017 10:21:32 +0200 Subject: [PATCH 064/551] traffic-control: Add the mq queue disc --- CHANGES.html | 2 + doc/models/Makefile | 1 + doc/models/source/traffic-control.rst | 1 + .../ns3wifi/wifi-ac-mapping-test-suite.cc | 117 ++++++++++++++---- src/traffic-control/doc/mq.rst | 83 +++++++++++++ src/traffic-control/model/mq-queue-disc.cc | 101 +++++++++++++++ src/traffic-control/model/mq-queue-disc.h | 66 ++++++++++ src/traffic-control/wscript | 2 + 8 files changed, 346 insertions(+), 27 deletions(-) create mode 100644 src/traffic-control/doc/mq.rst create mode 100644 src/traffic-control/model/mq-queue-disc.cc create mode 100644 src/traffic-control/model/mq-queue-disc.h diff --git a/CHANGES.html b/CHANGES.html index d2e74c9a85a..b2e1000d53f 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -93,6 +93,8 @@

New API:

which returns a vector of pairs (dscp,count), each of which indicates how many packets with the associated dscp value have been classified for a given flow. +
  • MqQueueDisc, a multi-queue aware queue disc modelled after the mq qdisc in Linux, has been introduced. +

    • Changes to existing API:

      diff --git a/doc/models/Makefile b/doc/models/Makefile index 405a08b828f..066bdf15b58 100644 --- a/doc/models/Makefile +++ b/doc/models/Makefile @@ -83,6 +83,7 @@ SOURCES = \ $(SRC)/traffic-control/doc/codel.rst \ $(SRC)/traffic-control/doc/fq-codel.rst \ $(SRC)/traffic-control/doc/pie.rst \ + $(SRC)/traffic-control/doc/mq.rst \ $(SRC)/spectrum/doc/spectrum.rst \ $(SRC)/stats/doc/adaptor.rst \ $(SRC)/stats/doc/aggregator.rst \ diff --git a/doc/models/source/traffic-control.rst b/doc/models/source/traffic-control.rst index fe5562513ed..1a6dddea014 100644 --- a/doc/models/source/traffic-control.rst +++ b/doc/models/source/traffic-control.rst @@ -10,3 +10,4 @@ Traffic Control Layer codel fq-codel pie + mq diff --git a/src/test/ns3wifi/wifi-ac-mapping-test-suite.cc b/src/test/ns3wifi/wifi-ac-mapping-test-suite.cc index 990c914de36..02e113be79a 100644 --- a/src/test/ns3wifi/wifi-ac-mapping-test-suite.cc +++ b/src/test/ns3wifi/wifi-ac-mapping-test-suite.cc @@ -41,6 +41,9 @@ #include "ns3/ipv4-address-helper.h" #include "ns3/packet-sink-helper.h" #include "ns3/on-off-helper.h" +#include "ns3/traffic-control-helper.h" +#include "ns3/traffic-control-layer.h" +#include "ns3/llc-snap-header.h" using namespace ns3; @@ -53,15 +56,54 @@ class WifiAcMappingTest : public TestCase virtual void DoRun (void); private: + static void PacketEnqueuedInQueueDisc (uint8_t tos, uint8_t* count, Ptr item); + static void PacketEnqueuedInWifiMacQueue (uint8_t tos, uint8_t* count, Ptr item); uint8_t m_tos; uint8_t m_expectedQueue; + uint8_t m_QueueDiscCount[4]; + uint8_t m_WifiMacQueueCount[4]; }; WifiAcMappingTest::WifiAcMappingTest (uint8_t tos, uint8_t expectedQueue) - : TestCase ("User priority to Access Category mapping test"), + : TestCase ("User priority to Access Category mapping test. Checks that packets are" + "enqueued in the correct child queue disc of the mq root queue disc and" + "in the correct wifi MAC queue"), m_tos (tos), m_expectedQueue (expectedQueue) { + for (uint8_t i = 0; i < 4; i++) + { + m_QueueDiscCount[i] = 0; + m_WifiMacQueueCount[i] = 0; + } +} + +void +WifiAcMappingTest::PacketEnqueuedInQueueDisc (uint8_t tos, uint8_t* count, Ptr item) +{ + uint8_t val; + if (item->GetUint8Value (QueueItem::IP_DSFIELD, val) && val == tos) + { + (*count)++; + } +} + +void +WifiAcMappingTest::PacketEnqueuedInWifiMacQueue (uint8_t tos, uint8_t* count, Ptr item) +{ + LlcSnapHeader llc; + Ptr packet = item->GetPacket ()->Copy (); + packet->RemoveHeader (llc); + + if (llc.GetType () == Ipv4L3Protocol::PROT_NUMBER) + { + Ipv4Header iph; + packet->PeekHeader (iph); + if (iph.GetTos () == tos) + { + (*count)++; + } + } } void @@ -111,6 +153,17 @@ WifiAcMappingTest::DoRun (void) stack.Install (ap); stack.Install (sta); + TrafficControlHelper tch; + uint16_t handle = tch.SetRootQueueDisc ("ns3::MqQueueDisc"); + TrafficControlHelper::ClassIdList cls = tch.AddQueueDiscClasses (handle, 4, "ns3::QueueDiscClass"); + TrafficControlHelper::HandleList hdl = tch.AddChildQueueDiscs (handle, cls, "ns3::FqCoDelQueueDisc"); + for (auto h : hdl) + { + tch.AddPacketFilter (h, "ns3::FqCoDelIpv4PacketFilter"); + } + tch.Install (apDev); + tch.Install (staDev); + Ipv4AddressHelper address; address.SetBase ("192.168.0.0", "255.255.255.0"); Ipv4InterfaceContainer staNodeInterface, apNodeInterface; @@ -123,7 +176,7 @@ WifiAcMappingTest::DoRun (void) InetSocketAddress (Ipv4Address::GetAny (), udpPort)); ApplicationContainer sinkApp = packetSink.Install (sta.Get (0)); sinkApp.Start (Seconds (0)); - sinkApp.Stop (Seconds (3.0)); + sinkApp.Stop (Seconds (4.0)); // The packet source is an on-off application on the AP device InetSocketAddress dest (staNodeInterface.GetAddress (0), udpPort); @@ -132,41 +185,49 @@ WifiAcMappingTest::DoRun (void) onoff.SetConstantRate (DataRate ("5kbps"), 500); ApplicationContainer sourceApp = onoff.Install (ap.Get (0)); sourceApp.Start (Seconds (1.0)); - sourceApp.Stop (Seconds (3.0)); + sourceApp.Stop (Seconds (4.0)); // The first packet will be transmitted at time 1+(500*8)/5000 = 1.8s. - // Let this packet be transmitted successfully, so that the AP can resolve - // the IP address of the station and get its MAC address. // The second packet will be transmitted at time 1.8+(500*8)/5000 = 2.6s. - // Put the AP in sleep mode at time 2.0s, so that the second packet remains - // in a wifi mac queue and we can discover the queue it has been sent to. - Ptr apPhy = DynamicCast (apDev.Get (0))->GetPhy (); - Simulator::ScheduleWithContext (ap.Get (0)->GetId (), Seconds (2.0), - &WifiPhy::SetSleepMode, apPhy); + // The third packet will be transmitted at time 2.6+(500*8)/5000 = 3.4s. + + Simulator::Stop (Seconds (5.0)); + + Ptr root = ap.Get (0)->GetObject ()->GetRootQueueDiscOnDevice (apDev.Get (0)); + NS_TEST_ASSERT_MSG_EQ (root->GetNQueueDiscClasses (), 4, "The root queue disc should have 4 classes"); + // Get the four child queue discs and connect their Enqueue trace to the PacketEnqueuedInQueueDisc + // method, which counts how many packets with the given ToS value have been enqueued + root->GetQueueDiscClass (0)->GetQueueDisc ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInQueueDisc, m_tos, m_QueueDiscCount)); - Simulator::Stop (Seconds (4.0)); + root->GetQueueDiscClass (1)->GetQueueDisc ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInQueueDisc, m_tos, m_QueueDiscCount+1)); + + root->GetQueueDiscClass (2)->GetQueueDisc ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInQueueDisc, m_tos, m_QueueDiscCount+2)); + + root->GetQueueDiscClass (3)->GetQueueDisc ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInQueueDisc, m_tos, m_QueueDiscCount+3)); Ptr apMac = DynamicCast (apDev.Get (0))->GetMac (); PointerValue ptr; - Ptr queues[4]; - // Get the four wifi mac queues and set their MaxDelay attribute to a large - // value, so that packets are not removed by the Cleanup method + // Get the four wifi mac queues and connect their Enqueue trace to the PacketEnqueuedInWifiMacQueue + // method, which counts how many packets with the given ToS value have been enqueued apMac->GetAttribute ("BE_EdcaTxopN", ptr); - queues[0] = ptr.Get ()->GetQueue (); - queues[0]->SetAttribute ("MaxDelay", TimeValue (Seconds (10.0))); + ptr.Get ()->GetQueue ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInWifiMacQueue, m_tos, m_WifiMacQueueCount)); apMac->GetAttribute ("BK_EdcaTxopN", ptr); - queues[1] = ptr.Get ()->GetQueue (); - queues[1]->SetAttribute ("MaxDelay", TimeValue (Seconds (10.0))); + ptr.Get ()->GetQueue ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInWifiMacQueue, m_tos, m_WifiMacQueueCount+1)); apMac->GetAttribute ("VI_EdcaTxopN", ptr); - queues[2] = ptr.Get ()->GetQueue (); - queues[2]->SetAttribute ("MaxDelay", TimeValue (Seconds (10.0))); + ptr.Get ()->GetQueue ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInWifiMacQueue, m_tos, m_WifiMacQueueCount+2)); apMac->GetAttribute ("VO_EdcaTxopN", ptr); - queues[3] = ptr.Get ()->GetQueue (); - queues[3]->SetAttribute ("MaxDelay", TimeValue (Seconds (10.0))); - + ptr.Get ()->GetQueue ()->TraceConnectWithoutContext ("Enqueue", + MakeBoundCallback (&WifiAcMappingTest::PacketEnqueuedInWifiMacQueue, m_tos, m_WifiMacQueueCount+3)); Simulator::Run (); @@ -174,19 +235,21 @@ WifiAcMappingTest::DoRun (void) { if (i == m_expectedQueue) { - NS_TEST_ASSERT_MSG_EQ (queues[i]->GetNPackets (), 1, "There is no packet in the expected queue " << i); + NS_TEST_ASSERT_MSG_GT_OR_EQ (m_QueueDiscCount[i], 1, "There is no packet in the expected queue disc " << i); + NS_TEST_ASSERT_MSG_GT_OR_EQ (m_WifiMacQueueCount[i], 1, "There is no packet in the expected Wifi MAC queue " << i); } else { - NS_TEST_ASSERT_MSG_EQ (queues[i]->GetNPackets (), 0, "Unexpectedly, there is a packet in queue " << i); + NS_TEST_ASSERT_MSG_EQ (m_QueueDiscCount[i], 0, "Unexpectedly, there is a packet in queue disc " << i); + NS_TEST_ASSERT_MSG_EQ (m_WifiMacQueueCount[i], 0, "Unexpectedly, there is a packet in Wifi MAC queue " << i); } } uint32_t totalOctetsThrough = DynamicCast (sinkApp.Get (0))->GetTotalRx (); - // Check that the first packet has been received - NS_TEST_ASSERT_MSG_EQ (totalOctetsThrough, 500, "A single packet should have been received"); + // Check that the three packets have been received + NS_TEST_ASSERT_MSG_EQ (totalOctetsThrough, 1500, "Three packets should have been received"); Simulator::Destroy (); } diff --git a/src/traffic-control/doc/mq.rst b/src/traffic-control/doc/mq.rst new file mode 100644 index 00000000000..6b973a91d94 --- /dev/null +++ b/src/traffic-control/doc/mq.rst @@ -0,0 +1,83 @@ +.. include:: replace.txt +.. highlight:: cpp +.. highlight:: bash + +Mq queue disc +------------------ + +This chapter describes the mq queue disc implementation in |ns3|. + +mq is a classful multiqueue dummy scheduler developed to best fit the multiqueue +traffic control API in Linux. The mq scheduler presents device transmission queues as +classes, allowing to attach different queue discs to them, which are grafted to the +device transmission queues. + +Model Description +***************** + +mq is a multi-queue aware queue disc, meaning that it has as many child queue discs as +the number of device transmission queues. Each child queue disc maps to a distinct +device transmission queue. Every packet is enqueued into the child queue disc which +maps to the device transmission queue in which the device will enqueue +the packet. + +In |ns3|, :cpp:class:`MqQueueDisc` has a wake mode of WAKE_CHILD, which means that the +traffic control layer enqueues packets directly into one of the child queue discs +(multi-queue devices can provide a callback to inform the traffic control layer of +the device transmission queue that will be selected for a given packet). Therefore, +``MqQueueDisc::DoEnqueue ()`` shall never be called (in fact, it raises a fatal error). +Given that dequeuing packets is triggered by enqueuing a packet in the queue disc or +by the device invoking the wake callback, it turns out that ``MqQueueDisc::DoDequeue ()`` +is never called as well (in fact, it raises a fatal error, too). + +The mq queue disc does not require packet filters, does not admit internal queues +and must have as many child queue discs as the number of device transmission queues. + +Examples +======== + +A typical usage pattern is to create a traffic control helper used to add the required number of +queue disc classes, attach child queue discs to the classes and (if needed) add packet filters to the +child queue discs. The following code shows how to install an mq queue disc having FqCodel child queue +discs: + +.. sourcecode:: cpp + + TrafficControlHelper tch; + uint16_t handle = tch.SetRootQueueDisc ("ns3::MqQueueDisc"); + TrafficControlHelper::ClassIdList cls = tch.AddQueueDiscClasses (handle, numTxQueues, "ns3::QueueDiscClass"); + TrafficControlHelper::HandleList hdl = tch.AddChildQueueDiscs (handle, cls, "ns3::FqCoDelQueueDisc"); + for (auto h : hdl) + { + tch.AddPacketFilter (h, "ns3::FqCoDelIpv4PacketFilter"); + } + QueueDiscContainer qdiscs = tch.Install (devices); + +Note that the child queue discs attached to the classes do not necessarily have to be of the same type. + +Validation +********** + +The mq model is tested using :cpp:class:`WifiAcMappingTestSuite` class defined in +`src/test/wifi-ac-mapping-test-suite.cc`. The suite considers a node with a QoS-enabled +wifi device (which has 4 transmission queues) and includes 4 test cases: + +* Test 1: EF-marked packets are enqueued in the queue disc which maps to the AC_VI queue +* Test 2: AF11-marked packets are enqueued in the queue disc which maps to the AC_BK queue +* Test 3: AF32-marked packets are enqueued in the queue disc which maps to the AC_BE queue +* Test 4: CS7-marked packets are enqueued in the queue disc which maps to the AC_VO queue + +The test suite can be run using the following commands: + +:: + + $ ./waf configure --enable-examples --enable-tests + $ ./waf build + $ ./test.py -s ns3-wifi-ac-mapping + +or + +:: + + $ NS_LOG="WifiAcMappingTest" ./waf --run "test-runner --suite=ns3-wifi-ac-mapping" + diff --git a/src/traffic-control/model/mq-queue-disc.cc b/src/traffic-control/model/mq-queue-disc.cc new file mode 100644 index 00000000000..6c2e51c89f3 --- /dev/null +++ b/src/traffic-control/model/mq-queue-disc.cc @@ -0,0 +1,101 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2016 Universita' degli Studi di Napoli Federico II + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Authors: Pasquale Imputato + * Stefano Avallone + */ + +#include "ns3/log.h" +#include "mq-queue-disc.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("MqQueueDisc"); + +NS_OBJECT_ENSURE_REGISTERED (MqQueueDisc); + +TypeId MqQueueDisc::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::MqQueueDisc") + .SetParent () + .SetGroupName ("TrafficControl") + .AddConstructor () + ; + return tid; +} + +MqQueueDisc::MqQueueDisc () +{ + NS_LOG_FUNCTION (this); +} + +MqQueueDisc::~MqQueueDisc () +{ + NS_LOG_FUNCTION (this); +} + +MqQueueDisc::WakeMode +MqQueueDisc::GetWakeMode (void) const +{ + return WAKE_CHILD; +} + +bool +MqQueueDisc::DoEnqueue (Ptr item) +{ + NS_FATAL_ERROR ("MqQueueDisc: DoEnqueue should never be called"); +} + +Ptr +MqQueueDisc::DoDequeue (void) +{ + NS_FATAL_ERROR ("MqQueueDisc: DoDequeue should never be called"); +} + +Ptr +MqQueueDisc::DoPeek (void) const +{ + NS_FATAL_ERROR ("MqQueueDisc: DoPeek should never be called"); +} + +bool +MqQueueDisc::CheckConfig (void) +{ + NS_LOG_FUNCTION (this); + + if (GetNPacketFilters () > 0) + { + NS_LOG_ERROR ("MqQueueDisc cannot have packet filters"); + return false; + } + + if (GetNInternalQueues () > 0) + { + NS_LOG_ERROR ("MqQueueDisc cannot have internal queues"); + return false; + } + + return true; +} + +void +MqQueueDisc::InitializeParams (void) +{ + NS_LOG_FUNCTION (this); +} + +} // namespace ns3 diff --git a/src/traffic-control/model/mq-queue-disc.h b/src/traffic-control/model/mq-queue-disc.h new file mode 100644 index 00000000000..8bf23c47773 --- /dev/null +++ b/src/traffic-control/model/mq-queue-disc.h @@ -0,0 +1,66 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2016 Universita' degli Studi di Napoli Federico II + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Authors: Pasquale Imputato + * Stefano Avallone + */ + +#ifndef MQ_QUEUE_DISC_H +#define MQ_QUEUE_DISC_H + +#include "ns3/queue-disc.h" + +namespace ns3 { + +/** + * \ingroup traffic-control + * + * mq is a classful multi-queue aware dummy scheduler. It has as many child + * queue discs as the number of device transmission queues. Packets are + * directly enqueued into and dequeued from child queue discs. + */ +class MqQueueDisc : public QueueDisc { +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + /** + * \brief MqQueueDisc constructor + */ + MqQueueDisc (); + + virtual ~MqQueueDisc(); + + /** + * \brief Return the wake mode adopted by this queue disc. + * \return the wake mode adopted by this queue disc. + */ + WakeMode GetWakeMode (void) const; + +private: + virtual bool DoEnqueue (Ptr item); + virtual Ptr DoDequeue (void); + virtual Ptr DoPeek (void) const; + virtual bool CheckConfig (void); + virtual void InitializeParams (void); +}; + +} // namespace ns3 + +#endif /* MQ_QUEUE_DISC_H */ diff --git a/src/traffic-control/wscript b/src/traffic-control/wscript index 21ebed4ef40..91dfeb7c6f3 100644 --- a/src/traffic-control/wscript +++ b/src/traffic-control/wscript @@ -17,6 +17,7 @@ def build(bld): 'model/codel-queue-disc.cc', 'model/fq-codel-queue-disc.cc', 'model/pie-queue-disc.cc', + 'model/mq-queue-disc.cc', 'helper/traffic-control-helper.cc', 'helper/queue-disc-container.cc' ] @@ -41,6 +42,7 @@ def build(bld): 'model/codel-queue-disc.h', 'model/fq-codel-queue-disc.h', 'model/pie-queue-disc.h', + 'model/mq-queue-disc.h', 'helper/traffic-control-helper.h', 'helper/queue-disc-container.h' ] From 2732d27e7549ddf4dd04cccf0a81c555239bc523 Mon Sep 17 00:00:00 2001 From: Sourabh Jain Date: Sun, 28 May 2017 10:21:38 +0200 Subject: [PATCH 065/551] traffic-control: Add Feng's Adaptive RED --- .../traffic-control/red-vs-fengadaptive.cc | 190 ++++++++++++++++++ examples/traffic-control/wscript | 3 + src/traffic-control/doc/red.rst | 33 ++- src/traffic-control/model/red-queue-disc.cc | 92 +++++++++ src/traffic-control/model/red-queue-disc.h | 47 +++++ .../test/red-queue-disc-test-suite.cc | 52 +++++ 6 files changed, 416 insertions(+), 1 deletion(-) create mode 100644 examples/traffic-control/red-vs-fengadaptive.cc diff --git a/examples/traffic-control/red-vs-fengadaptive.cc b/examples/traffic-control/red-vs-fengadaptive.cc new file mode 100644 index 00000000000..81826631583 --- /dev/null +++ b/examples/traffic-control/red-vs-fengadaptive.cc @@ -0,0 +1,190 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2016 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Sourabh Jain + * Mohit P. Tahiliani + */ + +#include "ns3/core-module.h" +#include "ns3/network-module.h" +#include "ns3/internet-module.h" +#include "ns3/point-to-point-module.h" +#include "ns3/applications-module.h" +#include "ns3/point-to-point-layout-module.h" +#include "ns3/traffic-control-module.h" + +#include +#include +#include + +using namespace ns3; + +int main (int argc, char *argv[]) +{ + uint32_t nLeaf = 10; + uint32_t maxPackets = 100; + bool modeBytes = false; + uint32_t queueDiscLimitPackets = 1000; + double minTh = 5; + double maxTh = 15; + uint32_t pktSize = 512; + std::string appDataRate = "10Mbps"; + std::string queueDiscType = "RED"; + uint16_t port = 5001; + std::string bottleNeckLinkBw = "1Mbps"; + std::string bottleNeckLinkDelay = "50ms"; + + CommandLine cmd; + cmd.AddValue ("nLeaf", "Number of left and right side leaf nodes", nLeaf); + cmd.AddValue ("maxPackets","Max Packets allowed in the device queue", maxPackets); + cmd.AddValue ("queueDiscLimitPackets","Max Packets allowed in the queue disc", queueDiscLimitPackets); + cmd.AddValue ("queueDiscType", "Set Queue disc type to RED or FengAdaptive", queueDiscType); + cmd.AddValue ("appPktSize", "Set OnOff App Packet Size", pktSize); + cmd.AddValue ("appDataRate", "Set OnOff App DataRate", appDataRate); + cmd.AddValue ("modeBytes", "Set Queue disc mode to Packets or bytes ", modeBytes); + + cmd.AddValue ("redMinTh", "RED queue minimum threshold", minTh); + cmd.AddValue ("redMaxTh", "RED queue maximum threshold", maxTh); + cmd.Parse (argc,argv); + + if ((queueDiscType != "RED") && (queueDiscType != "FengAdaptive")) + { + std::cout << "Invalid queue disc type: Use --queueDiscType=RED or --queueDiscType=FengAdaptive" << std::endl; + exit (1); + } + + Config::SetDefault ("ns3::OnOffApplication::PacketSize", UintegerValue (pktSize)); + Config::SetDefault ("ns3::OnOffApplication::DataRate", StringValue (appDataRate)); + + Config::SetDefault ("ns3::QueueBase::Mode", StringValue ("QUEUE_MODE_PACKETS")); + Config::SetDefault ("ns3::QueueBase::MaxPackets", UintegerValue (maxPackets)); + + if (!modeBytes) + { + Config::SetDefault ("ns3::RedQueueDisc::Mode", StringValue ("QUEUE_DISC_MODE_PACKETS")); + Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (queueDiscLimitPackets)); + } + else + { + Config::SetDefault ("ns3::RedQueueDisc::Mode", StringValue ("QUEUE_DISC_MODE_BYTES")); + Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (queueDiscLimitPackets * pktSize)); + minTh *= pktSize; + maxTh *= pktSize; + } + + Config::SetDefault ("ns3::RedQueueDisc::MinTh", DoubleValue (minTh)); + Config::SetDefault ("ns3::RedQueueDisc::MaxTh", DoubleValue (maxTh)); + Config::SetDefault ("ns3::RedQueueDisc::LinkBandwidth", StringValue (bottleNeckLinkBw)); + Config::SetDefault ("ns3::RedQueueDisc::LinkDelay", StringValue (bottleNeckLinkDelay)); + Config::SetDefault ("ns3::RedQueueDisc::MeanPktSize", UintegerValue (pktSize)); + + if (queueDiscType == "FengAdaptive") + { + // Turn on Feng's Adaptive RED + Config::SetDefault ("ns3::RedQueueDisc::FengAdaptive", BooleanValue (true)); + } + + // Create the point-to-point link helpers + PointToPointHelper bottleNeckLink; + bottleNeckLink.SetDeviceAttribute ("DataRate", StringValue (bottleNeckLinkBw)); + bottleNeckLink.SetChannelAttribute ("Delay", StringValue (bottleNeckLinkDelay)); + + PointToPointHelper pointToPointLeaf; + pointToPointLeaf.SetDeviceAttribute ("DataRate", StringValue ("10Mbps")); + pointToPointLeaf.SetChannelAttribute ("Delay", StringValue ("1ms")); + + PointToPointDumbbellHelper d (nLeaf, pointToPointLeaf, + nLeaf, pointToPointLeaf, + bottleNeckLink); + + // Install Stack + InternetStackHelper stack; + for (uint32_t i = 0; i < d.LeftCount (); ++i) + { + stack.Install (d.GetLeft (i)); + } + for (uint32_t i = 0; i < d.RightCount (); ++i) + { + stack.Install (d.GetRight (i)); + } + + stack.Install (d.GetLeft ()); + stack.Install (d.GetRight ()); + TrafficControlHelper tchBottleneck; + QueueDiscContainer queueDiscs; + tchBottleneck.SetRootQueueDisc ("ns3::RedQueueDisc"); + tchBottleneck.Install (d.GetLeft ()->GetDevice (0)); + queueDiscs = tchBottleneck.Install (d.GetRight ()->GetDevice (0)); + + // Assign IP Addresses + d.AssignIpv4Addresses (Ipv4AddressHelper ("10.1.1.0", "255.255.255.0"), + Ipv4AddressHelper ("10.2.1.0", "255.255.255.0"), + Ipv4AddressHelper ("10.3.1.0", "255.255.255.0")); + + // Install on/off app on all right side nodes + OnOffHelper clientHelper ("ns3::TcpSocketFactory", Address ()); + clientHelper.SetAttribute ("OnTime", StringValue ("ns3::UniformRandomVariable[Min=0.|Max=1.]")); + clientHelper.SetAttribute ("OffTime", StringValue ("ns3::UniformRandomVariable[Min=0.|Max=1.]")); + Address sinkLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port)); + PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", sinkLocalAddress); + ApplicationContainer sinkApps; + for (uint32_t i = 0; i < d.LeftCount (); ++i) + { + sinkApps.Add (packetSinkHelper.Install (d.GetLeft (i))); + } + sinkApps.Start (Seconds (0.0)); + sinkApps.Stop (Seconds (30.0)); + + ApplicationContainer clientApps; + for (uint32_t i = 0; i < d.RightCount (); ++i) + { + // Create an on/off app sending packets to the left side + AddressValue remoteAddress (InetSocketAddress (d.GetLeftIpv4Address (i), port)); + clientHelper.SetAttribute ("Remote", remoteAddress); + clientApps.Add (clientHelper.Install (d.GetRight (i))); + } + clientApps.Start (Seconds (1.0)); // Start 1 second after sink + clientApps.Stop (Seconds (15.0)); // Stop before the sink + + Ipv4GlobalRoutingHelper::PopulateRoutingTables (); + + std::cout << "Running the simulation" << std::endl; + Simulator::Run (); + + RedQueueDisc::Stats st = StaticCast (queueDiscs.Get (0))->GetStats (); + + if (st.unforcedDrop == 0) + { + std::cout << "There should be some unforced drops" << std::endl; + exit (1); + } + + if (st.qLimDrop != 0) + { + std::cout << "There should be zero drops due to queue full" << std::endl; + exit (1); + } + + std::cout << "*** Stats from the bottleneck queue disc ***" << std::endl; + std::cout << "\t " << st.unforcedDrop << " drops due to prob mark" << std::endl; + std::cout << "\t " << st.forcedDrop << " drops due to hard mark" << std::endl; + std::cout << "\t " << st.qLimDrop << " drops due to queue full" << std::endl; + std::cout << "Destroying the simulation" << std::endl; + + Simulator::Destroy (); + return 0; +} diff --git a/examples/traffic-control/wscript b/examples/traffic-control/wscript index b943e56a7fa..1204d8b63dc 100644 --- a/examples/traffic-control/wscript +++ b/examples/traffic-control/wscript @@ -8,3 +8,6 @@ def build(bld): obj = bld.create_ns3_program('queue-discs-benchmark', ['internet', 'point-to-point', 'applications', 'internet-apps', 'traffic-control', 'flow-monitor']) obj.source = 'queue-discs-benchmark.cc' + + obj = bld.create_ns3_program('red-vs-fengadaptive', ['point-to-point', 'point-to-point-layout', 'internet', 'applications', 'traffic-control']) + obj.source = 'red-vs-fengadaptive.cc' diff --git a/src/traffic-control/doc/red.rst b/src/traffic-control/doc/red.rst index 53253def123..cd335946740 100644 --- a/src/traffic-control/doc/red.rst +++ b/src/traffic-control/doc/red.rst @@ -35,6 +35,12 @@ in ns-3 contains implementation of both the features, and is a port of Sally Floyd's ns-2 ARED model. Note that the user is allowed to choose and explicitly configure the simulation by selecting feature (i) or feature (ii), or both. +Feng's Adaptive RED +=================== +Feng's Adaptive RED is a variant of RED that adapts the maximum drop +probability. The model in ns-3 contains implementation of this feature, and is a +port of ns-2 Feng's Adaptive RED model. + Explicit Congestion Notification (ECN) ====================================== This RED model supports an ECN mode of operation to notify endpoints of @@ -57,12 +63,16 @@ the ``Mark ()`` method. References ========== -The RED queue aims to be close to the results cited in: +The RED queue disc aims to be close to the results cited in: S.Floyd, K.Fall http://icir.org/floyd/papers/redsims.ps ARED queue implementation is based on the algorithm provided in: S. Floyd et al, http://www.icir.org/floyd/papers/adaptiveRed.pdf +Feng's Adaptive RED queue implementation is based on the algorithm +provided in: +W. C. Feng et al, http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=752150 + The addition of explicit congestion notification (ECN) to IP: K. K. Ramakrishnan et al, https://tools.ietf.org/html/rfc3168 @@ -99,6 +109,14 @@ In addition to RED attributes, ARED queue requires following attributes: * Beta (decrement parameter for m_curMaxP) * RTT +In addition to RED attributes, Feng's Adaptive RED queue requires following +attributes: + +* FengAdaptive (Boolean attribute, Default: false) +* Status (status of current queue length, Default: Above) +* FengAlpha (increment parameter for m_curMaxP, Default: 3) +* FengBeta (decrement parameter for m_curMaxP, Default: 2) + Consult the ns-3 documentation for explanation of these attributes. Simulating ARED @@ -133,6 +151,16 @@ To configure (ii); AdaptMaxP must be set to true, as done in Config::SetDefault ("ns3::RedQueueDisc::AdaptMaxP", BooleanValue (true)); +Simulating Feng's Adaptive RED +============================== + +To switch on Feng's Adaptive RED algorithm, the attribute FengAdaptive must be +set to true, as done in ``examples/traffic-control/red-vs-fengadaptive.cc``: + +.. sourcecode:: cpp + + Config::SetDefault ("ns3::RedQueueDisc::FengAdaptive", BooleanValue (true)); + Examples ======== @@ -142,6 +170,9 @@ ARED queue examples can be found at: ``src/traffic-control/examples/adaptive-red-tests.cc`` and ``src/traffic-control/examples/red-vs-ared.cc`` +Feng's Adaptive RED example can be found at: +``examples/traffic-control/red-vs-fengadaptive.cc`` + Validation ********** diff --git a/src/traffic-control/model/red-queue-disc.cc b/src/traffic-control/model/red-queue-disc.cc index 98efedc6349..fb1854c479b 100644 --- a/src/traffic-control/model/red-queue-disc.cc +++ b/src/traffic-control/model/red-queue-disc.cc @@ -114,6 +114,11 @@ TypeId RedQueueDisc::GetTypeId (void) BooleanValue (false), MakeBooleanAccessor (&RedQueueDisc::m_isAdaptMaxP), MakeBooleanChecker ()) + .AddAttribute ("FengAdaptive", + "True to enable Feng's Adaptive RED", + BooleanValue (false), + MakeBooleanAccessor (&RedQueueDisc::m_isFengAdaptive), + MakeBooleanChecker ()) .AddAttribute ("MinTh", "Minimum average length threshold in packets/bytes", DoubleValue (5), @@ -169,6 +174,16 @@ TypeId RedQueueDisc::GetTypeId (void) DoubleValue (0.9), MakeDoubleAccessor (&RedQueueDisc::SetAredBeta), MakeDoubleChecker (0, 1)) + .AddAttribute ("FengAlpha", + "Decrement parameter for m_curMaxP in Feng's Adaptive RED", + DoubleValue (3.0), + MakeDoubleAccessor (&RedQueueDisc::SetFengAdaptiveA), + MakeDoubleChecker ()) + .AddAttribute ("FengBeta", + "Increment parameter for m_curMaxP in Feng's Adaptive RED", + DoubleValue (2.0), + MakeDoubleAccessor (&RedQueueDisc::SetFengAdaptiveB), + MakeDoubleChecker ()) .AddAttribute ("LastSet", "Store the last time m_curMaxP was updated", TimeValue (Seconds (0.0)), @@ -281,6 +296,44 @@ RedQueueDisc::GetAredBeta (void) return m_beta; } +void +RedQueueDisc::SetFengAdaptiveA (double a) +{ + NS_LOG_FUNCTION (this << a); + m_a = a; + + if (m_a != 3) + { + NS_LOG_WARN ("Alpha value does not follow the recommendations!"); + } +} + +double +RedQueueDisc::GetFengAdaptiveA (void) +{ + NS_LOG_FUNCTION (this); + return m_a; +} + +void +RedQueueDisc::SetFengAdaptiveB (double b) +{ + NS_LOG_FUNCTION (this << b); + m_b = b; + + if (m_b != 2) + { + NS_LOG_WARN ("Beta value does not follow the recommendations!"); + } +} + +double +RedQueueDisc::GetFengAdaptiveB (void) +{ + NS_LOG_FUNCTION (this); + return m_b; +} + void RedQueueDisc::SetQueueLimit (uint32_t lim) { @@ -465,6 +518,12 @@ RedQueueDisc::InitializeParams (void) m_isAdaptMaxP = true; } + if (m_isFengAdaptive) + { + // Initialize m_fengStatus + m_fengStatus = Above; + } + if (m_minTh == 0 && m_maxTh == 0) { m_minTh = 5.0; @@ -568,6 +627,30 @@ RedQueueDisc::InitializeParams (void) << m_vC << "; m_vD " << m_vD); } +// Updating m_curMaxP, following the pseudocode +// from: A Self-Configuring RED Gateway, INFOCOMM '99. +// They recommend m_a = 3, and m_b = 2. +void +RedQueueDisc::UpdateMaxPFeng (double newAve) +{ + NS_LOG_FUNCTION (this << newAve); + + if (m_minTh < newAve && newAve < m_maxTh) + { + m_fengStatus = Between; + } + else if (newAve < m_minTh && m_fengStatus != Below) + { + m_fengStatus = Below; + m_curMaxP = m_curMaxP / m_a; + } + else if (newAve > m_maxTh && m_fengStatus != Above) + { + m_fengStatus = Above; + m_curMaxP = m_curMaxP * m_b; + } +} + // Update m_curMaxP to keep the average queue length within the target range. void RedQueueDisc::UpdateMaxP (double newAve) @@ -610,6 +693,10 @@ RedQueueDisc::Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW) { UpdateMaxP(newAve); } + else if (m_isFengAdaptive) + { + UpdateMaxPFeng (newAve); // Update MaxP in MIMD fashion. + } return newAve; } @@ -883,6 +970,11 @@ RedQueueDisc::CheckConfig (void) return false; } + if ((m_isARED || m_isAdaptMaxP) && m_isFengAdaptive) + { + NS_LOG_ERROR ("m_isAdaptMaxP and m_isFengAdaptive cannot be simultaneously true"); + } + return true; } diff --git a/src/traffic-control/model/red-queue-disc.h b/src/traffic-control/model/red-queue-disc.h index 398bbea5486..e147ad37435 100644 --- a/src/traffic-control/model/red-queue-disc.h +++ b/src/traffic-control/model/red-queue-disc.h @@ -98,6 +98,16 @@ class RedQueueDisc : public QueueDisc */ virtual ~RedQueueDisc (); + /** + * \brief Used in Feng's Adaptive RED + */ + enum FengStatus + { + Above, //!< When m_qAvg > m_maxTh + Between, //!< When m_maxTh < m_qAvg < m_minTh + Below, //!< When m_qAvg < m_minTh + }; + /** * \brief Stats */ @@ -179,6 +189,34 @@ class RedQueueDisc : public QueueDisc */ double GetAredBeta (void); + /** + * \brief Set the alpha value to adapt m_curMaxP in Feng's Adaptive RED. + * + * \param a The value of alpha to adapt m_curMaxP in Feng's Adaptive RED. + */ + void SetFengAdaptiveA (double a); + + /** + * \brief Get the alpha value to adapt m_curMaxP in Feng's Adaptive RED. + * + * \returns The alpha value to adapt m_curMaxP in Feng's Adaptive RED. + */ + double GetFengAdaptiveA (void); + + /** + * \brief Set the beta value to adapt m_curMaxP in Feng's Adaptive RED. + * + * \param b The value of beta to adapt m_curMaxP in Feng's Adaptive RED. + */ + void SetFengAdaptiveB (double b); + + /** + * \brief Get the beta value to adapt m_curMaxP in Feng's Adaptive RED. + * + * \returns The beta value to adapt m_curMaxP in Feng's Adaptive RED. + */ + double GetFengAdaptiveB (void); + /** * \brief Set the limit of the queue. * @@ -246,6 +284,11 @@ class RedQueueDisc : public QueueDisc * \param newAve new average queue length */ void UpdateMaxP (double newAve); + /** + * \brief Update m_curMaxP based on Feng's Adaptive RED + * \param newAve new average queue length + */ + void UpdateMaxPFeng (double newAve); /** * \brief Check if a packet needs to be dropped due to probability mark * \param item queue item @@ -302,6 +345,9 @@ class RedQueueDisc : public QueueDisc double m_alpha; //!< Increment parameter for m_curMaxP in ARED double m_beta; //!< Decrement parameter for m_curMaxP in ARED Time m_rtt; //!< Rtt to be considered while automatically setting m_bottom in ARED + bool m_isFengAdaptive; //!< True to enable Feng's Adaptive RED + double m_b; //!< Increment parameter for m_curMaxP in Feng's Adaptive RED + double m_a; //!< Decrement parameter for m_curMaxP in Feng's Adaptive RED bool m_isNs1Compat; //!< Ns-1 compatibility DataRate m_linkBandwidth; //!< Link bandwidth Time m_linkDelay; //!< Link delay @@ -323,6 +369,7 @@ class RedQueueDisc : public QueueDisc double m_ptc; //!< packet time constant in packets/second double m_qAvg; //!< Average queue length uint32_t m_count; //!< Number of packets since last random number generation + FengStatus m_fengStatus; //!< For use in Feng's Adaptive RED /** * 0 for default RED * 1 experimental (see red-queue-disc.cc) diff --git a/src/traffic-control/test/red-queue-disc-test-suite.cc b/src/traffic-control/test/red-queue-disc-test-suite.cc index 37f9f335da3..49bea1c79d7 100644 --- a/src/traffic-control/test/red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/red-queue-disc-test-suite.cc @@ -237,6 +237,8 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) uint32_t test5; uint32_t test6; uint32_t test7; + uint32_t test11; + uint32_t test12; } drop; @@ -421,6 +423,56 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) // Packets are ECN capable, RED queue disc is ECN enabled; there should be only unforced marks, no unforced drops NS_TEST_EXPECT_MSG_EQ (st.unforcedDrop, 0, "There should be no unforced drops"); NS_TEST_EXPECT_MSG_NE (st.unforcedMark, 0, "There should be some unforced marks"); + + + // test 11: Original RED with default parameter settings and fixed m_curMaxP + queue = CreateObject (); + minTh = 30 * modeSize; + maxTh = 90 * modeSize; + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mode", mode), true, + "Verify that we can actually set the attribute Mode"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MinTh", DoubleValue (minTh)), true, + "Verify that we can actually set the attribute MinTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxTh", DoubleValue (maxTh)), true, + "Verify that we can actually set the attribute MaxTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueLimit", UintegerValue (qSize)), true, + "Verify that we can actually set the attribute QueueLimit"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QW", DoubleValue (0.002)), true, + "Verify that we can actually set the attribute QW"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("LInterm", DoubleValue (2)), true, + "Verify that we can actually set the attribute LInterm"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Gentle", BooleanValue (true)), true, + "Verify that we can actually set the attribute Gentle"); + queue->Initialize (); + Enqueue (queue, pktSize, 300, false); + st = StaticCast (queue)->GetStats (); + drop.test11 = st.unforcedDrop; + NS_TEST_EXPECT_MSG_NE (drop.test11, 0, "There should some dropped packets due to probability mark"); + + + // test 12: Feng's Adaptive RED with default parameter settings and varying m_curMaxP + queue = CreateObject (); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mode", mode), true, + "Verify that we can actually set the attribute Mode"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MinTh", DoubleValue (minTh)), true, + "Verify that we can actually set the attribute MinTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxTh", DoubleValue (maxTh)), true, + "Verify that we can actually set the attribute MaxTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueLimit", UintegerValue (qSize)), true, + "Verify that we can actually set the attribute QueueLimit"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QW", DoubleValue (0.002)), true, + "Verify that we can actually set the attribute QW"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("LInterm", DoubleValue (2)), true, + "Verify that we can actually set the attribute LInterm"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Gentle", BooleanValue (true)), true, + "Verify that we can actually set the attribute Gentle"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("FengAdaptive", BooleanValue (true)), true, + "Verify that we can actually set the attribute FengAdaptive"); + queue->Initialize (); + Enqueue (queue, pktSize, 300, false); + st = StaticCast (queue)->GetStats (); + drop.test12 = st.unforcedDrop; + NS_TEST_EXPECT_MSG_LT (drop.test12, drop.test11, "Test 12 should have less drops due to probability mark than test 11"); } void From 4ff9a97d0c7044106ad56ba896b82b4a96c9bf81 Mon Sep 17 00:00:00 2001 From: Nichit Bodhak Goel Date: Sun, 28 May 2017 10:21:43 +0200 Subject: [PATCH 066/551] traffic-control: Add Nonlinear RED --- examples/traffic-control/red-vs-nlred.cc | 192 ++++++++++++++++++ examples/traffic-control/wscript | 3 + src/traffic-control/doc/red.rst | 26 +++ src/traffic-control/model/red-queue-disc.cc | 11 + src/traffic-control/model/red-queue-disc.h | 1 + .../test/red-queue-disc-test-suite.cc | 55 +++++ 6 files changed, 288 insertions(+) create mode 100644 examples/traffic-control/red-vs-nlred.cc diff --git a/examples/traffic-control/red-vs-nlred.cc b/examples/traffic-control/red-vs-nlred.cc new file mode 100644 index 00000000000..6cf3c122b36 --- /dev/null +++ b/examples/traffic-control/red-vs-nlred.cc @@ -0,0 +1,192 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2016 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Authors: Phani Kiran S V S + * Nichit Bodhak Goel + * Mohit P. Tahiliani + * + */ + +#include "ns3/core-module.h" +#include "ns3/network-module.h" +#include "ns3/internet-module.h" +#include "ns3/point-to-point-module.h" +#include "ns3/applications-module.h" +#include "ns3/point-to-point-layout-module.h" +#include "ns3/traffic-control-module.h" + +#include +#include +#include + +using namespace ns3; + +int main (int argc, char *argv[]) +{ + uint32_t nLeaf = 10; + uint32_t maxPackets = 100; + bool modeBytes = false; + uint32_t queueDiscLimitPackets = 1000; + double minTh = 5; + double maxTh = 15; + uint32_t pktSize = 512; + std::string appDataRate = "10Mbps"; + std::string queueDiscType = "RED"; + uint16_t port = 5001; + std::string bottleNeckLinkBw = "1Mbps"; + std::string bottleNeckLinkDelay = "50ms"; + + CommandLine cmd; + cmd.AddValue ("nLeaf", "Number of left and right side leaf nodes", nLeaf); + cmd.AddValue ("maxPackets","Max Packets allowed in the device queue", maxPackets); + cmd.AddValue ("queueDiscLimitPackets","Max Packets allowed in the queue disc", queueDiscLimitPackets); + cmd.AddValue ("queueDiscType", "Set Queue disc type to RED or NLRED", queueDiscType); + cmd.AddValue ("appPktSize", "Set OnOff App Packet Size", pktSize); + cmd.AddValue ("appDataRate", "Set OnOff App DataRate", appDataRate); + cmd.AddValue ("modeBytes", "Set Queue disc mode to Packets or bytes ", modeBytes); + + cmd.AddValue ("redMinTh", "RED queue minimum threshold", minTh); + cmd.AddValue ("redMaxTh", "RED queue maximum threshold", maxTh); + cmd.Parse (argc,argv); + + if ((queueDiscType != "RED") && (queueDiscType != "NLRED")) + { + std::cout << "Invalid queue disc type: Use --queueDiscType=RED or --queueDiscType=NLRED" << std::endl; + exit (1); + } + + Config::SetDefault ("ns3::OnOffApplication::PacketSize", UintegerValue (pktSize)); + Config::SetDefault ("ns3::OnOffApplication::DataRate", StringValue (appDataRate)); + + Config::SetDefault ("ns3::QueueBase::Mode", StringValue ("QUEUE_MODE_PACKETS")); + Config::SetDefault ("ns3::QueueBase::MaxPackets", UintegerValue (maxPackets)); + + if (!modeBytes) + { + Config::SetDefault ("ns3::RedQueueDisc::Mode", StringValue ("QUEUE_DISC_MODE_PACKETS")); + Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (queueDiscLimitPackets)); + } + else + { + Config::SetDefault ("ns3::RedQueueDisc::Mode", StringValue ("QUEUE_DISC_MODE_BYTES")); + Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (queueDiscLimitPackets * pktSize)); + minTh *= pktSize; + maxTh *= pktSize; + } + + Config::SetDefault ("ns3::RedQueueDisc::MinTh", DoubleValue (minTh)); + Config::SetDefault ("ns3::RedQueueDisc::MaxTh", DoubleValue (maxTh)); + Config::SetDefault ("ns3::RedQueueDisc::LinkBandwidth", StringValue (bottleNeckLinkBw)); + Config::SetDefault ("ns3::RedQueueDisc::LinkDelay", StringValue (bottleNeckLinkDelay)); + Config::SetDefault ("ns3::RedQueueDisc::MeanPktSize", UintegerValue (pktSize)); + + if (queueDiscType == "NLRED") + { + // Turn on NLRED + Config::SetDefault ("ns3::RedQueueDisc::NLRED", BooleanValue (true)); + } + + // Create the point-to-point link helpers + PointToPointHelper bottleNeckLink; + bottleNeckLink.SetDeviceAttribute ("DataRate", StringValue (bottleNeckLinkBw)); + bottleNeckLink.SetChannelAttribute ("Delay", StringValue (bottleNeckLinkDelay)); + + PointToPointHelper pointToPointLeaf; + pointToPointLeaf.SetDeviceAttribute ("DataRate", StringValue ("10Mbps")); + pointToPointLeaf.SetChannelAttribute ("Delay", StringValue ("1ms")); + + PointToPointDumbbellHelper d (nLeaf, pointToPointLeaf, + nLeaf, pointToPointLeaf, + bottleNeckLink); + + // Install Stack + InternetStackHelper stack; + for (uint32_t i = 0; i < d.LeftCount (); ++i) + { + stack.Install (d.GetLeft (i)); + } + for (uint32_t i = 0; i < d.RightCount (); ++i) + { + stack.Install (d.GetRight (i)); + } + + stack.Install (d.GetLeft ()); + stack.Install (d.GetRight ()); + TrafficControlHelper tchBottleneck; + QueueDiscContainer queueDiscs; + tchBottleneck.SetRootQueueDisc ("ns3::RedQueueDisc"); + tchBottleneck.Install (d.GetLeft ()->GetDevice (0)); + queueDiscs = tchBottleneck.Install (d.GetRight ()->GetDevice (0)); + + // Assign IP Addresses + d.AssignIpv4Addresses (Ipv4AddressHelper ("10.1.1.0", "255.255.255.0"), + Ipv4AddressHelper ("10.2.1.0", "255.255.255.0"), + Ipv4AddressHelper ("10.3.1.0", "255.255.255.0")); + + // Install on/off app on all right side nodes + OnOffHelper clientHelper ("ns3::TcpSocketFactory", Address ()); + clientHelper.SetAttribute ("OnTime", StringValue ("ns3::UniformRandomVariable[Min=0.|Max=1.]")); + clientHelper.SetAttribute ("OffTime", StringValue ("ns3::UniformRandomVariable[Min=0.|Max=1.]")); + Address sinkLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port)); + PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", sinkLocalAddress); + ApplicationContainer sinkApps; + for (uint32_t i = 0; i < d.LeftCount (); ++i) + { + sinkApps.Add (packetSinkHelper.Install (d.GetLeft (i))); + } + sinkApps.Start (Seconds (0.0)); + sinkApps.Stop (Seconds (30.0)); + + ApplicationContainer clientApps; + for (uint32_t i = 0; i < d.RightCount (); ++i) + { + // Create an on/off app sending packets to the left side + AddressValue remoteAddress (InetSocketAddress (d.GetLeftIpv4Address (i), port)); + clientHelper.SetAttribute ("Remote", remoteAddress); + clientApps.Add (clientHelper.Install (d.GetRight (i))); + } + clientApps.Start (Seconds (1.0)); // Start 1 second after sink + clientApps.Stop (Seconds (15.0)); // Stop before the sink + + Ipv4GlobalRoutingHelper::PopulateRoutingTables (); + + std::cout << "Running the simulation" << std::endl; + Simulator::Run (); + + RedQueueDisc::Stats st = StaticCast (queueDiscs.Get (0))->GetStats (); + + if (st.unforcedDrop == 0) + { + std::cout << "There should be some unforced drops" << std::endl; + exit (1); + } + + if (st.qLimDrop != 0) + { + std::cout << "There should be zero drops due to queue full" << std::endl; + exit (1); + } + + std::cout << "*** Stats from the bottleneck queue disc ***" << std::endl; + std::cout << "\t " << st.unforcedDrop << " drops due to prob mark" << std::endl; + std::cout << "\t " << st.forcedDrop << " drops due to hard mark" << std::endl; + std::cout << "\t " << st.qLimDrop << " drops due to queue full" << std::endl; + std::cout << "Destroying the simulation" << std::endl; + + Simulator::Destroy (); + return 0; +} diff --git a/examples/traffic-control/wscript b/examples/traffic-control/wscript index 1204d8b63dc..a05df8b21fd 100644 --- a/examples/traffic-control/wscript +++ b/examples/traffic-control/wscript @@ -11,3 +11,6 @@ def build(bld): obj = bld.create_ns3_program('red-vs-fengadaptive', ['point-to-point', 'point-to-point-layout', 'internet', 'applications', 'traffic-control']) obj.source = 'red-vs-fengadaptive.cc' + + obj = bld.create_ns3_program('red-vs-nlred', ['point-to-point', 'point-to-point-layout', 'internet', 'applications', 'traffic-control']) + obj.source = 'red-vs-nlred.cc' diff --git a/src/traffic-control/doc/red.rst b/src/traffic-control/doc/red.rst index cd335946740..d066c937d49 100644 --- a/src/traffic-control/doc/red.rst +++ b/src/traffic-control/doc/red.rst @@ -41,6 +41,12 @@ Feng's Adaptive RED is a variant of RED that adapts the maximum drop probability. The model in ns-3 contains implementation of this feature, and is a port of ns-2 Feng's Adaptive RED model. +Nonlinear Random Early Detection (NLRED) +======================================== +NLRED is a variant of RED in which the linear packet dropping function of +RED is replaced by a nonlinear quadratic function. This approach makes packet +dropping gentler for light traffic load and aggressive for heavy traffic load. + Explicit Congestion Notification (ECN) ====================================== This RED model supports an ECN mode of operation to notify endpoints of @@ -73,6 +79,9 @@ Feng's Adaptive RED queue implementation is based on the algorithm provided in: W. C. Feng et al, http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=752150 +NLRED queue implementation is based on the algorithm provided in: +Kaiyu Zhou et al, http://www.sciencedirect.com/science/article/pii/S1389128606000879 + The addition of explicit congestion notification (ECN) to IP: K. K. Ramakrishnan et al, https://tools.ietf.org/html/rfc3168 @@ -117,6 +126,10 @@ attributes: * FengAlpha (increment parameter for m_curMaxP, Default: 3) * FengBeta (decrement parameter for m_curMaxP, Default: 2) +The following attribute should be turned on to simulate NLRED queue disc: + +* NLRED (Boolean attribute. Default: false) + Consult the ns-3 documentation for explanation of these attributes. Simulating ARED @@ -161,6 +174,16 @@ set to true, as done in ``examples/traffic-control/red-vs-fengadaptive.cc``: Config::SetDefault ("ns3::RedQueueDisc::FengAdaptive", BooleanValue (true)); +Simulating NLRED +================ + +To switch on NLRED algorithm, the attribute NLRED must be set to true, +as shown below: + +.. sourcecode:: cpp + +Config::SetDefault ("ns3::RedQueueDisc::NLRED", BooleanValue (true)); + Examples ======== @@ -173,6 +196,9 @@ ARED queue examples can be found at: Feng's Adaptive RED example can be found at: ``examples/traffic-control/red-vs-fengadaptive.cc`` +NLRED queue example can be found at: +``examples/traffic-control/red-vs-nlred.cc`` + Validation ********** diff --git a/src/traffic-control/model/red-queue-disc.cc b/src/traffic-control/model/red-queue-disc.cc index fb1854c479b..1807c9fd9fb 100644 --- a/src/traffic-control/model/red-queue-disc.cc +++ b/src/traffic-control/model/red-queue-disc.cc @@ -119,6 +119,11 @@ TypeId RedQueueDisc::GetTypeId (void) BooleanValue (false), MakeBooleanAccessor (&RedQueueDisc::m_isFengAdaptive), MakeBooleanChecker ()) + .AddAttribute ("NLRED", + "True to enable Nonlinear RED", + BooleanValue (false), + MakeBooleanAccessor (&RedQueueDisc::m_isNonlinear), + MakeBooleanChecker ()) .AddAttribute ("MinTh", "Minimum average length threshold in packets/bytes", DoubleValue (5), @@ -792,6 +797,12 @@ RedQueueDisc::CalculatePNew (double qAvg, double maxTh, bool isGentle, double vA * th_min to th_max */ p = vA * qAvg + vB; + + if (m_isNonlinear) + { + p *= p * 1.5; + } + p *= maxP; } diff --git a/src/traffic-control/model/red-queue-disc.h b/src/traffic-control/model/red-queue-disc.h index e147ad37435..c6c213e71d2 100644 --- a/src/traffic-control/model/red-queue-disc.h +++ b/src/traffic-control/model/red-queue-disc.h @@ -346,6 +346,7 @@ class RedQueueDisc : public QueueDisc double m_beta; //!< Decrement parameter for m_curMaxP in ARED Time m_rtt; //!< Rtt to be considered while automatically setting m_bottom in ARED bool m_isFengAdaptive; //!< True to enable Feng's Adaptive RED + bool m_isNonlinear; //!< True to enable Nonlinear RED double m_b; //!< Increment parameter for m_curMaxP in Feng's Adaptive RED double m_a; //!< Decrement parameter for m_curMaxP in Feng's Adaptive RED bool m_isNs1Compat; //!< Ns-1 compatibility diff --git a/src/traffic-control/test/red-queue-disc-test-suite.cc b/src/traffic-control/test/red-queue-disc-test-suite.cc index 49bea1c79d7..d3ebd9b24b3 100644 --- a/src/traffic-control/test/red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/red-queue-disc-test-suite.cc @@ -239,6 +239,8 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) uint32_t test7; uint32_t test11; uint32_t test12; + uint32_t test13; + uint32_t test14; } drop; @@ -473,6 +475,59 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) st = StaticCast (queue)->GetStats (); drop.test12 = st.unforcedDrop; NS_TEST_EXPECT_MSG_LT (drop.test12, drop.test11, "Test 12 should have less drops due to probability mark than test 11"); + + + // test 11: RED with Linear drop probability + queue = CreateObject (); + minTh = 30 * modeSize; + maxTh = 90 * modeSize; + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mode", mode), true, + "Verify that we can actually set the attribute Mode"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MinTh", DoubleValue (minTh)), true, + "Verify that we can actually set the attribute MinTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxTh", DoubleValue (maxTh)), true, + "Verify that we can actually set the attribute MaxTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueLimit", UintegerValue (qSize)), true, + "Verify that we can actually set the attribute QueueLimit"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QW", DoubleValue (0.002)), true, + "Verify that we can actually set the attribute QW"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("LInterm", DoubleValue (2)), true, + "Verify that we can actually set the attribute LInterm"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Gentle", BooleanValue (true)), true, + "Verify that we can actually set the attribute Gentle"); + queue->Initialize (); + Enqueue (queue, pktSize, 300, false); + st = StaticCast (queue)->GetStats (); + drop.test13 = st.unforcedDrop; + NS_TEST_EXPECT_MSG_NE (drop.test13, 0, "There should some dropped packets due to probability mark"); + + + // test 14: RED with Nonlinear drop probability + queue = CreateObject (); + minTh = 30 * modeSize; + maxTh = 90 * modeSize; + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mode", mode), true, + "Verify that we can actually set the attribute Mode"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MinTh", DoubleValue (minTh)), true, + "Verify that we can actually set the attribute MinTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxTh", DoubleValue (maxTh)), true, + "Verify that we can actually set the attribute MaxTh"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueLimit", UintegerValue (qSize)), true, + "Verify that we can actually set the attribute QueueLimit"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QW", DoubleValue (0.002)), true, + "Verify that we can actually set the attribute QW"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("LInterm", DoubleValue (2)), true, + "Verify that we can actually set the attribute LInterm"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Gentle", BooleanValue (true)), true, + "Verify that we can actually set the attribute Gentle"); + NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("NLRED", BooleanValue (true)), true, + "Verify that we can actually set the attribute NLRED"); + queue->Initialize (); + Enqueue (queue, pktSize, 300, false); + st = StaticCast (queue)->GetStats (); + drop.test14 = st.unforcedDrop; + NS_TEST_EXPECT_MSG_LT (drop.test14, drop.test13, "Test 14 should have less drops due to probability mark than test 13"); + } void From 83518b6444525f8926a03d362628fba61b52df27 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Sun, 28 May 2017 10:21:48 +0200 Subject: [PATCH 067/551] traffic-control: Cleanup of some RED private methods --- src/traffic-control/model/red-queue-disc.cc | 35 ++++++++++----------- src/traffic-control/model/red-queue-disc.h | 19 ++--------- 2 files changed, 19 insertions(+), 35 deletions(-) diff --git a/src/traffic-control/model/red-queue-disc.cc b/src/traffic-control/model/red-queue-disc.cc index 1807c9fd9fb..6015eb427d1 100644 --- a/src/traffic-control/model/red-queue-disc.cc +++ b/src/traffic-control/model/red-queue-disc.cc @@ -696,7 +696,7 @@ RedQueueDisc::Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW) Time now = Simulator::Now (); if (m_isAdaptMaxP && now > m_lastSet + m_interval) { - UpdateMaxP(newAve); + UpdateMaxP (newAve); } else if (m_isFengAdaptive) { @@ -711,8 +711,9 @@ uint32_t RedQueueDisc::DropEarly (Ptr item, uint32_t qSize) { NS_LOG_FUNCTION (this << item << qSize); - m_vProb1 = CalculatePNew (m_qAvg, m_maxTh, m_isGentle, m_vA, m_vB, m_vC, m_vD, m_curMaxP); - m_vProb = ModifyP (m_vProb1, m_count, m_countBytes, m_meanPktSize, m_isWait, item->GetSize ()); + + double prob1 = CalculatePNew (); + m_vProb = ModifyP (prob1, item->GetSize ()); // Drop probability is computed, pick random number and act if (m_cautious == 1) @@ -769,19 +770,18 @@ RedQueueDisc::DropEarly (Ptr item, uint32_t qSize) // Returns a probability using these function parameters for the DropEarly funtion double -RedQueueDisc::CalculatePNew (double qAvg, double maxTh, bool isGentle, double vA, - double vB, double vC, double vD, double maxP) +RedQueueDisc::CalculatePNew (void) { - NS_LOG_FUNCTION (this << qAvg << maxTh << isGentle << vA << vB << vC << vD << maxP); + NS_LOG_FUNCTION (this); double p; - if (isGentle && qAvg >= maxTh) + if (m_isGentle && m_qAvg >= m_maxTh) { // p ranges from maxP to 1 as the average queue // Size ranges from maxTh to twice maxTh - p = vC * qAvg + vD; + p = m_vC * m_qAvg + m_vD; } - else if (!isGentle && qAvg >= maxTh) + else if (!m_isGentle && m_qAvg >= m_maxTh) { /* * OLD: p continues to range linearly above max_p as @@ -796,14 +796,14 @@ RedQueueDisc::CalculatePNew (double qAvg, double maxTh, bool isGentle, double vA * p ranges from 0 to max_p as the average queue size ranges from * th_min to th_max */ - p = vA * qAvg + vB; + p = m_vA * m_qAvg + m_vB; if (m_isNonlinear) { p *= p * 1.5; } - p *= maxP; + p *= m_curMaxP; } if (p > 1.0) @@ -816,18 +816,17 @@ RedQueueDisc::CalculatePNew (double qAvg, double maxTh, bool isGentle, double vA // Returns a probability using these function parameters for the DropEarly funtion double -RedQueueDisc::ModifyP (double p, uint32_t count, uint32_t countBytes, - uint32_t meanPktSize, bool isWait, uint32_t size) +RedQueueDisc::ModifyP (double p, uint32_t size) { - NS_LOG_FUNCTION (this << p << count << countBytes << meanPktSize << isWait << size); - double count1 = (double) count; + NS_LOG_FUNCTION (this << p << size); + double count1 = (double) m_count; if (GetMode () == QUEUE_DISC_MODE_BYTES) { - count1 = (double) (countBytes / meanPktSize); + count1 = (double) (m_countBytes / m_meanPktSize); } - if (isWait) + if (m_isWait) { if (count1 * p < 1.0) { @@ -856,7 +855,7 @@ RedQueueDisc::ModifyP (double p, uint32_t count, uint32_t countBytes, if ((GetMode () == QUEUE_DISC_MODE_BYTES) && (p < 1.0)) { - p = (p * size) / meanPktSize; + p = (p * size) / m_meanPktSize; } if (p > 1.0) diff --git a/src/traffic-control/model/red-queue-disc.h b/src/traffic-control/model/red-queue-disc.h index c6c213e71d2..847d68259e8 100644 --- a/src/traffic-control/model/red-queue-disc.h +++ b/src/traffic-control/model/red-queue-disc.h @@ -298,30 +298,16 @@ class RedQueueDisc : public QueueDisc uint32_t DropEarly (Ptr item, uint32_t qSize); /** * \brief Returns a probability using these function parameters for the DropEarly function - * \param qAvg Average queue length - * \param maxTh Max avg length threshold - * \param gentle "gentle" algorithm - * \param vA vA - * \param vB vB - * \param vC vC - * \param vD vD - * \param maxP max_p * \returns Prob. of packet drop before "count" */ - double CalculatePNew (double qAvg, double , bool gentle, double vA, - double vB, double vC, double vD, double maxP); + double CalculatePNew (void); /** * \brief Returns a probability using these function parameters for the DropEarly function * \param p Prob. of packet drop before "count" - * \param count number of packets since last random number generation - * \param countBytes number of bytes since last drop - * \param meanPktSize Avg pkt size - * \param wait True for waiting between dropped packets * \param size packet size * \returns Prob. of packet drop */ - double ModifyP (double p, uint32_t count, uint32_t countBytes, - uint32_t meanPktSize, bool wait, uint32_t size); + double ModifyP (double p, uint32_t size); Stats m_stats; //!< RED statistics @@ -356,7 +342,6 @@ class RedQueueDisc : public QueueDisc bool m_useHardDrop; //!< True if packets are always dropped above max threshold // ** Variables maintained by RED - double m_vProb1; //!< Prob. of packet drop before "count" double m_vA; //!< 1.0 / (m_maxTh - m_minTh) double m_vB; //!< -m_minTh / (m_maxTh - m_minTh) double m_vC; //!< (1.0 - m_curMaxP) / m_maxTh - used in "gentle" mode From ee496a5f4beff67e82d8554c3bed37f80fce576f Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Sun, 28 May 2017 10:21:54 +0200 Subject: [PATCH 068/551] traffic-control: Rescan python bindings --- .../bindings/modulegen__gcc_ILP32.py | 61 +++++++++++++++++++ .../bindings/modulegen__gcc_LP64.py | 61 +++++++++++++++++++ 2 files changed, 122 insertions(+) diff --git a/src/traffic-control/bindings/modulegen__gcc_ILP32.py b/src/traffic-control/bindings/modulegen__gcc_ILP32.py index 63879f67200..d98fbdc4183 100644 --- a/src/traffic-control/bindings/modulegen__gcc_ILP32.py +++ b/src/traffic-control/bindings/modulegen__gcc_ILP32.py @@ -184,6 +184,8 @@ def register_types(module): module.add_class('RandomVariableStream', import_from_module='ns.core', parent=root_module['ns3::Object']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc [class] module.add_class('RedQueueDisc', parent=root_module['ns3::QueueDisc']) + ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::FengStatus [enumeration] + module.add_enum('FengStatus', ['Above', 'Between', 'Below'], outer_class=root_module['ns3::RedQueueDisc']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc [enumeration] module.add_enum('', ['DTYPE_NONE', 'DTYPE_FORCED', 'DTYPE_UNFORCED'], outer_class=root_module['ns3::RedQueueDisc']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::QueueDiscMode [enumeration] @@ -318,6 +320,8 @@ def register_types(module): module.add_class('Mac48AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue [class] module.add_class('Mac48AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## mq-queue-disc.h (module 'traffic-control'): ns3::MqQueueDisc [class] + module.add_class('MqQueueDisc', parent=root_module['ns3::QueueDisc']) ## net-device.h (module 'network'): ns3::NetDevice [class] module.add_class('NetDevice', import_from_module='ns.network', parent=root_module['ns3::Object']) ## net-device.h (module 'network'): ns3::NetDevice::PacketType [enumeration] @@ -591,6 +595,7 @@ def register_methods(root_module): register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable']) register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker']) register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) + register_Ns3MqQueueDisc_methods(root_module, root_module['ns3::MqQueueDisc']) register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector']) register_Ns3Node_methods(root_module, root_module['ns3::Node']) @@ -3292,6 +3297,14 @@ def register_Ns3RedQueueDisc_methods(root_module, cls): cls.add_method('GetAredBeta', 'double', []) + ## red-queue-disc.h (module 'traffic-control'): double ns3::RedQueueDisc::GetFengAdaptiveA() [member function] + cls.add_method('GetFengAdaptiveA', + 'double', + []) + ## red-queue-disc.h (module 'traffic-control'): double ns3::RedQueueDisc::GetFengAdaptiveB() [member function] + cls.add_method('GetFengAdaptiveB', + 'double', + []) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::QueueDiscMode ns3::RedQueueDisc::GetMode() [member function] cls.add_method('GetMode', 'ns3::RedQueueDisc::QueueDiscMode', @@ -3317,6 +3330,14 @@ def register_Ns3RedQueueDisc_methods(root_module, cls): cls.add_method('SetAredBeta', 'void', [param('double', 'beta')]) + ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetFengAdaptiveA(double a) [member function] + cls.add_method('SetFengAdaptiveA', + 'void', + [param('double', 'a')]) + ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetFengAdaptiveB(double b) [member function] + cls.add_method('SetFengAdaptiveB', + 'void', + [param('double', 'b')]) ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetMode(ns3::RedQueueDisc::QueueDiscMode mode) [member function] cls.add_method('SetMode', 'void', @@ -5164,6 +5185,46 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): [param('ns3::Mac48Address const &', 'value')]) return +def register_Ns3MqQueueDisc_methods(root_module, cls): + ## mq-queue-disc.h (module 'traffic-control'): static ns3::TypeId ns3::MqQueueDisc::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::MqQueueDisc::MqQueueDisc() [constructor] + cls.add_constructor([]) + ## mq-queue-disc.h (module 'traffic-control'): ns3::QueueDisc::WakeMode ns3::MqQueueDisc::GetWakeMode() const [member function] + cls.add_method('GetWakeMode', + 'ns3::QueueDisc::WakeMode', + [], + is_const=True, is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): bool ns3::MqQueueDisc::DoEnqueue(ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::Ptr ns3::MqQueueDisc::DoDequeue() [member function] + cls.add_method('DoDequeue', + 'ns3::Ptr< ns3::QueueDiscItem >', + [], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::Ptr ns3::MqQueueDisc::DoPeek() const [member function] + cls.add_method('DoPeek', + 'ns3::Ptr< ns3::QueueDiscItem const >', + [], + is_const=True, visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): bool ns3::MqQueueDisc::CheckConfig() [member function] + cls.add_method('CheckConfig', + 'bool', + [], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): void ns3::MqQueueDisc::InitializeParams() [member function] + cls.add_method('InitializeParams', + 'void', + [], + visibility='private', is_virtual=True) + return + def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) diff --git a/src/traffic-control/bindings/modulegen__gcc_LP64.py b/src/traffic-control/bindings/modulegen__gcc_LP64.py index 63879f67200..d98fbdc4183 100644 --- a/src/traffic-control/bindings/modulegen__gcc_LP64.py +++ b/src/traffic-control/bindings/modulegen__gcc_LP64.py @@ -184,6 +184,8 @@ def register_types(module): module.add_class('RandomVariableStream', import_from_module='ns.core', parent=root_module['ns3::Object']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc [class] module.add_class('RedQueueDisc', parent=root_module['ns3::QueueDisc']) + ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::FengStatus [enumeration] + module.add_enum('FengStatus', ['Above', 'Between', 'Below'], outer_class=root_module['ns3::RedQueueDisc']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc [enumeration] module.add_enum('', ['DTYPE_NONE', 'DTYPE_FORCED', 'DTYPE_UNFORCED'], outer_class=root_module['ns3::RedQueueDisc']) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::QueueDiscMode [enumeration] @@ -318,6 +320,8 @@ def register_types(module): module.add_class('Mac48AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue [class] module.add_class('Mac48AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## mq-queue-disc.h (module 'traffic-control'): ns3::MqQueueDisc [class] + module.add_class('MqQueueDisc', parent=root_module['ns3::QueueDisc']) ## net-device.h (module 'network'): ns3::NetDevice [class] module.add_class('NetDevice', import_from_module='ns.network', parent=root_module['ns3::Object']) ## net-device.h (module 'network'): ns3::NetDevice::PacketType [enumeration] @@ -591,6 +595,7 @@ def register_methods(root_module): register_Ns3LogNormalRandomVariable_methods(root_module, root_module['ns3::LogNormalRandomVariable']) register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker']) register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) + register_Ns3MqQueueDisc_methods(root_module, root_module['ns3::MqQueueDisc']) register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector']) register_Ns3Node_methods(root_module, root_module['ns3::Node']) @@ -3292,6 +3297,14 @@ def register_Ns3RedQueueDisc_methods(root_module, cls): cls.add_method('GetAredBeta', 'double', []) + ## red-queue-disc.h (module 'traffic-control'): double ns3::RedQueueDisc::GetFengAdaptiveA() [member function] + cls.add_method('GetFengAdaptiveA', + 'double', + []) + ## red-queue-disc.h (module 'traffic-control'): double ns3::RedQueueDisc::GetFengAdaptiveB() [member function] + cls.add_method('GetFengAdaptiveB', + 'double', + []) ## red-queue-disc.h (module 'traffic-control'): ns3::RedQueueDisc::QueueDiscMode ns3::RedQueueDisc::GetMode() [member function] cls.add_method('GetMode', 'ns3::RedQueueDisc::QueueDiscMode', @@ -3317,6 +3330,14 @@ def register_Ns3RedQueueDisc_methods(root_module, cls): cls.add_method('SetAredBeta', 'void', [param('double', 'beta')]) + ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetFengAdaptiveA(double a) [member function] + cls.add_method('SetFengAdaptiveA', + 'void', + [param('double', 'a')]) + ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetFengAdaptiveB(double b) [member function] + cls.add_method('SetFengAdaptiveB', + 'void', + [param('double', 'b')]) ## red-queue-disc.h (module 'traffic-control'): void ns3::RedQueueDisc::SetMode(ns3::RedQueueDisc::QueueDiscMode mode) [member function] cls.add_method('SetMode', 'void', @@ -5164,6 +5185,46 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): [param('ns3::Mac48Address const &', 'value')]) return +def register_Ns3MqQueueDisc_methods(root_module, cls): + ## mq-queue-disc.h (module 'traffic-control'): static ns3::TypeId ns3::MqQueueDisc::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::MqQueueDisc::MqQueueDisc() [constructor] + cls.add_constructor([]) + ## mq-queue-disc.h (module 'traffic-control'): ns3::QueueDisc::WakeMode ns3::MqQueueDisc::GetWakeMode() const [member function] + cls.add_method('GetWakeMode', + 'ns3::QueueDisc::WakeMode', + [], + is_const=True, is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): bool ns3::MqQueueDisc::DoEnqueue(ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::Ptr ns3::MqQueueDisc::DoDequeue() [member function] + cls.add_method('DoDequeue', + 'ns3::Ptr< ns3::QueueDiscItem >', + [], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): ns3::Ptr ns3::MqQueueDisc::DoPeek() const [member function] + cls.add_method('DoPeek', + 'ns3::Ptr< ns3::QueueDiscItem const >', + [], + is_const=True, visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): bool ns3::MqQueueDisc::CheckConfig() [member function] + cls.add_method('CheckConfig', + 'bool', + [], + visibility='private', is_virtual=True) + ## mq-queue-disc.h (module 'traffic-control'): void ns3::MqQueueDisc::InitializeParams() [member function] + cls.add_method('InitializeParams', + 'void', + [], + visibility='private', is_virtual=True) + return + def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) From 6e8891669b8836ae7268447db727a826e0d6c6c1 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 28 May 2017 19:37:55 +0200 Subject: [PATCH 069/551] traffic-control: Improve documentation --- src/traffic-control/doc/queue-discs.rst | 26 ++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/src/traffic-control/doc/queue-discs.rst b/src/traffic-control/doc/queue-discs.rst index 8bb30c37049..bc1d84279b8 100644 --- a/src/traffic-control/doc/queue-discs.rst +++ b/src/traffic-control/doc/queue-discs.rst @@ -11,18 +11,26 @@ Model Description ***************** Packets received by the Traffic Control layer for transmission to a netdevice -can be passed to a Queue Discipline to perform scheduling and policing. +can be passed to a queueing discipline (queue disc) to perform scheduling and +policing. The |ns3| term "queue disc" corresponds to what Linux calls a "qdisc". A netdevice can have a single (root) queue disc installed on it. Installing a queue disc on a netdevice is not mandatory. If a netdevice does not have a queue disc installed on it, the traffic control layer sends the packets directly to the netdevice. This is the case, for instance, of the loopback netdevice. -As in Linux, a queue disc may contain distinct elements: +As in Linux, queue discs may be simple queues or may be complicated hierarchical +structures. A queue disc may contain distinct elements: * queues, which actually store the packets waiting for transmission -* classes, which allow to reserve a different treatment to different packets +* classes, which permit the definition of different treatments for different subdivisions of traffic * filters, which determine the queue or class which a packet is destined to +Linux uses the terminology "classful qdiscs" or "classless qdiscs" to describe +how packets are handled. This use of the term "class" should be distinguished +from the C++ language "class". In general, the below discussion uses "class" +in the Linux, not C++, sense, but there are some uses of the C++ term, so +please keep in mind the dual use of this term in the below text. + Notice that a child queue disc must be attached to every class and a packet filter is only able to classify packets of a single protocol. Also, while in Linux some queue discs (e.g., fq-codel) use an internal classifier and do not make use of @@ -50,7 +58,7 @@ is equivalent to make it run. Design ========== -An abstract base class, class QueueDisc, is subclassed to implement a specific +A C++ abstract base class, class QueueDisc, is subclassed to implement a specific queue disc. A subclass is required to implement the following methods: * ``bool DoEnqueue (Ptr item)``: Enqueue a packet @@ -59,7 +67,7 @@ queue disc. A subclass is required to implement the following methods: * ``bool CheckConfig (void) const``: Check if the configuration is correct * ``void InitializeParams (void)``: Initialize queue disc parameters -The base class QueueDisc implements: +The C++ base class QueueDisc implements: * methods to add/get a single queue, class or filter and methods to get the number \ of installed queues, classes or filters @@ -77,14 +85,14 @@ The base class QueueDisc provides many trace sources: * ``PacketsInQueue`` * ``BytesInQueue`` -The base class QueueDisc holds the list of attached queues, classes and filter +The C++ base class QueueDisc holds the list of attached queues, classes and filter by means of three vectors accessible through attributes (InternalQueueList, QueueDiscClassList and PacketFilterList). Internal queues are implemented as (subclasses of) Queue objects. A Queue stores QueueItem objects, which consist of just a Ptr. Since a queue disc has to store at least the destination address and the protocol number for each enqueued -packet, a new class, QueueDiscItem, is derived from QueueItem to store such +packet, a new C++ class, QueueDiscItem, is derived from QueueItem to store such additional information for each packet. Thus, internal queues are implemented as Queue objects storing QueueDiscItem objects. Also, there could be the need to store further information depending on the network layer protocol of the packet. For @@ -95,7 +103,7 @@ subclasses ``Ipv4QueueDiscItem`` and ``Ipv6QueueDiscItem`` are derived from ``QueueDiscItem`` to additionally store the IP header and provide protocol specific operations such as ECN marking. -Classes are implemented via the QueueDiscClass class, which just consists of a pointer +Classes (in the Linux sense of the term) are implemented via the QueueDiscClass class, which consists of a pointer to the attached queue disc. Such a pointer is accessible through the QueueDisc attribute. Classful queue discs needing to set parameters for their classes can subclass QueueDiscClass and add the required parameters as attributes. @@ -127,7 +135,7 @@ installed on the node. To install a queue disc other than the default one, it is necessary to install such queue disc before an IP address is assigned to the device. Alternatively, the default queue disc can be removed from the device after assigning an IP address, by using the convenient -Uninstall method of the TrafficControlHelper class, and then installing a different +Uninstall method of the TrafficControlHelper C++ class, and then installing a different queue disc on the device. Clearly, it is also possible to have no queue disc installed on a device. Helpers From be47e2d5b5b832019a57d7a99746140375fbfa8a Mon Sep 17 00:00:00 2001 From: "Mohit P. Tahiliani" Date: Sun, 28 May 2017 19:59:52 +0200 Subject: [PATCH 070/551] traffic-control: Improve comments in RED --- src/traffic-control/model/red-queue-disc.cc | 20 ++++++++++---------- src/traffic-control/model/red-queue-disc.h | 10 +++++----- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/traffic-control/model/red-queue-disc.cc b/src/traffic-control/model/red-queue-disc.cc index 6015eb427d1..742df887f34 100644 --- a/src/traffic-control/model/red-queue-disc.cc +++ b/src/traffic-control/model/red-queue-disc.cc @@ -430,9 +430,9 @@ RedQueueDisc::DoEnqueue (Ptr item) { /* * The average queue size has just crossed the - * threshold from below to above "minthresh", or - * from above "minthresh" with an empty queue to - * above "minthresh" with a nonempty queue. + * threshold from below to above m_minTh, or + * from above m_minTh with an empty queue to + * above m_minTh with a nonempty queue. */ m_count = 1; m_countBytes = item->GetSize (); @@ -700,7 +700,7 @@ RedQueueDisc::Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW) } else if (m_isFengAdaptive) { - UpdateMaxPFeng (newAve); // Update MaxP in MIMD fashion. + UpdateMaxPFeng (newAve); // Update m_curMaxP in MIMD fashion. } return newAve; @@ -777,15 +777,15 @@ RedQueueDisc::CalculatePNew (void) if (m_isGentle && m_qAvg >= m_maxTh) { - // p ranges from maxP to 1 as the average queue - // Size ranges from maxTh to twice maxTh + // p ranges from m_curMaxP to 1 as the average queue + // size ranges from m_maxTh to twice m_maxTh p = m_vC * m_qAvg + m_vD; } else if (!m_isGentle && m_qAvg >= m_maxTh) { /* - * OLD: p continues to range linearly above max_p as - * the average queue size ranges above th_max. + * OLD: p continues to range linearly above m_curMaxP as + * the average queue size ranges above m_maxTh. * NEW: p is set to 1.0 */ p = 1.0; @@ -793,8 +793,8 @@ RedQueueDisc::CalculatePNew (void) else { /* - * p ranges from 0 to max_p as the average queue size ranges from - * th_min to th_max + * p ranges from 0 to m_curMaxP as the average queue size ranges from + * m_minTh to m_maxTh */ p = m_vA * m_qAvg + m_vB; diff --git a/src/traffic-control/model/red-queue-disc.h b/src/traffic-control/model/red-queue-disc.h index 847d68259e8..26ecd623536 100644 --- a/src/traffic-control/model/red-queue-disc.h +++ b/src/traffic-control/model/red-queue-disc.h @@ -114,10 +114,10 @@ class RedQueueDisc : public QueueDisc typedef struct { uint32_t unforcedDrop; //!< Early probability drops - uint32_t forcedDrop; //!< Forced drops, qavg > max threshold + uint32_t forcedDrop; //!< Forced drops, m_qAvg > m_maxTh uint32_t qLimDrop; //!< Drops due to queue limits uint32_t unforcedMark; //!< Early probability marks - uint32_t forcedMark; //!< Forced marks, qavg > max threshold + uint32_t forcedMark; //!< Forced marks, m_qAvg > m_maxTh } Stats; /** @@ -316,11 +316,11 @@ class RedQueueDisc : public QueueDisc uint32_t m_meanPktSize; //!< Avg pkt size uint32_t m_idlePktSize; //!< Avg pkt size used during idle times bool m_isWait; //!< True for waiting between dropped packets - bool m_isGentle; //!< True to increases dropping prob. slowly when ave queue exceeds maxthresh + bool m_isGentle; //!< True to increase dropping prob. slowly when m_qAvg exceeds m_maxTh bool m_isARED; //!< True to enable Adaptive RED bool m_isAdaptMaxP; //!< True to adapt m_curMaxP - double m_minTh; //!< Min avg length threshold (bytes) - double m_maxTh; //!< Max avg length threshold (bytes), should be >= 2*minTh + double m_minTh; //!< Minimum threshold for m_qAvg (bytes or packets) + double m_maxTh; //!< Maximum threshold for m_qAvg (bytes or packets), should be >= 2 * m_minTh uint32_t m_queueLimit; //!< Queue limit in bytes / packets double m_qW; //!< Queue weight given to cur queue size sample double m_lInterm; //!< The max probability of dropping a packet From 0c745d244da73db6e96beb6321e866755430488d Mon Sep 17 00:00:00 2001 From: "Mohit P. Tahiliani" Date: Sun, 28 May 2017 22:15:20 +0200 Subject: [PATCH 071/551] traffic-control: Remove duplicate test case in RED test suite --- .../test/red-queue-disc-test-suite.cc | 34 +++---------------- 1 file changed, 4 insertions(+), 30 deletions(-) diff --git a/src/traffic-control/test/red-queue-disc-test-suite.cc b/src/traffic-control/test/red-queue-disc-test-suite.cc index d3ebd9b24b3..8f15ab1364d 100644 --- a/src/traffic-control/test/red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/red-queue-disc-test-suite.cc @@ -240,7 +240,6 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) uint32_t test11; uint32_t test12; uint32_t test13; - uint32_t test14; } drop; @@ -427,7 +426,7 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) NS_TEST_EXPECT_MSG_NE (st.unforcedMark, 0, "There should be some unforced marks"); - // test 11: Original RED with default parameter settings and fixed m_curMaxP + // test 11: RED with default parameter settings, linear drop probability and fixed m_curMaxP queue = CreateObject (); minTh = 30 * modeSize; maxTh = 90 * modeSize; @@ -477,32 +476,7 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) NS_TEST_EXPECT_MSG_LT (drop.test12, drop.test11, "Test 12 should have less drops due to probability mark than test 11"); - // test 11: RED with Linear drop probability - queue = CreateObject (); - minTh = 30 * modeSize; - maxTh = 90 * modeSize; - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Mode", mode), true, - "Verify that we can actually set the attribute Mode"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MinTh", DoubleValue (minTh)), true, - "Verify that we can actually set the attribute MinTh"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("MaxTh", DoubleValue (maxTh)), true, - "Verify that we can actually set the attribute MaxTh"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QueueLimit", UintegerValue (qSize)), true, - "Verify that we can actually set the attribute QueueLimit"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("QW", DoubleValue (0.002)), true, - "Verify that we can actually set the attribute QW"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("LInterm", DoubleValue (2)), true, - "Verify that we can actually set the attribute LInterm"); - NS_TEST_EXPECT_MSG_EQ (queue->SetAttributeFailSafe ("Gentle", BooleanValue (true)), true, - "Verify that we can actually set the attribute Gentle"); - queue->Initialize (); - Enqueue (queue, pktSize, 300, false); - st = StaticCast (queue)->GetStats (); - drop.test13 = st.unforcedDrop; - NS_TEST_EXPECT_MSG_NE (drop.test13, 0, "There should some dropped packets due to probability mark"); - - - // test 14: RED with Nonlinear drop probability + // test 13: RED with Nonlinear drop probability queue = CreateObject (); minTh = 30 * modeSize; maxTh = 90 * modeSize; @@ -525,8 +499,8 @@ RedQueueDiscTestCase::RunRedTest (StringValue mode) queue->Initialize (); Enqueue (queue, pktSize, 300, false); st = StaticCast (queue)->GetStats (); - drop.test14 = st.unforcedDrop; - NS_TEST_EXPECT_MSG_LT (drop.test14, drop.test13, "Test 14 should have less drops due to probability mark than test 13"); + drop.test13 = st.unforcedDrop; + NS_TEST_EXPECT_MSG_LT (drop.test13, drop.test11, "Test 13 should have less drops due to probability mark than test 11"); } From 4bcec242c59d25b57b6c1db4d0b7cba7711ac5be Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sun, 28 May 2017 19:46:38 +0200 Subject: [PATCH 072/551] network: doxygen updates --- src/network/model/byte-tag-list.h | 5 +- src/network/test/buffer-test.cc | 35 +++- .../test/drop-tail-queue-test-suite.cc | 18 +- src/network/test/error-model-test-suite.cc | 61 ++++++- src/network/test/ipv6-address-test-suite.cc | 29 +++- src/network/test/packet-metadata-test.cc | 98 ++++++++++- .../test/packet-socket-apps-test-suite.cc | 27 ++- src/network/test/packet-test-suite.cc | 163 ++++++++++++++++-- src/network/test/packetbb-test-suite.cc | 27 ++- src/network/test/pcap-file-test-suite.cc | 97 +++++++---- .../test/sequence-number-test-suite.cc | 51 +++++- 11 files changed, 513 insertions(+), 98 deletions(-) diff --git a/src/network/model/byte-tag-list.h b/src/network/model/byte-tag-list.h index a8e1cb39577..3841b86ea72 100644 --- a/src/network/model/byte-tag-list.h +++ b/src/network/model/byte-tag-list.h @@ -85,7 +85,10 @@ class ByteTagList int32_t start; //!< offset to the start of the tag from the virtual byte buffer int32_t end; //!< offset to the end of the tag from the virtual byte buffer TagBuffer buf; //!< the data for the tag as generated by Tag::Serialize - Item (TagBuffer buf); //!< constructs an item with the given TagBuffer + + /// Constructs an item with the given TagBuffer + /// \param buf The Tag Buffer + Item (TagBuffer buf); private: /// Friend class friend class ByteTagList; diff --git a/src/network/test/buffer-test.cc b/src/network/test/buffer-test.cc index e607d9572db..47932ac0181 100644 --- a/src/network/test/buffer-test.cc +++ b/src/network/test/buffer-test.cc @@ -25,11 +25,27 @@ using namespace ns3; -//----------------------------------------------------------------------------- -// Unit tests -//----------------------------------------------------------------------------- +/** + * \ingroup network + * \defgroup network-test Network module unit tests + */ + +/** + * \ingroup network-test + * \ingroup tests + * + * Buffer unit tests. + */ class BufferTest : public TestCase { private: + /** + * Checks the buffer content + * \param b The buffer to check + * \param n The number of bytes to check + * \param array The aray of bytes that should be in the buffer + * \param file The file name + * \param line The line number + */ void EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[], const char *file, int line); public: virtual void DoRun (void); @@ -78,7 +94,8 @@ BufferTest::EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[], const cha } } -/** \todo Works only when variadic macros are +/* + * Works only when variadic macros are * available which is the case for gcc. */ #define ENSURE_WRITTEN_BYTES(buffer, n, ...) \ @@ -360,7 +377,13 @@ BufferTest::DoRun (void) val2 |= i.ReadU8 (); NS_TEST_ASSERT_MSG_EQ (val1, val2, "Bad ReadNtohU16()"); } -//----------------------------------------------------------------------------- + +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Buffer TestSuite + */ class BufferTestSuite : public TestSuite { public: @@ -373,4 +396,4 @@ BufferTestSuite::BufferTestSuite () AddTestCase (new BufferTest, TestCase::QUICK); } -static BufferTestSuite g_bufferTestSuite; +static BufferTestSuite g_bufferTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/drop-tail-queue-test-suite.cc b/src/network/test/drop-tail-queue-test-suite.cc index a98210ef54d..ee228aa73b5 100644 --- a/src/network/test/drop-tail-queue-test-suite.cc +++ b/src/network/test/drop-tail-queue-test-suite.cc @@ -22,6 +22,12 @@ using namespace ns3; +/** + * \ingroup network-test + * \ingroup tests + * + * DropTailQueue unit tests. + */ class DropTailQueueTestCase : public TestCase { public: @@ -77,7 +83,13 @@ DropTailQueueTestCase::DoRun (void) NS_TEST_EXPECT_MSG_EQ ((packet == 0), true, "There are really no packets in there"); } -static class DropTailQueueTestSuite : public TestSuite +/** + * \ingroup network-test + * \ingroup tests + * + * \brief DropTail Queue TestSuite + */ +class DropTailQueueTestSuite : public TestSuite { public: DropTailQueueTestSuite () @@ -85,4 +97,6 @@ static class DropTailQueueTestSuite : public TestSuite { AddTestCase (new DropTailQueueTestCase (), TestCase::QUICK); } -} g_dropTailQueueTestSuite; +}; + +static DropTailQueueTestSuite g_dropTailQueueTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/error-model-test-suite.cc b/src/network/test/error-model-test-suite.cc index 1d334e7a3b1..ec2847a5acd 100644 --- a/src/network/test/error-model-test-suite.cc +++ b/src/network/test/error-model-test-suite.cc @@ -64,6 +64,12 @@ static void BuildSimpleTopology (Ptr a, Ptr b, Ptr output->SetAddress (Mac48Address::Allocate ()); } +/** + * \ingroup network-test + * \ingroup tests + * + * ErrorModel unit tests. + */ class ErrorModelSimple : public TestCase { public: @@ -72,10 +78,23 @@ class ErrorModelSimple : public TestCase private: virtual void DoRun (void); + /** + * Receive form a NetDevice + * \param nd The NetDevice. + * \param p The received packet. + * \param protocol The protocol received. + * \param addr The sender address. + * \return True on success. + */ bool Receive (Ptr nd, Ptr p, uint16_t protocol, const Address& addr); + /** + * Register a Drop + * \param p The dropped packet + */ void DropEvent (Ptr p); - uint32_t m_count; - uint32_t m_drops; + + uint32_t m_count; //!< The received packets counter. + uint32_t m_drops; //!< The dropped packets counter. }; // Add some help text to this case to describe what it is intended to test @@ -142,6 +161,12 @@ ErrorModelSimple::DoRun (void) NS_TEST_ASSERT_MSG_EQ (m_drops, 9, "Wrong number of drops."); } +/** + * \ingroup network-test + * \ingroup tests + * + * BurstErrorModel unit tests. + */ class BurstErrorModelSimple : public TestCase { public: @@ -150,10 +175,23 @@ class BurstErrorModelSimple : public TestCase private: virtual void DoRun (void); + /** + * Receive form a NetDevice + * \param nd The NetDevice. + * \param p The received packet. + * \param protocol The protocol received. + * \param addr The sender address. + * \return True on success. + */ bool Receive (Ptr nd, Ptr p, uint16_t protocol, const Address& addr); + /** + * Register a Drop + * \param p The dropped packet + */ void DropEvent (Ptr p); - uint32_t m_count; - uint32_t m_drops; + + uint32_t m_count; //!< The received packets counter. + uint32_t m_drops; //!< The dropped packets counter. }; // Add some help text to this case to describe what it is intended to test @@ -224,9 +262,16 @@ BurstErrorModelSimple::DoRun (void) NS_TEST_ASSERT_MSG_EQ (m_drops, 260 , "Wrong number of drops."); } -// This is the start of an error model test suite. For starters, this is -// just testing that the SimpleNetDevice is working but this can be -// extended to many more test cases in the future +/** + * \ingroup network-test + * \ingroup tests + * + * \brief ErrorModel TestSuite + * + * This is the start of an error model test suite. For starters, this is + * just testing that the SimpleNetDevice is working but this can be + * extended to many more test cases in the future + */ class ErrorModelTestSuite : public TestSuite { public: @@ -241,4 +286,4 @@ ErrorModelTestSuite::ErrorModelTestSuite () } // Do not forget to allocate an instance of this TestSuite -static ErrorModelTestSuite errorModelTestSuite; +static ErrorModelTestSuite errorModelTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/ipv6-address-test-suite.cc b/src/network/test/ipv6-address-test-suite.cc index 407e57b99cb..0672665b679 100644 --- a/src/network/test/ipv6-address-test-suite.cc +++ b/src/network/test/ipv6-address-test-suite.cc @@ -19,27 +19,33 @@ using namespace ns3; -class Ipv6AddressTestCase1 : public TestCase +/** + * \ingroup network-test + * \ingroup tests + * + * Ipv6Address unit tests. + */ +class Ipv6AddressTestCase : public TestCase { public: - Ipv6AddressTestCase1 (); - virtual ~Ipv6AddressTestCase1 (); + Ipv6AddressTestCase (); + virtual ~Ipv6AddressTestCase (); private: virtual void DoRun (void); }; -Ipv6AddressTestCase1::Ipv6AddressTestCase1 () +Ipv6AddressTestCase::Ipv6AddressTestCase () : TestCase ("serialization code") { } -Ipv6AddressTestCase1::~Ipv6AddressTestCase1 () +Ipv6AddressTestCase::~Ipv6AddressTestCase () { } void -Ipv6AddressTestCase1::DoRun (void) +Ipv6AddressTestCase::DoRun (void) { Ipv6Address ip = Ipv6Address ("2001:db8::1"); uint8_t ipBytes[16]; @@ -91,6 +97,13 @@ Ipv6AddressTestCase1::DoRun (void) } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Ipv6Address TestSuite + * + */ class Ipv6AddressTestSuite : public TestSuite { public: @@ -100,8 +113,8 @@ class Ipv6AddressTestSuite : public TestSuite Ipv6AddressTestSuite::Ipv6AddressTestSuite () : TestSuite ("ipv6-address", UNIT) { - AddTestCase (new Ipv6AddressTestCase1, TestCase::QUICK); + AddTestCase (new Ipv6AddressTestCase, TestCase::QUICK); } -static Ipv6AddressTestSuite ipv6AddressTestSuite; +static Ipv6AddressTestSuite ipv6AddressTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/packet-metadata-test.cc b/src/network/test/packet-metadata-test.cc index 1066739fdd3..82b720c8297 100644 --- a/src/network/test/packet-metadata-test.cc +++ b/src/network/test/packet-metadata-test.cc @@ -30,16 +30,35 @@ using namespace ns3; namespace { +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Base header-type class to check the proper header concatenation + * + * \note Class internal to packet-metadata-test.cc + */ class HistoryHeaderBase : public Header { public: + /** + * \brief Get the type ID. + * \return The object TypeId. + */ static TypeId GetTypeId (void); HistoryHeaderBase (); + /** + * Checks if the header has deserialization errors + * \returns True if no error found. + */ bool IsOk (void) const; protected: + /** + * Signal that an error has been found in deserialization. + */ void ReportError (void); private: - bool m_ok; + bool m_ok; //!< True if no error is signalled. }; TypeId @@ -68,11 +87,23 @@ HistoryHeaderBase::ReportError (void) } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template header-type class to check the proper header concatenation + * + * \note Class internal to packet-metadata-test.cc + */ template class HistoryHeader : public HistoryHeaderBase { public: HistoryHeader (); + /** + * \brief Get the type ID. + * \return The object TypeId. + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual void Print (std::ostream &os) const; @@ -138,16 +169,35 @@ HistoryHeader::Deserialize (Buffer::Iterator start) return N; } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Base trailer-type class to check the proper trailer concatenation + * + * \note Class internal to packet-metadata-test.cc + */ class HistoryTrailerBase : public Trailer { public: + /** + * \brief Get the type ID. + * \return The object TypeId. + */ static TypeId GetTypeId (void); HistoryTrailerBase (); + /** + * Checks if the header has deserialization errors + * \returns True if no error found. + */ bool IsOk (void) const; protected: + /** + * Signal that an error has been found in deserialization. + */ void ReportError (void); private: - bool m_ok; + bool m_ok; //!< True if no error is signalled. }; TypeId @@ -174,20 +224,30 @@ HistoryTrailerBase::ReportError (void) } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template trailer-type class to check the proper trailer concatenation + * + * \note Class internal to packet-metadata-test.cc + */ template class HistoryTrailer : public HistoryTrailerBase { public: HistoryTrailer (); + /** + * \brief Get the type ID. + * \return The object TypeId. + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual void Print (std::ostream &os) const; virtual uint32_t GetSerializedSize (void) const; virtual void Serialize (Buffer::Iterator start) const; virtual uint32_t Deserialize (Buffer::Iterator start); -private: - bool m_ok; }; template @@ -250,13 +310,32 @@ HistoryTrailer::Deserialize (Buffer::Iterator start) } +/** + * \ingroup network-test + * \ingroup tests + * + * Packet Metadata unit tests. + */ class PacketMetadataTest : public TestCase { public: PacketMetadataTest (); virtual ~PacketMetadataTest (); + /** + * Checks the packet header and trailer history + * \param p The packet + * \param file The file name + * \param line The line number + * \param n The number of variable arguments + * \param ... The variable arguments + */ void CheckHistory (Ptr p, const char *file, int line, uint32_t n, ...); virtual void DoRun (void); private: + /** + * Adds an header to the packet + * \param p The packet + * \return The packet with the header added. + */ Ptr DoAddHeader (Ptr p); }; @@ -822,7 +901,14 @@ PacketMetadataTest::DoRun (void) delete [] buf; NS_TEST_EXPECT_MSG_EQ (msg, std::string ("hello world"), "Could not find original data in received packet"); } -//----------------------------------------------------------------------------- + + +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Packet Metadata TestSuite + */ class PacketMetadataTestSuite : public TestSuite { public: @@ -835,4 +921,4 @@ PacketMetadataTestSuite::PacketMetadataTestSuite () AddTestCase (new PacketMetadataTest, TestCase::QUICK); } -PacketMetadataTestSuite g_packetMetadataTest; +static PacketMetadataTestSuite g_packetMetadataTest; //!< Static variable for test initialization diff --git a/src/network/test/packet-socket-apps-test-suite.cc b/src/network/test/packet-socket-apps-test-suite.cc index 4e7275a408b..9d2e6b55b96 100644 --- a/src/network/test/packet-socket-apps-test-suite.cc +++ b/src/network/test/packet-socket-apps-test-suite.cc @@ -32,15 +32,26 @@ using namespace ns3; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief PacketSocket apps Unit Test + */ class PacketSocketAppsTest : public TestCase { - uint32_t m_receivedPacketSize; - uint32_t m_receivedPacketNumber; + uint32_t m_receivedPacketSize; //!< Received packet size + uint32_t m_receivedPacketNumber; //!< Number of received packets public: virtual void DoRun (void); PacketSocketAppsTest (); + /** + * Receive a packet + * \param packet The packet + * \param from Address of the sender + */ void ReceivePkt (Ptr packet, const Address &from); }; @@ -114,8 +125,12 @@ PacketSocketAppsTest::DoRun (void) } -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- +/** + * \ingroup network-test + * \ingroup tests + * + * \brief PacketSocket apps TestSuite + */ class PacketSocketAppsTestSuite : public TestSuite { public: @@ -123,4 +138,6 @@ class PacketSocketAppsTestSuite : public TestSuite { AddTestCase (new PacketSocketAppsTest, TestCase::QUICK); } -} g_packetSocketAppsTestSuite; +}; + +static PacketSocketAppsTestSuite g_packetSocketAppsTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/packet-test-suite.cc b/src/network/test/packet-test-suite.cc index be7a4f122b9..4012e32255b 100644 --- a/src/network/test/packet-test-suite.cc +++ b/src/network/test/packet-test-suite.cc @@ -35,10 +35,20 @@ using namespace ns3; //----------------------------------------------------------------------------- namespace { +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Base class for Test tags + * + * \note Class internal to packet-test-suite.cc + */ class ATestTagBase : public Tag { public: ATestTagBase () : m_error (false), m_data (0) {} + /// Constructor + /// \param data Tag data ATestTagBase (uint8_t data) : m_error (false), m_data (data) {} /** * Register this type. @@ -54,14 +64,24 @@ class ATestTagBase : public Tag ; return tid; } + /// Get the tag data. + /// \return the tag data. int GetData () const { int result = (int)m_data; return result; } - bool m_error; - uint8_t m_data; + bool m_error; //!< Error in the Tag + uint8_t m_data; //!< Tag data }; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template class for Test tags + * + * \note Class internal to packet-test-suite.cc + */ template class ATestTag : public ATestTagBase { @@ -110,14 +130,26 @@ class ATestTag : public ATestTagBase } ATestTag () : ATestTagBase () {} + /// Constructor + /// \param data Tag data ATestTag (uint8_t data) : ATestTagBase (data) {} }; // Previous versions of ns-3 limited the tag size to 20 bytes or less -static const uint8_t LARGE_TAG_BUFFER_SIZE = 64; +// static const uint8_t LARGE_TAG_BUFFER_SIZE = 64; +#define LARGE_TAG_BUFFER_SIZE 64 -// Bug 2221: Expanding packet tag maximum size +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template class for Large Test tags + * + * \see Bug 2221: Expanding packet tag maximum size + * + * \note Class internal to packet-test-suite.cc + */ class ALargeTestTag : public Tag { public: @@ -167,10 +199,18 @@ class ALargeTestTag : public Tag os << "(" << (uint16_t) m_size << ")"; } private: - uint8_t m_size; - std::vector m_data; + uint8_t m_size; //!< Packet size + std::vector m_data; //!< Tag data }; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Base class for Test headers + * + * \note Class internal to packet-test-suite.cc + */ class ATestHeaderBase : public Header { public: @@ -189,9 +229,17 @@ class ATestHeaderBase : public Header ; return tid; } - bool m_error; + bool m_error; //!< Error in the Header }; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template class for Test headers + * + * \note Class internal to packet-test-suite.cc + */ template class ATestHeader : public ATestHeaderBase { @@ -241,6 +289,14 @@ class ATestHeader : public ATestHeaderBase }; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Base class for Test trailers + * + * \note Class internal to packet-test-suite.cc + */ class ATestTrailerBase : public Trailer { public: @@ -259,9 +315,17 @@ class ATestTrailerBase : public Trailer ; return tid; } - bool m_error; + bool m_error; //!< Error in the Trailer }; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Template class for Test trailers + * + * \note Class internal to packet-test-suite.cc + */ template class ATestTrailer : public ATestTrailerBase { @@ -313,15 +377,28 @@ class ATestTrailer : public ATestTrailerBase }; - +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Struct to hold the expected data in the packet + * + * \note Class internal to packet-test-suite.cc + */ struct Expected { + /** + * Constructor + * \param n_ Number of elements + * \param start_ Start + * \param end_ End + */ Expected (uint32_t n_, uint32_t start_, uint32_t end_) : n (n_), start (start_), end (end_) {} - uint32_t n; - uint32_t start; - uint32_t end; + uint32_t n; //!< Number of elements + uint32_t start; //!< Start + uint32_t end; //!< End }; } @@ -332,12 +409,26 @@ struct Expected #define CHECK(p, n, ...) \ DoCheck (p, __FILE__, __LINE__, n, __VA_ARGS__) +/** + * \ingroup network-test + * \ingroup tests + * + * Packet unit tests. + */ class PacketTest : public TestCase { public: PacketTest (); virtual void DoRun (void); private: + /** + * Checks the packet + * \param p The packet + * \param file The file name + * \param line The line number + * \param n The number of variable arguments + * \param ... The variable arguments + */ void DoCheck (Ptr p, const char *file, int line, uint32_t n, ...); }; @@ -647,7 +738,13 @@ PacketTest::DoRun (void) tmp->AddPacketTag (a); } } -//-------------------------------------- + +/** + * \ingroup network-test + * \ingroup tests + * + * Packet Tag list unit tests. + */ class PacketTagListTest : public TestCase { public: @@ -655,16 +752,43 @@ class PacketTagListTest : public TestCase virtual ~PacketTagListTest (); private: void DoRun (void); + /** + * Checks against a reference PacketTagList + * \param ref Reference + * \param t List to test + * \param msg Message + * \param miss Expected miss/hit + */ void CheckRef (const PacketTagList & ref, ATestTagBase & t, const char * msg, bool miss = false); + /** + * Checks against a reference PacketTagList + * \param ref Reference + * \param msg Message + * \param miss Expected miss/hit + */ void CheckRefList (const PacketTagList & ref, const char * msg, int miss = 0); + + /** + * Prints the remove time + * \param ref Reference. + * \param t List to test. + * \param msg Message - prints on cout if msg is not null. + * \return the ticks to remove the tags. + */ int RemoveTime (const PacketTagList & ref, ATestTagBase & t, const char * msg = 0); + + /** + * Prints the remove time + * \param verbose prints on cout if verbose is true. + * \return the ticks to remove the tags. + */ int AddRemoveTime (const bool verbose = false); }; @@ -741,7 +865,7 @@ PacketTagListTest::RemoveTime (const PacketTagList & ref, std::cout << GetName () << "remove time: " << msg << ": " << std::setw (8) << delta << " ticks to remove " << reps << " times" - << std::endl; + << std::endl; } return delta; } @@ -763,7 +887,7 @@ PacketTagListTest::AddRemoveTime (const bool verbose /* = false */) std::cout << GetName () << "add/remove time: " << std::setw (8) << delta << " ticks to add+remove " << reps << " times" - << std::endl; + << std::endl; } return delta; } @@ -911,7 +1035,12 @@ PacketTagListTest::DoRun (void) } -//----------------------------------------------------------------------------- +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Packet TestSuite + */ class PacketTestSuite : public TestSuite { public: @@ -925,4 +1054,4 @@ PacketTestSuite::PacketTestSuite () AddTestCase (new PacketTagListTest, TestCase::QUICK); } -static PacketTestSuite g_packetTestSuite; +static PacketTestSuite g_packetTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/packetbb-test-suite.cc b/src/network/test/packetbb-test-suite.cc index fb0bb0e867d..cc859dd9b9f 100644 --- a/src/network/test/packetbb-test-suite.cc +++ b/src/network/test/packetbb-test-suite.cc @@ -29,9 +29,22 @@ using namespace ns3; +/** + * \ingroup network-test + * \ingroup tests + * + * \brief PacketBb TestCase + */ class PbbTestCase : public TestCase { public: + /** + * Constructor + * \param name Test name. + * \param packet Packet to test. + * \param buffer Buffer to test. + * \param size Buffer size. + */ PbbTestCase (std::string name, Ptr packet, uint8_t * buffer, uint32_t size); virtual ~PbbTestCase (void); @@ -40,11 +53,13 @@ class PbbTestCase : public TestCase virtual void DoRun (void); private: + /// Serialization void TestSerialize (void); + /// Deserialization void TestDeserialize (void); - Ptr m_refPacket; - Buffer m_refBuffer; + Ptr m_refPacket; //!< Reference packet + Buffer m_refBuffer; //!< Reference buffer }; PbbTestCase::PbbTestCase (std::string name, Ptr packet, @@ -99,6 +114,12 @@ PbbTestCase::TestDeserialize (void) "deserialization failed, objects do not match"); } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief PacketBb TestSuite + */ class PbbTestSuite : public TestSuite { public: @@ -3820,4 +3841,4 @@ PbbTestSuite::PbbTestSuite () } } -static PbbTestSuite pbbTestSuite; +static PbbTestSuite pbbTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/pcap-file-test-suite.cc b/src/network/test/pcap-file-test-suite.cc index 799b67f6198..79b4041e56d 100644 --- a/src/network/test/pcap-file-test-suite.cc +++ b/src/network/test/pcap-file-test-suite.cc @@ -77,10 +77,13 @@ CheckFileLength (std::string filename, uint64_t sizeExpected) return sizeActual == sizeExpected; } -// =========================================================================== -// Test case to make sure that the Pcap File Object can do its most basic job -// and create an empty pcap file. -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap File Object can do its + * most basic job and create an empty pcap file. + */ class WriteModeCreateTestCase : public TestCase { public: @@ -92,7 +95,7 @@ class WriteModeCreateTestCase : public TestCase virtual void DoRun (void); virtual void DoTeardown (void); - std::string m_testFilename; + std::string m_testFilename; //!< File name }; WriteModeCreateTestCase::WriteModeCreateTestCase () @@ -192,10 +195,13 @@ WriteModeCreateTestCase::DoRun (void) ") returns error"); } -// =========================================================================== -// Test case to make sure that the Pcap File Object can open an existing pcap -// file. -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap File Object can open an + * existing pcap file. + */ class ReadModeCreateTestCase : public TestCase { public: @@ -207,7 +213,7 @@ class ReadModeCreateTestCase : public TestCase virtual void DoRun (void); virtual void DoTeardown (void); - std::string m_testFilename; + std::string m_testFilename; //!< File name }; ReadModeCreateTestCase::ReadModeCreateTestCase () @@ -410,10 +416,14 @@ AppendModeCreateTestCase::DoRun (void) } #endif -// =========================================================================== -// Test case to make sure that the Pcap File Object can write out correct pcap -// file headers in both endian cases, and then read them in correctly. -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap File Object can + * write out correct pcap file headers in both endian cases, + * and then read them in correctly. + */ class FileHeaderTestCase : public TestCase { public: @@ -425,7 +435,7 @@ class FileHeaderTestCase : public TestCase virtual void DoRun (void); virtual void DoTeardown (void); - std::string m_testFilename; + std::string m_testFilename; //!< File name }; FileHeaderTestCase::FileHeaderTestCase () @@ -650,10 +660,14 @@ FileHeaderTestCase::DoRun (void) f.Close (); } -// =========================================================================== -// Test case to make sure that the Pcap File Object can write pcap packet -// records in both endian cases, and then read them in correctly. -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap File Object can + * write pcap packet records in both endian cases, and then read + * them in correctly. + */ class RecordHeaderTestCase : public TestCase { public: @@ -665,7 +679,7 @@ class RecordHeaderTestCase : public TestCase virtual void DoRun (void); virtual void DoTeardown (void); - std::string m_testFilename; + std::string m_testFilename; //!< File name }; RecordHeaderTestCase::RecordHeaderTestCase () @@ -956,10 +970,13 @@ RecordHeaderTestCase::DoRun (void) f.Close (); } -// =========================================================================== -// Test case to make sure that the Pcap File Object can read out the contents -// of a known good pcap file. -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap File Object can read + * out the contents of a known good pcap file. + */ class ReadFileTestCase : public TestCase { public: @@ -971,7 +988,7 @@ class ReadFileTestCase : public TestCase virtual void DoRun (void); virtual void DoTeardown (void); - std::string m_testFilename; + std::string m_testFilename; //!< File name }; ReadFileTestCase::ReadFileTestCase () @@ -996,12 +1013,15 @@ ReadFileTestCase::DoTeardown (void) static const uint32_t N_KNOWN_PACKETS = 6; static const uint32_t N_PACKET_BYTES = 16; +/** + * PCAP Packet structure + */ typedef struct PACKET_ENTRY { - uint32_t tsSec; - uint32_t tsUsec; - uint32_t inclLen; - uint32_t origLen; - uint16_t data[N_PACKET_BYTES]; + uint32_t tsSec; //!< Time (seconds part) + uint32_t tsUsec; //!< Time (micro seconds part) + uint32_t inclLen; //!< Length of the entry in the PCAP + uint32_t origLen; //!< length of the original packet + uint16_t data[N_PACKET_BYTES]; //!< Packet data } PacketEntry; static const PacketEntry knownPackets[] = { @@ -1066,9 +1086,12 @@ ReadFileTestCase::DoRun (void) f.Close (); } -// =========================================================================== -// Test case to make sure that the Pcap::Diff method works as expected -// =========================================================================== +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test case to make sure that the Pcap::Diff method works as expected. + */ class DiffTestCase : public TestCase { public: @@ -1121,6 +1144,12 @@ DiffTestCase::DoRun (void) NS_TEST_EXPECT_MSG_EQ (usec, 3696, "Files are different from 2.3696 seconds"); } +/** + * \ingroup network-test + * \ingroup tests + * + * \brief PCAP file utils TestSuite + */ class PcapFileTestSuite : public TestSuite { public: @@ -1140,4 +1169,4 @@ PcapFileTestSuite::PcapFileTestSuite () AddTestCase (new DiffTestCase, TestCase::QUICK); } -static PcapFileTestSuite pcapFileTestSuite; +static PcapFileTestSuite pcapFileTestSuite; //!< Static variable for test initialization diff --git a/src/network/test/sequence-number-test-suite.cc b/src/network/test/sequence-number-test-suite.cc index 5da0a7a72b6..9ad5001bb5e 100644 --- a/src/network/test/sequence-number-test-suite.cc +++ b/src/network/test/sequence-number-test-suite.cc @@ -26,11 +26,22 @@ using namespace ns3; +namespace { + + +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Test object using sequence numbers + * + * \note Class internal to sequence-number-test-suite.cc + */ class SequenceNumberTestObj : public Object { + /// Test traced sequence number. TracedValue m_testTracedSequenceNumber; - public: SequenceNumberTestObj () @@ -38,6 +49,10 @@ class SequenceNumberTestObj : public Object m_testTracedSequenceNumber = SequenceNumber32 (0); } + /** + * \brief Get the type ID. + * \return The object TypeId. + */ static TypeId GetTypeId (void) { static TypeId tid = TypeId ("ns3::SequenceNumberTestObj") @@ -56,19 +71,31 @@ class SequenceNumberTestObj : public Object return GetTypeId (); } + /// Increment the sequence number. void IncSequenceNumber () { m_testTracedSequenceNumber += 1; } - - }; +} + +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Sequence Number Unit Test + */ class SequenceNumberTestCase : public TestCase { - SequenceNumber32 m_oldval; - SequenceNumber32 m_newval; - + SequenceNumber32 m_oldval; //!< Old value + SequenceNumber32 m_newval; //!< New value + + /** + * Sequence number tracker + * \param oldval Old value + * \param newval New value + */ void SequenceNumberTracer (SequenceNumber32 oldval, SequenceNumber32 newval); public: @@ -181,7 +208,13 @@ void SequenceNumberTestCase::DoRun (void) } -static class SequenceNumberTestSuite : public TestSuite +/** + * \ingroup network-test + * \ingroup tests + * + * \brief Sequence Number TestSuite + */ +class SequenceNumberTestSuite : public TestSuite { public: SequenceNumberTestSuite () @@ -189,4 +222,6 @@ static class SequenceNumberTestSuite : public TestSuite { AddTestCase (new SequenceNumberTestCase (), TestCase::QUICK); } -} g_seqNumTests; +}; + +static SequenceNumberTestSuite g_seqNumTests; //!< Static variable for test initialization From 3a651df87d365c8b1883bb7b9542861ca45a3992 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sun, 28 May 2017 22:22:41 +0200 Subject: [PATCH 073/551] Routing sphynx documentation upgrades --- doc/models/source/index.rst | 1 + src/internet/doc/routing-overview.rst | 217 ++++++++---------- src/internet/doc/routing-specialization.dia | Bin 2723 -> 2467 bytes .../doc/nix-vector-routing.h | 52 ----- .../doc/nix-vector-routing.rst | 63 +++++ .../model/ipv4-nix-vector-routing.h | 7 + src/olsr/doc/olsr.rst | 40 ++++ 7 files changed, 204 insertions(+), 176 deletions(-) delete mode 100644 src/nix-vector-routing/doc/nix-vector-routing.h create mode 100644 src/nix-vector-routing/doc/nix-vector-routing.rst diff --git a/doc/models/source/index.rst b/doc/models/source/index.rst index 260308ddbd9..dd5e8495be1 100644 --- a/doc/models/source/index.rst +++ b/doc/models/source/index.rst @@ -40,6 +40,7 @@ This document is written in `reStructuredText routingProtocol, + int16_t priority); + + void AddRoutingProtocol (Ptr routingProtocol, + int16_t priority); + +These methods are implemented respectively by class Ipv4ListRoutingImpl and by class +Ipv6ListRoutingImpl in the internet module. + +The priority variable above governs the priority in which the routing protocols +are inserted. Notice that it is a signed int. By default in |ns3|, the helper +classes will instantiate a Ipv[4,6]ListRoutingImpl object, and add to it an +Ipv[4,6]StaticRoutingImpl object at priority zero. Internally, a list of +Ipv[4,6]RoutingProtocols is stored, and and the routing protocols are each consulted +in decreasing order of priority to see whether a match is found. Therefore, if +you want your Ipv4RoutingProtocol to have priority lower than the static +routing, insert it with priority less than 0; e.g.:: + + Ptr myRoutingProto = CreateObject (); + listRoutingPtr->AddRoutingProtocol (myRoutingProto, -10); + +Upon calls to RouteOutput() or RouteInput(), the list routing object will search +the list of routing protocols, in priority order, until a route is found. Such +routing protocol will invoke the appropriate callback and no further routing +protocols will be searched. + .. _Global-centralized-routing: Global centralized routing -************************** +++++++++++++++++++++++++++ Global centralized routing is sometimes called "God" routing; it is a special implementation that walks the simulation topology and runs a shortest path @@ -109,7 +184,7 @@ users can insert routes via Ipv4StaticRouting API and they will take precedence over routes found by global routing). Global Unicast Routing API -++++++++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~~~~~~~ The public API is very minimal. User scripts include the following:: @@ -152,7 +227,7 @@ user manually calls RecomputeRoutingTables() after such events. The default is set to false to preserve legacy |ns3| program behavior. Global Routing Implementation -+++++++++++++++++++++++++++++ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This section is for those readers who care about how this is implemented. A singleton object (GlobalRouteManager) is responsible for populating the static @@ -210,127 +285,6 @@ Advertisement for each router, and this link state database is fed into the OSPF shortest path computation logic. The Ipv4 API is finally used to populate the routes themselves. -.. _Unicast-routing: - -Unicast routing -*************** - -The following unicast routing protocols are defined for IPv4 and IPv6: - -* classes Ipv4ListRouting and Ipv6ListRouting (used to store a prioritized list of routing protocols) -* classes Ipv4StaticRouting and Ipv6StaticRouting (covering both unicast and multicast) -* class Ipv4GlobalRouting (used to store routes computed by the global route - manager, if that is used) -* class Ipv4NixVectorRouting (a more efficient version of global routing that - stores source routes in a packet header field) -* class Rip - the IPv4 RIPv2 protocol (:rfc:`2453`) -* class RipNg - the IPv6 RIPng protocol (:rfc:`2080`) -* IPv4 Optimized Link State Routing (OLSR) (a MANET protocol defined in - :rfc:`3626`) -* IPv4 Ad Hoc On Demand Distance Vector (AODV) (a MANET protocol defined in - :rfc:`3561`) -* IPv4 Destination Sequenced Distance Vector (DSDV) (a MANET protocol) -* IPv4 Dynamic Source Routing (DSR) (a MANET protocol) - -In the future, this architecture should also allow someone to implement a -Linux-like implementation with routing cache, or a Click modular router, but -those are out of scope for now. - -Ipv[4,6]ListRouting -+++++++++++++++++++ - -This section describes the current default |ns3| Ipv[4,6]RoutingProtocol. Typically, -multiple routing protocols are supported in user space and coordinate to write a -single forwarding table in the kernel. Presently in |ns3|, the implementation -instead allows for multiple routing protocols to build/keep their own routing -state, and the IP implementation will query each one of these routing -protocols (in some order determined by the simulation author) until a route is -found. - -We chose this approach because it may better facilitate the integration of -disparate routing approaches that may be difficult to coordinate the writing to -a single table, approaches where more information than destination IP address -(e.g., source routing) is used to determine the next hop, and on-demand routing -approaches where packets must be cached. - -Ipv[4,6]ListRouting::AddRoutingProtocol -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Classes Ipv4ListRouting and Ipv6ListRouting provides a pure virtual function declaration -for the method that allows one to add a routing protocol:: - - void AddRoutingProtocol (Ptr routingProtocol, - int16_t priority); - - void AddRoutingProtocol (Ptr routingProtocol, - int16_t priority); - -These methods are implemented respectively by class Ipv4ListRoutingImpl and by class -Ipv6ListRoutingImpl in the internet module. - -The priority variable above governs the priority in which the routing protocols -are inserted. Notice that it is a signed int. By default in |ns3|, the helper -classes will instantiate a Ipv[4,6]ListRoutingImpl object, and add to it an -Ipv[4,6]StaticRoutingImpl object at priority zero. Internally, a list of -Ipv[4,6]RoutingProtocols is stored, and and the routing protocols are each consulted -in decreasing order of priority to see whether a match is found. Therefore, if -you want your Ipv4RoutingProtocol to have priority lower than the static -routing, insert it with priority less than 0; e.g.:: - - Ptr myRoutingProto = CreateObject (); - listRoutingPtr->AddRoutingProtocol (myRoutingProto, -10); - -Upon calls to RouteOutput() or RouteInput(), the list routing object will search -the list of routing protocols, in priority order, until a route is found. Such -routing protocol will invoke the appropriate callback and no further routing -protocols will be searched. - -Optimized Link State Routing (OLSR) -+++++++++++++++++++++++++++++++++++ - -This IPv4 routing protocol was originally ported from the OLSR-UM implementation -for ns-2. The implementation is found in the src/olsr directory, and an -example script is in examples/simple-point-to-point-olsr.cc. - -Typically, OLSR is enabled in a main program by use of an OlsrHelper class that -installs OLSR into an Ipv4ListRoutingProtocol object. The following sample -commands will enable OLSR in a simulation using this helper class along with -some other routing helper objects. The setting of priority value 10, ahead of -the staticRouting priority of 0, means that OLSR will be consulted for a route -before the node's static routing table.:: - - NodeContainer c: - ... - // Enable OLSR - NS_LOG_INFO ("Enabling OLSR Routing."); - OlsrHelper olsr; - - Ipv4StaticRoutingHelper staticRouting; - - Ipv4ListRoutingHelper list; - list.Add (staticRouting, 0); - list.Add (olsr, 10); - - InternetStackHelper internet; - internet.SetRoutingHelper (list); - internet.Install (c); - -Once installed,the OLSR "main interface" can be set with the SetMainInterface() -command. If the user does not specify a main address, the protocol will select -the first primary IP address that it finds, starting first the loopback -interface and then the next non-loopback interface found, in order of Ipv4 -interface index. The loopback address of 127.0.0.1 is not selected. In addition, -a number of protocol constants are defined in olsr-routing-protocol.cc. - -Olsr is started at time zero of the simulation, based on a call to -Object::Start() that eventually calls OlsrRoutingProtocol::DoStart(). Note: a -patch to allow the user to start and stop the protocol at other times would be -welcome. - -Presently, OLSR is limited to use with an Ipv4ListRouting object, and does not -respond to dynamic changes to a device's IP address or link up/down -notifications; i.e. the topology changes are due to loss/gain of connectivity -over a wireless channel. RIP and RIPng +++++++++++++ @@ -451,6 +405,21 @@ tables and route advertisements may be larger than necessary. Prefix aggregation may be added in the future. +Other routing protocols ++++++++++++++++++++++++ + +Other routing protocols documentation can be found under the respective +modules sections, e.g.: + +* AODV +* Click +* DSDV +* DSR +* NixVectorRouting +* OLSR +* etc. + + .. _Multicast-routing: Multicast routing diff --git a/src/internet/doc/routing-specialization.dia b/src/internet/doc/routing-specialization.dia index 9c8122593e94bbbd0e48988a5640a950675f1a3f..bfa08262bb451d33ebc6ca378d202d162ecb02bc 100644 GIT binary patch literal 2467 zcmZY1XFMB-AII?!(KAY$G*-nPN0HXyXpNW&F|S5wV(%5RMr)q7CpbaJ5h+E@l-R4G z)gnsG#B6I;Tb@Doq_4e;~WAuQYt{Gx_H{7}s~Z8%QiN#v7Y zvRwBdU`F|J_XYCaRH0XoH&TFhf&BW2+8I}o2Ct)F9DK61IK#5ccNU-YWv<*tf)fr8 z{Dl4aZC|G&o27xP(itXf1+~8M*A71qCA^O=F8ER%pLb=u_%N5Jj=_*G($s2$DVJbR zG{y9Eb&EnEkUkLilt_2Pu^#xYCxtr$8Rd|76Z0}1m7U)|1Xci%s%4o{btTQk3S1q7 zAQxo4jlCjVaFfWxN=j)ij@n-hP#dfg7F>%d-GJtfRTM4-L^9iA58_Fc4z{8W?bxmV zDx|{d6`>X7@&|F&a&Tys!N~E(d%dl8is?aW9Ii~niA(B{(SW0Ek4+rJ8|Ef8q-Mbs zZu)Z2mWK0~k$*d1`sfZ1oJU@Tr+1-`z@zY6ju%~FMN-!0u3~pyQ*SB|Tq(Ji?+Bx` z`24l~2dh)w4cnWz{x!Hso!lD!(tF72ok1$WNo>koMa~Ks>0p24T{ta{87P(1Va5vd zeW;xMdi`XpIj3&_bPueR-$cg7vZg)$O<5YPx?65WE!qotCk>(vCA&&dUCnS!sDibbk{7VKWI;Oc^BMTq=fuXszz!nQRcw^U zwQYtk@J)9*A-r^z&Pan7!?4fiGIJo#0U5H-xYC`{S7jcOh+@*izO(_PaeHO`h{k!( zp7GGgOksLR(7H#jYQ)f{4s7gVzaB7`JWv`B6+GUZkv9g48-jb~|9SDrjHC1pR^1_R zi4V=eWy!wiNI0W}-qOEni0g;l=Z?KxBL>wJ+uMf^!HC>W)1eo%p$26x4*cKvJ07mh zMZJ`Ds5hycD#Rm$NZ4GC+jcanyuRw^-x5pZV&Es~E`f zEZ&@8u)*Zb<>2{Cib;!l+KfYuS>}}lM52mga;^8zXU?28%szN7RIvXgI6v}9dOWuL z0!1js4iz5TkN^1i&U{QtQS~IR{;0ebN}`P zTCLA@8)PjKY%$_e%yhDsdHUEUjKpEPn_Q_8A_z32`3k7EYJr*sL%te1Hfxz{VMGT@ zAX{#4)hxr61eD8NvyIruwsAg3mTK)u6;P8v6*oIG=N!$sva@R!gN;)TtK=})!A4Op zkcz29!30={z#QInxx~}$fcmnNeUue5LOJ9q{9w73XH)jRcQJ?8o431+IDbL`y}4c&!#4AOTF|1*igk34|PQQb+sgfUq;r z`u9CcHtLm8+|jgt)0JpuDfNgKDq%a51&{@ZXADfGeI@KngJ zA|}r%07D%y@-E$@FG=YXIw6ulG%RH0S5dM(LvdXV|HMw=+ZoowkTr0rK8gh zWJ|3koi=7XPqIrA8>lMd5%P93=l`9@)i!0D<`$8hshE6v*b|W~^I~Kv*}o!m8h^Wq zFLij-2go(dfq(!k0BUT%MAAelR|{F44bu8JKB*l9mO#(WD$hxb?W%;-Bg8q!vp`BI zq4TXtA1`$}&h3=J6P}ZgfYCx}SBy^1?HV%pZS;PL@6Cd{;_L3GWljeCQVG(T$F#vC zj!&!1LxC`geiZz}{3p#;r0cDvLzWI9e8vX$pd#JEc*IUL7?~}dU8DbX8A_cIxcHQ7 z`u-Ou)@K``#Iu}k?J#eGv$wKUJ#$Z0l7zG)O{vXZF1r_GDK;u+ho5!c*?Pd1DWx6- z8C0^MvaU@VoWHJ%kaf^5Io+7G5WO#5{@2r!;ey#$CpMTn-V=YCwACC^_fcLbxh{Ky zq`vU$Sox{0_dDzO0#L$AXyr}c{eV^h+Z)U6`MnN$Mp%DyWxQH0Uqoq8`SBUz$Keu3 zt%xKIxEX18?9a|&R7|nt5x(gqE_aZZw&PKt?Riv6rV>7%edD7W7E(8Ry~}0o%dIga zruF88N!V-|Q5Zco9Qj}H1X?=X$+OucrV_&cgp9rjxtR+&zzp}jFM z%5pN9PFO$FY~ydzElN4XE^1^oF0GPtfeKUC8bfvdd)ET-y7zaqio(9K+>%pkhRH}! zgqiflYoCnc`j6*Sd~ih?&ipnP#px>l`w4x zrcDlAwGpOVZ))S}_rogp!yb6w=y;X8pCIYh$g3`TQ!Pjh7diE8O&qstl~adc`~)>( zb;#H(PM{f+$j9|NWm{1whLE0v#;SO++f;gaoP_@mYaT^SF4^TQ2Xn^NZCL(J!x3z| zVNtuER(Xr}U5W3TQMs0}7o#smWgp&j{#d78ykq#BnnnrWpLc^hq7m4om@na)y%9kz s&VnjB*VGT^D(eMlYf9Jn`tB0itJV=G10cr_xD#<;+8e)njR3&^02tbydjJ3c literal 2723 zcmZwGc_0%E1IKZah=-NrK5{Hqi8*o~Il>&t{kX~%=1Q(Pk|jr&D~4r=IU@IcJ|h`( zlxq`u6=`d;VUG5=-sgSaKi__z|9<~}#WUEM{yUbfQuokxb-olDUE%zU6{mE&al*a8 z5;-lFpy+3E)kU573pZ6dwOWbjTAzOYqh-Y3VIt;*H^GH6J0dLfhpC%5BfF;Q%F2)W zXS|NfP8LBC# zoRfamSax={tlOA=X&ndeik!%L-O;Uoe>#C4-Lr7HD3KYOZAlF>f`i zdj1T=uaoXq+3)aa`iBJnXBIA+X(+XA%-=0SMRC8ahIX~It?t1d_zAu@HpT2jQRtQl2FlZa%7$_ERe`WH??@ zDO~wOASh^NKf>#>w~EXd&T2-1ALV5I+DS1@MnSQvJgEU}tqBm!3U`p>S#*~<2&gS2 z3^vCaKNdF|2V|b1QXV6jb`fRpPVelM9(KPYz{>rM6c4fI#cq~^+^X(S8aXL8k^S2P zp;q@wfF!h)imxFJ{!Q|s4kX0QEaV(6#>5u&O!^({)TBarCY|FS6c;S3?zPL7WC5mP zJKUGk$35S^Zcs_jX)KoQP3+ROf{e1cX-v1dtj#4B-OAWLJw2(6svH0Wh-7!lrCMmf zmR5=R9w=m>>RTD#xQ=m`otmr3R>l;vu<&IBVWF0c`Xmi1byQ2{NHV481V`Q%#7iH% zOV9Ov7@trnt9A z7kF3R*G$|Iu=ogNw!ZzF z4{MA~Z(iG_35GSxC9VV1y<(mUVvPv52EL?! z1sE?d?+ay?UC$>a0sz43iExzZ&fceEK`)mPz@^e>mCw0Yz!B%NRS>d z-JuXQi@1Jb7jOWwDr7Hy0{whHzV-Wy=zDk#l9spym2oaaxd86;R73RnN_FJ=Ni(5n z+`dQ8CB-I-j4qUc$*qZnQja+twR= zGxQ9(G2Hx8aCc7BHCJ3l%@~CB6D-|e7W*i_dL~Fay}PVPYb0%7^UcI0gy$$e+MuS; z)wbf)fz8=%XxOEPFWQ=g@yaah(m!%IpX96)pgkOQK1S}IggtQt4hXd^cP;pf=nA}+ z<|d4d+Rg!dS-8Wwz)n0rYPpNBdgd01wQk$W zX}-3g?q~Ng0Bs1X{+$-4m#p`0Jo94aRm0_@Q_#C#Fddk1n25~CE@%0UK3ePEG5E)hGLzCc-v2CcgzeoJU8D1+{Tw+N9M&?dax*^shU%mJ97ccZj=0jKP!F1*v$o{e_W}wxJ8?1nJ@@6KxY1Tm#Y}?T z{KpMgfJ@kCT6|%$z5h}O=p0exw~o(8Q1=>(kyxQqzbF->-KkZ|`BLw(t}nSA%n?^K z9ieJNyKzhU3CDCgaCOk*)#R8?=BNPGgN^5R^jXvM2c@akEE~DpPjrd5+vNpck3Y!U z8lv_VJ`OIzj*L7tf}CxCPB5(Ba@*yjh|l*9T+_i1PBkG$21Eb)@&6E0KSF3(1ktM6 zS*$?R+7v<5XQ?MIcWVswWwr6qD=PPZ#E~24{ zY|8hojZH9T(Y*?Bm`amX|L#>iyUkKTVt2A^uJnA*d8$z?uZrSC8Mhg>ZBl|<93K1= z=GvS3bu>9xl6b@Hn{EcP;QLM;oHEy{nvPQ!Aqz@86oae27_#>`nY@}geD#lk!w_Ee z-LzmgBvyI+qwD>RJF$Tr$Qr&`ZE|(9?N}z7L*riXu4Y4fK!1bu!~;CFbr!{ZTg6%P z43f*Tn7_Ui5h-Xm6$-a{(VJH2^i^4*CF9Qm16NyrehHxq^xE*AuvF#_hw;Si_7rV* z-HDWW$_u|f@2MZQRorW;Wp70vBFp?azuSy*6zG8Ow{O|l#nhQCXzAv13Jv5--D;A} z5!1$Z;<7j-*r1Mug2m^N7K?2j&o7>0)+w`9QDsZhR9@SN&KoHp;HFUkI|% zjX;=bPjK`U`Q%2VHMK|>!of;Qc#vrPboD#rrUOyzark9Q?X3_eq^+>Yh~cN>!OAh? zE8}fk?QHTax(n)g7!DR2bm~{>gM~g%uYf)~o>ZLqYdhD++Fu~Nw8&I5CV=)M8cj)+ zcZ4h*%@=x)Y=1oZiZ z9jyrh-cRgAi#JaT12pP}IzpGo5a^(jl+JT-DF!mcDK#%VhgA`%IC+`*(Wn|m64i6Q zFpKa?Ce=3ZZ6_Gd1=)c_`!Drx_tA$(%(8}j?~wY%#7ECR45C=diXQW1sfrdvmf!qv zplsE~1;m*B2iY|6DOd{Fgg3Ji{z}0)>K+1NjHE&m@yV57d^3J=Xsvv$oS#x|%^3LL zB08Tiz#S-O*WyVon2OjAMq<>glx&n{RyP9@!1O(j7HDjmtoLKK#_Z@_YYJruV4k(w v;@U;tf0wg{T0`+uP*I+TlVzz9Q}37SkJJBF;g4V({5(T9IGPgXnV9|!nmSSx diff --git a/src/nix-vector-routing/doc/nix-vector-routing.h b/src/nix-vector-routing/doc/nix-vector-routing.h deleted file mode 100644 index f3fca4e15ec..00000000000 --- a/src/nix-vector-routing/doc/nix-vector-routing.h +++ /dev/null @@ -1,52 +0,0 @@ -/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ -/* - * Copyright (c) 2009 The Georgia Institute of Technology - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation; - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Authors: Josh Pelkey - */ - -/** - * \defgroup nix-vector-routing Nix-Vector Routing - * - * \section model Model - * - * Nix-vector routing is a simulation specific routing protocol and is - * intended for large network topologies. The on-demand nature of this - * protocol as well as the low-memory footprint of the nix-vector provides - * improved performance in terms of memory usage and simulation run time - * when dealing with a large number of nodes. - * - * Currently, the ns-3 model of nix-vector routing supports IPv4 p2p links - * as well as CSMA links. It does not (yet) provide support for - * efficient adaptation to link failures. It simply flushes all nix-vector - * routing caches. Finally, IPv6 is not supported. - * - * \section impl Implementation - * - * ns-3 nix-vector-routing performs on-demand route computation using - * a breadth-first search and an efficient route-storage data structure - * known as a nix-vector. When a packet is generated at a node for - * transmission, the route is calculated, and the nix-vector is built. - * The nix-vector stores an index for each hop along the path, which - * corresponds to the neighbor-index. This index is used to determine - * which net-device and gateway should be used. To route a packet, the - * nix-vector must be transmitted with the packet. At each hop, the - * current node extracts the appropriate neighbor-index from the - * nix-vector and transmits the packet through the corresponding - * net-device. This continues until the packet reaches the destination. - * - */ - diff --git a/src/nix-vector-routing/doc/nix-vector-routing.rst b/src/nix-vector-routing/doc/nix-vector-routing.rst new file mode 100644 index 00000000000..83b35f4338b --- /dev/null +++ b/src/nix-vector-routing/doc/nix-vector-routing.rst @@ -0,0 +1,63 @@ +Nix-Vector Routing Documentation +-------------------------------- + +.. include:: replace.txt +.. highlight:: cpp + +.. heading hierarchy: + ------------- Chapter + ************* Section (#.#) + ============= Subsection (#.#.#) + ############# Paragraph (no number) + + +Nix-vector routing is a simulation specific routing protocol and is +intended for large network topologies. The on-demand nature of this +protocol as well as the low-memory footprint of the nix-vector provides +improved performance in terms of memory usage and simulation run time +when dealing with a large number of nodes. + +Model Description +***************** + +The source code for the NixVectorRouting module lives in +the directory ``src/nix-vector-routing``. + +|ns3| nix-vector-routing performs on-demand route computation using +a breadth-first search and an efficient route-storage data structure +known as a nix-vector. + +When a packet is generated at a node for transmission, the route is +calculated, and the nix-vector is built. +The nix-vector stores an index for each hop along the path, which +corresponds to the neighbor-index. This index is used to determine +which net-device and gateway should be used. To route a packet, the +nix-vector must be transmitted with the packet. At each hop, the +current node extracts the appropriate neighbor-index from the +nix-vector and transmits the packet through the corresponding +net-device. This continues until the packet reaches the destination. + +Scope and Limitations +===================== + +Currently, the ns-3 model of nix-vector routing supports IPv4 p2p links +as well as CSMA links. It does not (yet) provide support for +efficient adaptation to link failures. It simply flushes all nix-vector +routing caches. Finally, IPv6 is not supported. + + +Usage +***** + +The usage pattern is the one of all the Internet routing protocols. +Since NixVectorRouting is not installed by default in the +Internet stack, it is necessary to set it in the Internet Stack +helper by using ``InternetStackHelper::SetRoutingHelper`` + + +Examples +======== + +The examples for the NixVectorRouting module lives in +the directory ``src/nix-vector-routing/examples``. + diff --git a/src/nix-vector-routing/model/ipv4-nix-vector-routing.h b/src/nix-vector-routing/model/ipv4-nix-vector-routing.h index fb793be4565..a2e2aa1dd2d 100644 --- a/src/nix-vector-routing/model/ipv4-nix-vector-routing.h +++ b/src/nix-vector-routing/model/ipv4-nix-vector-routing.h @@ -35,6 +35,13 @@ namespace ns3 { +/** + * \defgroup nix-vector-routing Nix-Vector Routing + * + * Nix-vector routing is a simulation specific routing protocol and is + * intended for large network topologies. + */ + /** * \ingroup nix-vector-routing * Map of Ipv4Address to NixVector diff --git a/src/olsr/doc/olsr.rst b/src/olsr/doc/olsr.rst index 3c82c595676..647bb372599 100644 --- a/src/olsr/doc/olsr.rst +++ b/src/olsr/doc/olsr.rst @@ -47,6 +47,41 @@ The usage pattern is the one of all the Internet routing protocols. Since OLSR is not installed by default in the Internet stack, it is necessary to set it in the Internet Stack helper by using ``InternetStackHelper::SetRoutingHelper`` +Typically, OLSR is enabled in a main program by use of an OlsrHelper class that +installs OLSR into an Ipv4ListRoutingProtocol object. The following sample +commands will enable OLSR in a simulation using this helper class along with +some other routing helper objects. The setting of priority value 10, ahead of +the staticRouting priority of 0, means that OLSR will be consulted for a route +before the node's static routing table.:: + + NodeContainer c: + ... + // Enable OLSR + NS_LOG_INFO ("Enabling OLSR Routing."); + OlsrHelper olsr; + + Ipv4StaticRoutingHelper staticRouting; + + Ipv4ListRoutingHelper list; + list.Add (staticRouting, 0); + list.Add (olsr, 10); + + InternetStackHelper internet; + internet.SetRoutingHelper (list); + internet.Install (c); + +Once installed,the OLSR "main interface" can be set with the SetMainInterface() +command. If the user does not specify a main address, the protocol will select +the first primary IP address that it finds, starting first the loopback +interface and then the next non-loopback interface found, in order of Ipv4 +interface index. The loopback address of 127.0.0.1 is not selected. In addition, +a number of protocol constants are defined in olsr-routing-protocol.cc. + +Olsr is started at time zero of the simulation, based on a call to +Object::Start() that eventually calls OlsrRoutingProtocol::DoStart(). Note: a +patch to allow the user to start and stop the protocol at other times would be +welcome. + Examples ++++++++ @@ -94,6 +129,11 @@ The available traces are: Caveats +++++++ +Presently, OLSR is limited to use with an Ipv4ListRouting object, and does not +respond to dynamic changes to a device's IP address or link up/down +notifications; i.e. the topology changes are due to loss/gain of connectivity +over a wireless channel. + The code does not present any known issue. Validation From e0e9127c6d62e439e8939eead808f0f677daf163 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 1 Jun 2017 14:06:54 +0300 Subject: [PATCH 074/551] lte: Comment fix: s/expec/expect/ --- src/lte/helper/lte-helper.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index bedc6041045..fa5717b060f 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -835,7 +835,7 @@ class LteHelper : public Object /** * The `UseCa` attribute. If true, Carrier Aggregation is enabled. - * Hence, the helper will expec a valid component carrier map + * Hence, the helper will expect a valid component carrier map * If it is false, the component carrier will be created within the LteHelper * this is to mantain the backwards compatibility with user script */ From dcb699890072b74020ef8ee5f539c5c62d4a92ff Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 1 Jun 2017 14:35:49 +0300 Subject: [PATCH 075/551] lte: Make EARFCN variables 32-bit in lte-test-earfcn.cc --- src/lte/test/lte-test-earfcn.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/lte/test/lte-test-earfcn.cc b/src/lte/test/lte-test-earfcn.cc index 2d0fc2ccfd8..53e2a79e669 100644 --- a/src/lte/test/lte-test-earfcn.cc +++ b/src/lte/test/lte-test-earfcn.cc @@ -47,18 +47,18 @@ class LteEarfcnTestCase : public TestCase * \param earfcn EARFCN * \param f frequency */ - LteEarfcnTestCase (const char* str, uint16_t earfcn, double f); + LteEarfcnTestCase (const char* str, uint32_t earfcn, double f); virtual ~LteEarfcnTestCase (); protected: - uint16_t m_earfcn; ///< the EARFCN + uint32_t m_earfcn; ///< the EARFCN double m_f; ///< the frequency private: virtual void DoRun (void); }; -LteEarfcnTestCase::LteEarfcnTestCase (const char* str, uint16_t earfcn, double f) +LteEarfcnTestCase::LteEarfcnTestCase (const char* str, uint32_t earfcn, double f) : TestCase (str), m_earfcn (earfcn), m_f (f) @@ -96,13 +96,13 @@ class LteEarfcnDlTestCase : public LteEarfcnTestCase * \param earfcn EARFCN * \param f frequency */ - LteEarfcnDlTestCase (const char* str, uint16_t earfcn, double f); + LteEarfcnDlTestCase (const char* str, uint32_t earfcn, double f); private: virtual void DoRun (void); }; -LteEarfcnDlTestCase::LteEarfcnDlTestCase (const char* str, uint16_t earfcn, double f) +LteEarfcnDlTestCase::LteEarfcnDlTestCase (const char* str, uint32_t earfcn, double f) : LteEarfcnTestCase (str, earfcn, f) { } @@ -137,13 +137,13 @@ class LteEarfcnUlTestCase : public LteEarfcnTestCase * \param earfcn EARFCN * \param f frequency */ - LteEarfcnUlTestCase (const char* str, uint16_t earfcn, double f); + LteEarfcnUlTestCase (const char* str, uint32_t earfcn, double f); private: virtual void DoRun (void); }; -LteEarfcnUlTestCase::LteEarfcnUlTestCase (const char* str, uint16_t earfcn, double f) +LteEarfcnUlTestCase::LteEarfcnUlTestCase (const char* str, uint32_t earfcn, double f) : LteEarfcnTestCase (str, earfcn, f) { } From 1795aa0ed8b2bbaa16163c62cde4a48df3e52d06 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 1 Jun 2017 14:36:19 +0300 Subject: [PATCH 076/551] =?UTF-8?q?lte:=20Typo=20fix:=20"freuquencies"=20?= =?UTF-8?q?=E2=86=92=20"frequencies"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lte/test/lte-test-earfcn.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/test/lte-test-earfcn.cc b/src/lte/test/lte-test-earfcn.cc index 53e2a79e669..f8e1c92059d 100644 --- a/src/lte/test/lte-test-earfcn.cc +++ b/src/lte/test/lte-test-earfcn.cc @@ -160,7 +160,7 @@ LteEarfcnUlTestCase::DoRun (void) * \ingroup lte-test * \ingroup tests * - * \brief Test suite for testing correct conversion of freuquencies in + * \brief Test suite for testing correct conversion of frequencies in * the downlink and the uplink, and general EARFCN frequencies. */ class LteEarfcnTestSuite : public TestSuite From c4e725e55e5d5bc0e6c8f59d0998db173aea3098 Mon Sep 17 00:00:00 2001 From: "Peter D. Barnes, Jr." Date: Thu, 1 Jun 2017 16:27:30 -0700 Subject: [PATCH 077/551] bug 2736: revert from r11086 --- src/network/model/node.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/network/model/node.cc b/src/network/model/node.cc index 8b251cf4ce6..5e8571f1b46 100644 --- a/src/network/model/node.cc +++ b/src/network/model/node.cc @@ -67,7 +67,7 @@ Node::GetTypeId (void) MakeUintegerAccessor (&Node::m_id), MakeUintegerChecker ()) .AddAttribute ("SystemId", "The systemId of this node: a unique integer used for parallel simulations.", - TypeId::ATTR_GET || TypeId::ATTR_SET, + TypeId::ATTR_GET | TypeId::ATTR_SET, UintegerValue (0), MakeUintegerAccessor (&Node::m_sid), MakeUintegerChecker ()) From 25c3a567e14fcc8328ee3a1ec7b20a331bac8a48 Mon Sep 17 00:00:00 2001 From: "Peter D. Barnes, Jr." Date: Thu, 1 Jun 2017 16:57:22 -0700 Subject: [PATCH 078/551] fix buffer underflow warning from gcc-7 --- .../model/snr-to-block-error-rate-manager.cc | 45 +++++++++---------- .../model/snr-to-block-error-rate-manager.h | 4 +- 2 files changed, 23 insertions(+), 26 deletions(-) diff --git a/src/wimax/model/snr-to-block-error-rate-manager.cc b/src/wimax/model/snr-to-block-error-rate-manager.cc index 58534e7aad8..b44427ca8e6 100644 --- a/src/wimax/model/snr-to-block-error-rate-manager.cc +++ b/src/wimax/model/snr-to-block-error-rate-manager.cc @@ -26,6 +26,7 @@ #include "ns3/log.h" #include "ns3/assert.h" #include +#include namespace ns3 { @@ -39,7 +40,7 @@ SNRToBlockErrorRateManager::SNRToBlockErrorRateManager (void) m_recordModulation[i] = new std::vector (); } m_activateLoss = false; - std::strcpy (m_traceFilePath,"DefaultTraces"); + m_traceFilePath = "DefaultTraces"; } SNRToBlockErrorRateManager::~SNRToBlockErrorRateManager (void) @@ -79,25 +80,25 @@ SNRToBlockErrorRateManager::ActivateLoss (bool loss) void SNRToBlockErrorRateManager::LoadTraces (void) { - std::ifstream m_ifTraceFile; + std::ifstream traceFile; ClearRecords (); double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2; for (int i = 0; i < 7; i++) { - char traceFile[1024]; - sprintf (traceFile, "%s/modulation%d.txt", m_traceFilePath, i); + std::stringstream traceFilePath; + traceFilePath << m_traceFilePath << "/modulation" << i << ".txt"; - m_ifTraceFile.open (traceFile, std::ifstream::in); - if (m_ifTraceFile.good () == false) + traceFile.open (traceFilePath.str ().c_str (), std::ifstream::in); + if (traceFile.good () == false) { - NS_LOG_INFO ("Unable to load " << traceFile << "!! Loading default traces..."); + NS_LOG_INFO ("Unable to load " << traceFilePath.str () << "!! Loading default traces..."); LoadDefaultTraces (); return; } - while (m_ifTraceFile.good ()) + while (traceFile.good ()) { - m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2; + traceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2; SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue, bitErrorRate, burstErrorRate, @@ -107,7 +108,7 @@ SNRToBlockErrorRateManager::LoadTraces (void) m_recordModulation[i]->push_back (record); } - m_ifTraceFile.close (); + traceFile.close (); } m_activateLoss = true; } @@ -239,23 +240,23 @@ SNRToBlockErrorRateManager::ReLoadTraces (void) ClearRecords (); - std::ifstream m_ifTraceFile; + std::ifstream traceFile; for (int i = 0; i < 7; i++) { - char traceFile[1024]; - sprintf (traceFile, "%s/Modulation%d.txt", m_traceFilePath, i); + std::stringstream traceFilePath; + traceFilePath << m_traceFilePath << "/Modulation" << i << ".txt"; - m_ifTraceFile.open (traceFile, std::ifstream::in); - if (m_ifTraceFile.good () == false) + traceFile.open (traceFilePath.str ().c_str (), std::ifstream::in); + if (traceFile.good () == false) { - NS_LOG_INFO ("Unable to load " << traceFile << "!!Loading default traces..."); + NS_LOG_INFO ("Unable to load " << traceFilePath.str () << "!!Loading default traces..."); LoadDefaultTraces (); return; } - while (m_ifTraceFile.good ()) + while (traceFile.good ()) { - m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2; + traceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2; SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue, bitErrorRate, burstErrorRate, @@ -266,7 +267,7 @@ SNRToBlockErrorRateManager::ReLoadTraces (void) m_recordModulation[i]->push_back (record); } - m_ifTraceFile.close (); + traceFile.close (); } m_activateLoss = true; } @@ -274,15 +275,13 @@ SNRToBlockErrorRateManager::ReLoadTraces (void) void SNRToBlockErrorRateManager::SetTraceFilePath (char *traceFilePath) { - NS_ASSERT_MSG (std::strlen (traceFilePath) < TRACE_FILE_PATH_SIZE, - "char * traceFilePath too long"); - std::strcpy (m_traceFilePath, traceFilePath); + m_traceFilePath = traceFilePath; } std::string SNRToBlockErrorRateManager::GetTraceFilePath (void) { - return (std::string (m_traceFilePath)); + return m_traceFilePath; } double diff --git a/src/wimax/model/snr-to-block-error-rate-manager.h b/src/wimax/model/snr-to-block-error-rate-manager.h index 73b274877d3..a9b68d3fe1a 100644 --- a/src/wimax/model/snr-to-block-error-rate-manager.h +++ b/src/wimax/model/snr-to-block-error-rate-manager.h @@ -104,9 +104,7 @@ class SNRToBlockErrorRateManager /// Clear records function void ClearRecords (void); uint8_t m_activateLoss; ///< activate loss - /// trace file path size - static const unsigned int TRACE_FILE_PATH_SIZE = 1024; - char m_traceFilePath[TRACE_FILE_PATH_SIZE]; ///< trace file path + std::string m_traceFilePath; ///< trace file path std::vector * m_recordModulation[7]; ///< record modulation From d5b7812381c95fa93c82682febed827438c3afa5 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Fri, 2 Jun 2017 14:45:29 +0200 Subject: [PATCH 079/551] lte: Additional doxygen corrections (patch set 5) --- .../helper/radio-bearer-stats-calculator.h | 1 + .../helper/radio-bearer-stats-connector.cc | 44 +++++++------- src/lte/helper/radio-bearer-stats-connector.h | 4 ++ src/lte/model/a2-a4-rsrq-handover-algorithm.h | 2 +- src/lte/model/a3-rsrp-handover-algorithm.h | 2 +- src/lte/model/component-carrier-enb.h | 8 +-- src/lte/model/component-carrier-ue.h | 2 +- src/lte/model/cqa-ff-mac-scheduler.h | 2 + src/lte/model/epc-enb-application.h | 2 + src/lte/model/epc-mme.h | 2 + src/lte/model/epc-s11-sap.h | 1 + src/lte/model/epc-sgw-pgw-application.h | 1 + src/lte/model/epc-ue-nas.h | 1 + src/lte/model/epc-x2.h | 1 + src/lte/model/eps-bearer-tag.h | 11 ++-- src/lte/model/fdbet-ff-mac-scheduler.h | 2 + src/lte/model/fdmt-ff-mac-scheduler.h | 2 + src/lte/model/fdtbfq-ff-mac-scheduler.h | 2 + src/lte/model/lte-anr.h | 8 ++- src/lte/model/lte-ccm-rrc-sap.h | 3 + src/lte/model/lte-common.h | 6 +- src/lte/model/lte-enb-mac.h | 6 ++ src/lte/model/lte-enb-phy.h | 5 ++ src/lte/model/lte-enb-rrc.h | 58 +++++++++++++++--- src/lte/model/lte-ffr-distributed-algorithm.h | 3 +- src/lte/model/lte-ffr-enhanced-algorithm.cc | 4 +- src/lte/model/lte-ffr-enhanced-algorithm.h | 3 +- src/lte/model/lte-ffr-rrc-sap.h | 2 + src/lte/model/lte-ffr-sap.h | 8 ++- src/lte/model/lte-ffr-soft-algorithm.cc | 4 +- src/lte/model/lte-ffr-soft-algorithm.h | 3 +- src/lte/model/lte-fr-hard-algorithm.cc | 4 +- src/lte/model/lte-fr-hard-algorithm.h | 3 +- src/lte/model/lte-fr-no-op-algorithm.h | 3 +- src/lte/model/lte-fr-soft-algorithm.cc | 4 +- src/lte/model/lte-fr-soft-algorithm.h | 3 +- src/lte/model/lte-fr-strict-algorithm.cc | 4 +- src/lte/model/lte-fr-strict-algorithm.h | 3 +- src/lte/model/lte-net-device.h | 5 +- src/lte/model/lte-pdcp-tag.h | 1 + src/lte/model/lte-pdcp.h | 2 + src/lte/model/lte-phy-tag.h | 1 + src/lte/model/lte-radio-bearer-tag.h | 5 ++ src/lte/model/lte-rlc-sap.h | 6 +- src/lte/model/lte-rlc-sequence-number.h | 59 +++++++++++++++---- src/lte/model/lte-rlc-tag.h | 3 +- src/lte/model/lte-rlc.h | 2 + src/lte/model/lte-rrc-protocol-ideal.h | 2 + src/lte/model/lte-rrc-protocol-real.h | 7 +++ src/lte/model/lte-rrc-sap.h | 25 +++++--- src/lte/model/lte-spectrum-phy.h | 1 + .../model/lte-spectrum-signal-parameters.h | 4 ++ src/lte/model/lte-ue-ccm-rrc-sap.h | 1 + .../model/lte-ue-component-carrier-manager.h | 2 + src/lte/model/lte-ue-mac.h | 3 + src/lte/model/lte-ue-phy.h | 5 ++ src/lte/model/lte-ue-rrc.h | 32 ++++++++-- .../model/no-op-component-carrier-manager.h | 4 ++ src/lte/model/no-op-handover-algorithm.h | 2 +- src/lte/model/pf-ff-mac-scheduler.h | 2 + src/lte/model/pss-ff-mac-scheduler.h | 2 + src/lte/model/rr-ff-mac-scheduler.h | 2 + .../simple-ue-component-carrier-manager.h | 4 +- src/lte/model/tdbet-ff-mac-scheduler.h | 2 + src/lte/model/tdmt-ff-mac-scheduler.h | 2 + src/lte/model/tdtbfq-ff-mac-scheduler.h | 2 + src/lte/model/tta-ff-mac-scheduler.h | 2 + src/lte/test/lte-ffr-simple.h | 3 +- src/lte/test/lte-test-cell-selection.h | 3 + src/lte/test/lte-test-cqi-generation.h | 6 +- src/lte/test/lte-test-downlink-sinr.h | 14 +++++ src/lte/test/lte-test-entities.h | 16 ++++- 72 files changed, 362 insertions(+), 97 deletions(-) diff --git a/src/lte/helper/radio-bearer-stats-calculator.h b/src/lte/helper/radio-bearer-stats-calculator.h index b1298c8e383..dc4eda15b37 100644 --- a/src/lte/helper/radio-bearer-stats-calculator.h +++ b/src/lte/helper/radio-bearer-stats-calculator.h @@ -77,6 +77,7 @@ class RadioBearerStatsCalculator : public LteStatsCalculator /** * Class constructor + * \param protocolType the name of the protocol type */ RadioBearerStatsCalculator (std::string protocolType); diff --git a/src/lte/helper/radio-bearer-stats-connector.cc b/src/lte/helper/radio-bearer-stats-connector.cc index 2514db6aaa8..db2f2d3f0db 100644 --- a/src/lte/helper/radio-bearer-stats-connector.cc +++ b/src/lte/helper/radio-bearer-stats-connector.cc @@ -58,11 +58,11 @@ struct BoundCallbackArgument : public SimpleRefCount /** * Callback function for DL TX statistics for both RLC and PDCP - * /param arg - * /param path - * /param rnti - * /param lcid - * /param packetSize + * \param arg + * \param path + * \param rnti + * \param lcid + * \param packetSize */ void DlTxPduCallback (Ptr arg, std::string path, @@ -74,12 +74,12 @@ DlTxPduCallback (Ptr arg, std::string path, /** * Callback function for DL RX statistics for both RLC and PDCP - * /param arg - * /param path - * /param rnti - * /param lcid - * /param packetSize - * /param delay + * \param arg + * \param path + * \param rnti + * \param lcid + * \param packetSize + * \param delay */ void DlRxPduCallback (Ptr arg, std::string path, @@ -91,11 +91,11 @@ DlRxPduCallback (Ptr arg, std::string path, /** * Callback function for UL TX statistics for both RLC and PDCP - * /param arg - * /param path - * /param rnti - * /param lcid - * /param packetSize + * \param arg + * \param path + * \param rnti + * \param lcid + * \param packetSize */ void UlTxPduCallback (Ptr arg, std::string path, @@ -108,12 +108,12 @@ UlTxPduCallback (Ptr arg, std::string path, /** * Callback function for UL RX statistics for both RLC and PDCP - * /param arg - * /param path - * /param rnti - * /param lcid - * /param packetSize - * /param delay + * \param arg + * \param path + * \param rnti + * \param lcid + * \param packetSize + * \param delay */ void UlRxPduCallback (Ptr arg, std::string path, diff --git a/src/lte/helper/radio-bearer-stats-connector.h b/src/lte/helper/radio-bearer-stats-connector.h index 8a2b9fafd13..b00681a3c33 100644 --- a/src/lte/helper/radio-bearer-stats-connector.h +++ b/src/lte/helper/radio-bearer-stats-connector.h @@ -278,6 +278,10 @@ class RadioBearerStatsConnector /** * Less than operator for CellIdRnti, because it is used as key in map + * + * \param a the lhs operand + * \param b the rhs operand + * \returns true if less than */ friend bool operator < (const CellIdRnti &a, const CellIdRnti &b); diff --git a/src/lte/model/a2-a4-rsrq-handover-algorithm.h b/src/lte/model/a2-a4-rsrq-handover-algorithm.h index 9787af65f83..c7e6943edb5 100644 --- a/src/lte/model/a2-a4-rsrq-handover-algorithm.h +++ b/src/lte/model/a2-a4-rsrq-handover-algorithm.h @@ -95,7 +95,7 @@ class A2A4RsrqHandoverAlgorithm : public LteHandoverAlgorithm virtual void SetLteHandoverManagementSapUser (LteHandoverManagementSapUser* s); virtual LteHandoverManagementSapProvider* GetLteHandoverManagementSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteHandoverManagementSapProvider; protected: diff --git a/src/lte/model/a3-rsrp-handover-algorithm.h b/src/lte/model/a3-rsrp-handover-algorithm.h index 889bb2024fb..a0f58d0ad83 100644 --- a/src/lte/model/a3-rsrp-handover-algorithm.h +++ b/src/lte/model/a3-rsrp-handover-algorithm.h @@ -80,7 +80,7 @@ class A3RsrpHandoverAlgorithm : public LteHandoverAlgorithm virtual void SetLteHandoverManagementSapUser (LteHandoverManagementSapUser* s); virtual LteHandoverManagementSapProvider* GetLteHandoverManagementSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteHandoverManagementSapProvider; protected: diff --git a/src/lte/model/component-carrier-enb.h b/src/lte/model/component-carrier-enb.h index 382b6172af4..7b4b6ae733c 100644 --- a/src/lte/model/component-carrier-enb.h +++ b/src/lte/model/component-carrier-enb.h @@ -80,24 +80,24 @@ class ComponentCarrierEnb : public ComponentCarrier Ptr GetFfMacScheduler (); /** * Set the LteEnbPhy - * \ param s a pointer to the LteEnbPhy + * \param s a pointer to the LteEnbPhy */ void SetPhy (Ptr s); /** * Set the LteEnbMac - * \ param s a pointer to the LteEnbMac + * \param s a pointer to the LteEnbMac */ void SetMac (Ptr s); /** * Set the FfMacScheduler Algorithm - * \ param s a pointer to the FfMacScheduler + * \param s a pointer to the FfMacScheduler */ void SetFfMacScheduler (Ptr s); /** * Set the LteFfrAlgorithm - * \ param s a pointer to the LteFfrAlgorithm + * \param s a pointer to the LteFfrAlgorithm */ void SetFfrAlgorithm (Ptr s); diff --git a/src/lte/model/component-carrier-ue.h b/src/lte/model/component-carrier-ue.h index e60c719c2b0..fd66780f0f9 100644 --- a/src/lte/model/component-carrier-ue.h +++ b/src/lte/model/component-carrier-ue.h @@ -70,7 +70,7 @@ class ComponentCarrierUe : public ComponentCarrier /** * Set the LteEnbMac - * \ param s a pointer to the LteEnbMac + * \param s a pointer to the LteEnbMac */ void SetMac (Ptr s); diff --git a/src/lte/model/cqa-ff-mac-scheduler.h b/src/lte/model/cqa-ff-mac-scheduler.h index 34fca716c85..ba895769c3b 100644 --- a/src/lte/model/cqa-ff-mac-scheduler.h +++ b/src/lte/model/cqa-ff-mac-scheduler.h @@ -111,7 +111,9 @@ class CqaFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/epc-enb-application.h b/src/lte/model/epc-enb-application.h index 96111081681..2a5a1b4562f 100644 --- a/src/lte/model/epc-enb-application.h +++ b/src/lte/model/epc-enb-application.h @@ -49,7 +49,9 @@ class EpcEnbS1SapProvider; class EpcEnbApplication : public Application { + /// allow MemberEpcEnbS1SapProvider class friend access friend class MemberEpcEnbS1SapProvider; + /// allow MemberEpcS1apSapEnb class friend access friend class MemberEpcS1apSapEnb; diff --git a/src/lte/model/epc-mme.h b/src/lte/model/epc-mme.h index 71adcfca3bb..dc7d1dfce40 100644 --- a/src/lte/model/epc-mme.h +++ b/src/lte/model/epc-mme.h @@ -40,7 +40,9 @@ class NetDevice; class EpcMme : public Object { + /// allow MemberEpcS1apSapMme class friend access friend class MemberEpcS1apSapMme; + /// allow MemberEpcS11SapMme class friend access friend class MemberEpcS11SapMme; public: diff --git a/src/lte/model/epc-s11-sap.h b/src/lte/model/epc-s11-sap.h index f97981383e0..b407a213000 100644 --- a/src/lte/model/epc-s11-sap.h +++ b/src/lte/model/epc-s11-sap.h @@ -210,6 +210,7 @@ class EpcS11SapSgw : public EpcS11Sap /** * \brief As per 3GPP TS 29.274 Release 9 V9.3.0, a Delete Bearer Command message shall be sent on the S11 interface by the MME to the SGW + * \param msg the DeleteBearerCommandMessage */ virtual void DeleteBearerCommand (DeleteBearerCommandMessage msg) = 0; diff --git a/src/lte/model/epc-sgw-pgw-application.h b/src/lte/model/epc-sgw-pgw-application.h index 3c03c42f121..064cac6af9a 100644 --- a/src/lte/model/epc-sgw-pgw-application.h +++ b/src/lte/model/epc-sgw-pgw-application.h @@ -47,6 +47,7 @@ namespace ns3 { */ class EpcSgwPgwApplication : public Application { + /// allow MemberEpcS11SapSgw class friend access friend class MemberEpcS11SapSgw; public: diff --git a/src/lte/model/epc-ue-nas.h b/src/lte/model/epc-ue-nas.h index c68e8d23ac9..175f1be79bb 100644 --- a/src/lte/model/epc-ue-nas.h +++ b/src/lte/model/epc-ue-nas.h @@ -33,6 +33,7 @@ class EpcHelper; class EpcUeNas : public Object { + /// allow MemberLteAsSapUser class friend access friend class MemberLteAsSapUser; public: diff --git a/src/lte/model/epc-x2.h b/src/lte/model/epc-x2.h index a61194ebd84..57569a5789f 100644 --- a/src/lte/model/epc-x2.h +++ b/src/lte/model/epc-x2.h @@ -98,6 +98,7 @@ class X2CellInfo : public SimpleRefCount */ class EpcX2 : public Object { + /// allow EpcX2SpecificEpcX2SapProvider class friend access friend class EpcX2SpecificEpcX2SapProvider; public: diff --git a/src/lte/model/eps-bearer-tag.h b/src/lte/model/eps-bearer-tag.h index f0284e87ec5..2f93c845453 100644 --- a/src/lte/model/eps-bearer-tag.h +++ b/src/lte/model/eps-bearer-tag.h @@ -50,6 +50,9 @@ class EpsBearerTag : public Tag /** * Create a EpsBearerTag with the given RNTI and bearer id + * + * @param rnti the value of the RNTI to set + * @param bid the value of the Bearer Id to set */ EpsBearerTag (uint16_t rnti, uint8_t bid); @@ -63,7 +66,7 @@ class EpsBearerTag : public Tag /** * Set the bearer id to the given value. * - * @param bid the value of the RNTI to set + * @param bid the value of the Bearer Id to set */ void SetBid (uint8_t bid); @@ -78,14 +81,14 @@ class EpsBearerTag : public Tag */ uint16_t GetRnti (void) const; /** - * Get bid function - * \returns the bid + * Get Bearer Id function + * \returns the Bearer Id */ uint8_t GetBid (void) const; private: uint16_t m_rnti; ///< RNTI value - uint8_t m_bid; ///< bid value + uint8_t m_bid; ///< Bearer Id value }; diff --git a/src/lte/model/fdbet-ff-mac-scheduler.h b/src/lte/model/fdbet-ff-mac-scheduler.h index ad17457b149..8527e56818e 100644 --- a/src/lte/model/fdbet-ff-mac-scheduler.h +++ b/src/lte/model/fdbet-ff-mac-scheduler.h @@ -103,7 +103,9 @@ class FdBetFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/fdmt-ff-mac-scheduler.h b/src/lte/model/fdmt-ff-mac-scheduler.h index f783af358d4..8742540383a 100644 --- a/src/lte/model/fdmt-ff-mac-scheduler.h +++ b/src/lte/model/fdmt-ff-mac-scheduler.h @@ -98,7 +98,9 @@ class FdMtFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider clss friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/fdtbfq-ff-mac-scheduler.h b/src/lte/model/fdtbfq-ff-mac-scheduler.h index df1950b67f9..8616aedf35b 100644 --- a/src/lte/model/fdtbfq-ff-mac-scheduler.h +++ b/src/lte/model/fdtbfq-ff-mac-scheduler.h @@ -137,7 +137,9 @@ class FdTbfqFfMacScheduler : public FfMacScheduler */ virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider claass friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/lte-anr.h b/src/lte/model/lte-anr.h index 19fcc2e402d..9ccca27f65b 100644 --- a/src/lte/model/lte-anr.h +++ b/src/lte/model/lte-anr.h @@ -135,7 +135,7 @@ class LteAnr : public Object */ virtual LteAnrSapProvider* GetLteAnrSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteAnrSapProvider; protected: @@ -220,7 +220,11 @@ class LteAnr : public Object /// neighbor relation table NeighbourRelationTable_t m_neighbourRelationTable; - /// internal methods + /** + * \internal methods + * \param cellId + * \returns the neighbor relation + */ const NeighbourRelation_t* Find (uint16_t cellId) const; /// The expected measurement identity diff --git a/src/lte/model/lte-ccm-rrc-sap.h b/src/lte/model/lte-ccm-rrc-sap.h index e6dd1ccf90a..c2e4601a656 100644 --- a/src/lte/model/lte-ccm-rrc-sap.h +++ b/src/lte/model/lte-ccm-rrc-sap.h @@ -46,7 +46,9 @@ namespace ns3 { class LteCcmRrcSapProvider { +/// allow UeManager class friend access friend class UeManager; +/// allow LteMacSapUser class friend access friend class LteMacSapUser; public: @@ -148,6 +150,7 @@ friend class LteMacSapUser; */ class LteCcmRrcSapUser { + /// allow LteEnbRrc class friend access friend class LteEnbRrc; public: virtual ~LteCcmRrcSapUser (); diff --git a/src/lte/model/lte-common.h b/src/lte/model/lte-common.h index daf231ab847..903b5a25f3b 100644 --- a/src/lte/model/lte-common.h +++ b/src/lte/model/lte-common.h @@ -173,7 +173,11 @@ class BufferSizeLevelBsr class TransmissionModesLayers { public: - /// Transmit mode 2 layer number + /** + * Transmit mode 2 layer number + * \param txMode the transmit mode + * \returns the layer 2 number + */ static uint8_t TxMode2LayerNum (uint8_t txMode); }; diff --git a/src/lte/model/lte-enb-mac.h b/src/lte/model/lte-enb-mac.h index e4515741b8c..aaf9634f4a1 100644 --- a/src/lte/model/lte-enb-mac.h +++ b/src/lte/model/lte-enb-mac.h @@ -54,11 +54,17 @@ typedef std::vector > > DlHarqProcessesBuffer_t; */ class LteEnbMac : public Object { + /// allow EnbMacMemberLteEnbCmacSapProvider class friend access friend class EnbMacMemberLteEnbCmacSapProvider; + /// allow EnbMacMemberLteMacSapProvider class friend access friend class EnbMacMemberLteMacSapProvider; + /// allow EnbMacMemberFfMacSchedSapUser class friend access friend class EnbMacMemberFfMacSchedSapUser; + /// allow EnbMacMemberFfMacCschedSapUser class friend access friend class EnbMacMemberFfMacCschedSapUser; + /// allow EnbMacMemberLteEnbPhySapUser class friend access friend class EnbMacMemberLteEnbPhySapUser; + /// allow MemberLteCcmMacSapProvider class friend ccess friend class MemberLteCcmMacSapProvider; public: diff --git a/src/lte/model/lte-enb-phy.h b/src/lte/model/lte-enb-phy.h index 14349cf6f09..96809b7154c 100644 --- a/src/lte/model/lte-enb-phy.h +++ b/src/lte/model/lte-enb-phy.h @@ -46,7 +46,9 @@ class LteUePhy; */ class LteEnbPhy : public LtePhy { + /// allow EnbMemberLteEnbPhySapProvider class friend access friend class EnbMemberLteEnbPhySapProvider; + /// allow MemberLteEnbCphySapProvider class friend access friend class MemberLteEnbCphySapProvider; public: @@ -185,11 +187,13 @@ class LteEnbPhy : public LtePhy /** * \brief Create the PSD for TX + * \returns the PSD */ virtual Ptr CreateTxPowerSpectralDensity (); /** * \brief Create the PSD for TX with power allocation for each RB + * \return the PSD */ virtual Ptr CreateTxPowerSpectralDensityWithPowerAllocation (); @@ -264,6 +268,7 @@ class LteEnbPhy : public LtePhy /** * \brief PhySpectrum received a new PHY-PDU + * \param p the packet received */ void PhyPduReceived (Ptr p); diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 41f8ef58cc7..ba08c19074b 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -71,6 +71,7 @@ class Packet; */ class UeManager : public Object { + /// allow LtePdcpSpecificLtePdcpSapUser class friend access friend class LtePdcpSpecificLtePdcpSapUser; public: @@ -565,14 +566,23 @@ class UeManager : public Object class LteEnbRrc : public Object { + /// allow EnbRrcMemberLteEnbCmacSapUser class friend access friend class EnbRrcMemberLteEnbCmacSapUser; + /// allow MemberLteHandoverManagementSapUser class friend access friend class MemberLteHandoverManagementSapUser; + /// allow MemberLteAnrSapUser class friend access friend class MemberLteAnrSapUser; + /// allow MemberLteFfrRrcSapUser class friend access friend class MemberLteFfrRrcSapUser; + /// allow MemberLteEnbRrcSapProvider class friend access friend class MemberLteEnbRrcSapProvider; + /// allow MemberLteEnbRrcSapProvider class friend access friend class MemberEpcEnbS1SapUser; + /// allow MemberEpcEnbS1SapUser class friend access friend class EpcX2SpecificEpcX2SapUser; + /// allow UeManager class friend access friend class UeManager; + /// allow MemberLteCcmRrcSapUser class friend access friend class MemberLteCcmRrcSapUser; public: @@ -996,19 +1006,53 @@ class LteEnbRrc : public Object // RRC SAP methods - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::CompleteSetupUe interface to UeManager::CompleteSetupUe + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::CompleteSetupUe interface to UeManager::CompleteSetupUe + * \param rnti the RNTI + * \param params the LteEnbRrcSapProvider::CompleteSetupUeParameters + */ void DoCompleteSetupUe (uint16_t rnti, LteEnbRrcSapProvider::CompleteSetupUeParameters params); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionRequest interface to UeManager::RecvRrcConnectionRequest + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionRequest interface to UeManager::RecvRrcConnectionRequest + * + * \param rnti the RNTI + * \param msg the LteRrcSap::RrcConnectionRequest + */ void DoRecvRrcConnectionRequest (uint16_t rnti, LteRrcSap::RrcConnectionRequest msg); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionSetupCompleted interface to UeManager::RecvRrcConnectionSetupCompleted + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionSetupCompleted interface to UeManager::RecvRrcConnectionSetupCompleted + * + * \param rnti the RNTI + * \param msg the LteRrcSap::RrcConnectionSetupCompleted + */ void DoRecvRrcConnectionSetupCompleted (uint16_t rnti, LteRrcSap::RrcConnectionSetupCompleted msg); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReconfigurationCompleted interface to UeManager::RecvRrcConnectionReconfigurationCompleted + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReconfigurationCompleted interface to UeManager::RecvRrcConnectionReconfigurationCompleted + * + * \param rnti the RNTI + * \param msg the LteRrcSap::RrcConnectionReconfigurationCompleted + */ void DoRecvRrcConnectionReconfigurationCompleted (uint16_t rnti, LteRrcSap::RrcConnectionReconfigurationCompleted msg); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReestablishmentRequest interface to UeManager::RecvRrcConnectionReestablishmentRequest + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReestablishmentRequest interface to UeManager::RecvRrcConnectionReestablishmentRequest + * + * \param rnti the RNTI + * \param msg the LteRrcSap::RrcConnectionReestablishmentRequest + */ void DoRecvRrcConnectionReestablishmentRequest (uint16_t rnti, LteRrcSap::RrcConnectionReestablishmentRequest msg); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReestablishmentComplete interface to UeManager::RecvRrcConnectionReestablishmentComplete + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvRrcConnectionReestablishmentComplete interface to UeManager::RecvRrcConnectionReestablishmentComplete + * + * \param rnti the RNTI + * \param msg the LteRrcSap::RrcConnectionReestablishmentComplete + */ void DoRecvRrcConnectionReestablishmentComplete (uint16_t rnti, LteRrcSap::RrcConnectionReestablishmentComplete msg); - /// Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvMeasurementReport interface to UeManager::RecvMeasurementReport + /** + * Part of the RRC protocol. Forwarding LteEnbRrcSapProvider::RecvMeasurementReport interface to UeManager::RecvMeasurementReport + * + * \param rnti the RNTI + * \param msg the LteRrcSap::MeasurementReport + */ void DoRecvMeasurementReport (uint16_t rnti, LteRrcSap::MeasurementReport msg); // S1 SAP methods diff --git a/src/lte/model/lte-ffr-distributed-algorithm.h b/src/lte/model/lte-ffr-distributed-algorithm.h index cd81de659c5..a921a946a0e 100644 --- a/src/lte/model/lte-ffr-distributed-algorithm.h +++ b/src/lte/model/lte-ffr-distributed-algorithm.h @@ -51,8 +51,9 @@ class LteFfrDistributedAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-ffr-enhanced-algorithm.cc b/src/lte/model/lte-ffr-enhanced-algorithm.cc index cd9ee15574b..5aaa1bd72ff 100644 --- a/src/lte/model/lte-ffr-enhanced-algorithm.cc +++ b/src/lte/model/lte-ffr-enhanced-algorithm.cc @@ -88,9 +88,9 @@ static const struct FfrEnhancedUplinkDefaultConfiguration { 3, 100, 64, 16, 16} }; ///< the enhanced uplink default configuration -/// number of downlink configurations +/** \returns number of downlink configurations */ const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_ffrEnhancedDownlinkDefaultConfiguration) / sizeof (FfrEnhancedDownlinkDefaultConfiguration)); -/// number of uplink configurations +/** \returns number of uplink configurations */ const uint16_t NUM_UPLINK_CONFS (sizeof (g_ffrEnhancedUplinkDefaultConfiguration) / sizeof (FfrEnhancedUplinkDefaultConfiguration)); diff --git a/src/lte/model/lte-ffr-enhanced-algorithm.h b/src/lte/model/lte-ffr-enhanced-algorithm.h index 4cfaf048b72..9a6ffcc1983 100644 --- a/src/lte/model/lte-ffr-enhanced-algorithm.h +++ b/src/lte/model/lte-ffr-enhanced-algorithm.h @@ -59,8 +59,9 @@ class LteFfrEnhancedAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-ffr-rrc-sap.h b/src/lte/model/lte-ffr-rrc-sap.h index 4ade7648ab4..f7e955f4e5f 100644 --- a/src/lte/model/lte-ffr-rrc-sap.h +++ b/src/lte/model/lte-ffr-rrc-sap.h @@ -71,6 +71,7 @@ class LteFfrRrcSapProvider /** * \brief RecvLoadInformation + * \param params the EpcX2Sap::LoadInformationParams */ virtual void RecvLoadInformation (EpcX2Sap::LoadInformationParams params) = 0; @@ -126,6 +127,7 @@ class LteFfrRrcSapUser /** * \brief SendLoadInformation + * \param params the EpcX2Sap::LoadInformationParams */ virtual void SendLoadInformation (EpcX2Sap::LoadInformationParams params) = 0; diff --git a/src/lte/model/lte-ffr-sap.h b/src/lte/model/lte-ffr-sap.h index 1cbb44ff5e4..36257b93348 100644 --- a/src/lte/model/lte-ffr-sap.h +++ b/src/lte/model/lte-ffr-sap.h @@ -97,26 +97,32 @@ class LteFfrSapProvider /** * \brief ReportDlCqiInfo + * \param params the struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters */ virtual void ReportDlCqiInfo (const struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters& params) = 0; /** * \brief ReportUlCqiInfo + * \param params the struct FfMacSchedSapProvider::SchedUlCqiInfoReqParameters */ virtual void ReportUlCqiInfo (const struct FfMacSchedSapProvider::SchedUlCqiInfoReqParameters& params) = 0; /** * \brief ReportUlCqiInfo + * \param ulCqiMap the UL CQI map */ virtual void ReportUlCqiInfo ( std::map > ulCqiMap ) = 0; /** * \brief GetTpc + * \param rnti the RNTI + * \returns the TCP */ virtual uint8_t GetTpc (uint16_t rnti) = 0; /** - * \brief GetMinContinuousUlBandwidth + * \brief Get the minimum continuous Ul bandwidth + * \returns the minimum continuous UL bandwidth */ virtual uint8_t GetMinContinuousUlBandwidth () = 0; }; // end of class LteFfrSapProvider diff --git a/src/lte/model/lte-ffr-soft-algorithm.cc b/src/lte/model/lte-ffr-soft-algorithm.cc index 57786593e02..da4dfbd1507 100644 --- a/src/lte/model/lte-ffr-soft-algorithm.cc +++ b/src/lte/model/lte-ffr-soft-algorithm.cc @@ -81,9 +81,9 @@ static const struct FfrSoftUplinkDefaultConfiguration { 3, 100, 28, 48, 24} }; ///< the soft uplink default configuration -/// number of downlink configurations +/** \returns number of downlink configurations */ const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_ffrSoftDownlinkDefaultConfiguration) / sizeof (FfrSoftDownlinkDefaultConfiguration)); -/// number of uplink configurations +/** \returns number of uplink configurations */ const uint16_t NUM_UPLINK_CONFS (sizeof (g_ffrSoftUplinkDefaultConfiguration) / sizeof (FfrSoftUplinkDefaultConfiguration)); diff --git a/src/lte/model/lte-ffr-soft-algorithm.h b/src/lte/model/lte-ffr-soft-algorithm.h index afab549ba7d..e02ac6b0280 100644 --- a/src/lte/model/lte-ffr-soft-algorithm.h +++ b/src/lte/model/lte-ffr-soft-algorithm.h @@ -57,8 +57,9 @@ class LteFfrSoftAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-fr-hard-algorithm.cc b/src/lte/model/lte-fr-hard-algorithm.cc index fb99b54f57c..844f423b784 100644 --- a/src/lte/model/lte-fr-hard-algorithm.cc +++ b/src/lte/model/lte-fr-hard-algorithm.cc @@ -78,9 +78,9 @@ static const struct FrHardUplinkDefaultConfiguration { 3, 100, 64, 36} }; ///< the hard uplink default configuration -/// number of downlink configurations +/** \returns number of downlink configurations */ const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_frHardDownlinkDefaultConfiguration) / sizeof (FrHardDownlinkDefaultConfiguration)); -/// number of uplink configurations +/** \returns number of uplink configurations */ const uint16_t NUM_UPLINK_CONFS (sizeof (g_frHardUplinkDefaultConfiguration) / sizeof (FrHardUplinkDefaultConfiguration)); LteFrHardAlgorithm::LteFrHardAlgorithm () diff --git a/src/lte/model/lte-fr-hard-algorithm.h b/src/lte/model/lte-fr-hard-algorithm.h index 2023d4ea727..deb4b5fffb4 100644 --- a/src/lte/model/lte-fr-hard-algorithm.h +++ b/src/lte/model/lte-fr-hard-algorithm.h @@ -56,8 +56,9 @@ class LteFrHardAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-fr-no-op-algorithm.h b/src/lte/model/lte-fr-no-op-algorithm.h index 14e592f9fe8..a2885988059 100644 --- a/src/lte/model/lte-fr-no-op-algorithm.h +++ b/src/lte/model/lte-fr-no-op-algorithm.h @@ -62,8 +62,9 @@ class LteFrNoOpAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-fr-soft-algorithm.cc b/src/lte/model/lte-fr-soft-algorithm.cc index ee8ed8ff98c..647b092a6d8 100644 --- a/src/lte/model/lte-fr-soft-algorithm.cc +++ b/src/lte/model/lte-fr-soft-algorithm.cc @@ -79,9 +79,9 @@ static const struct FrSoftUplinkDefaultConfiguration { 3, 100, 64, 36} }; ///< soft uplink default configuration -/// number of downlink configurations +/** \returns number of downlink configurations */ const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_frSoftDownlinkDefaultConfiguration) / sizeof (FrSoftDownlinkDefaultConfiguration)); -/// number of uplink configurations +/** \returns number of uplink configurations */ const uint16_t NUM_UPLINK_CONFS (sizeof (g_frSoftUplinkDefaultConfiguration) / sizeof (FrSoftUplinkDefaultConfiguration)); diff --git a/src/lte/model/lte-fr-soft-algorithm.h b/src/lte/model/lte-fr-soft-algorithm.h index 9c2feff8afc..f485a7d5039 100644 --- a/src/lte/model/lte-fr-soft-algorithm.h +++ b/src/lte/model/lte-fr-soft-algorithm.h @@ -57,8 +57,9 @@ class LteFrSoftAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-fr-strict-algorithm.cc b/src/lte/model/lte-fr-strict-algorithm.cc index b2ba670c141..ef742e86cc5 100644 --- a/src/lte/model/lte-fr-strict-algorithm.cc +++ b/src/lte/model/lte-fr-strict-algorithm.cc @@ -81,9 +81,9 @@ static const struct FrStrictUplinkDefaultConfiguration { 3, 100, 28, 48, 24} }; ///< the strict uplink default configuration -/// number of downlink configurations +/** \returns number of downlink configurations */ const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_frStrictDownlinkDefaultConfiguration) / sizeof (FrStrictDownlinkDefaultConfiguration)); -/// number of uplink configurations +/** \returns number of uplink configurations */ const uint16_t NUM_UPLINK_CONFS (sizeof (g_frStrictUplinkDefaultConfiguration) / sizeof (FrStrictUplinkDefaultConfiguration)); diff --git a/src/lte/model/lte-fr-strict-algorithm.h b/src/lte/model/lte-fr-strict-algorithm.h index a5fd7e4a58a..a9879c07532 100644 --- a/src/lte/model/lte-fr-strict-algorithm.h +++ b/src/lte/model/lte-fr-strict-algorithm.h @@ -57,8 +57,9 @@ class LteFrStrictAlgorithm : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; protected: diff --git a/src/lte/model/lte-net-device.h b/src/lte/model/lte-net-device.h index 99a048c147d..79cc1583cc2 100644 --- a/src/lte/model/lte-net-device.h +++ b/src/lte/model/lte-net-device.h @@ -98,7 +98,10 @@ class LteNetDevice : public NetDevice private: /// type conversion operator LteNetDevice (const LteNetDevice &); - /// assignment operator + /** + * assignment operator + * \returns LteNetDevice + */ LteNetDevice & operator= (const LteNetDevice &); Ptr m_node; ///< the node diff --git a/src/lte/model/lte-pdcp-tag.h b/src/lte/model/lte-pdcp-tag.h index aa54cd4fa8d..04d5dbfe7bb 100644 --- a/src/lte/model/lte-pdcp-tag.h +++ b/src/lte/model/lte-pdcp-tag.h @@ -50,6 +50,7 @@ class PdcpTag : public Tag PdcpTag (); /** * Create an PDCP tag with the given senderTimestamp + * \param senderTimestamp the time stamp */ PdcpTag (Time senderTimestamp); diff --git a/src/lte/model/lte-pdcp.h b/src/lte/model/lte-pdcp.h index 0fa5b40a04d..bc78465b261 100644 --- a/src/lte/model/lte-pdcp.h +++ b/src/lte/model/lte-pdcp.h @@ -36,7 +36,9 @@ namespace ns3 { */ class LtePdcp : public Object // SimpleRefCount { + /// allow LtePdcpSpecificLteRlcSapUser class friend access friend class LtePdcpSpecificLteRlcSapUser; + /// allow LtePdcpSpecificLtePdcpSapProvider class friend access friend class LtePdcpSpecificLtePdcpSapProvider; public: LtePdcp (); diff --git a/src/lte/model/lte-phy-tag.h b/src/lte/model/lte-phy-tag.h index 67bc7e164db..6883fe79fc1 100644 --- a/src/lte/model/lte-phy-tag.h +++ b/src/lte/model/lte-phy-tag.h @@ -45,6 +45,7 @@ class LtePhyTag : public Tag /** * Create a LtePhyTag with the given RNTI and LC id + * \param cellId the cell ID */ LtePhyTag (uint16_t cellId); diff --git a/src/lte/model/lte-radio-bearer-tag.h b/src/lte/model/lte-radio-bearer-tag.h index 412ad24a258..1517eda61ce 100644 --- a/src/lte/model/lte-radio-bearer-tag.h +++ b/src/lte/model/lte-radio-bearer-tag.h @@ -48,11 +48,16 @@ class LteRadioBearerTag : public Tag /** * Create a LteRadioBearerTag with the given RNTI and LC id + * \param rnti the RNTI + * \param lcId the LCID */ LteRadioBearerTag (uint16_t rnti, uint8_t lcId); /** * Create a LteRadioBearerTag with the given RNTI, LC id and layer + * \param rnti the RNTI + * \param lcId the LCID + * \param layer the layer */ LteRadioBearerTag (uint16_t rnti, uint8_t lcId, uint8_t layer); diff --git a/src/lte/model/lte-rlc-sap.h b/src/lte/model/lte-rlc-sap.h index feb0a63a437..7e23cc2f72e 100644 --- a/src/lte/model/lte-rlc-sap.h +++ b/src/lte/model/lte-rlc-sap.h @@ -51,6 +51,7 @@ class LteRlcSapProvider * Send a PDCP PDU to the RLC for transmission * This method is to be called * when upper PDCP entity has a PDCP PDU ready to send + * \param params the TransmitPdcpPduParameters */ virtual void TransmitPdcpPdu (TransmitPdcpPduParameters params) = 0; }; @@ -89,7 +90,10 @@ class LteRlcSpecificLteRlcSapProvider : public LteRlcSapProvider */ LteRlcSpecificLteRlcSapProvider (C* rlc); - // Interface implemented from LteRlcSapProvider + /** + * Interface implemented from LteRlcSapProvider + * \param params the TransmitPdcpPduParameters + */ virtual void TransmitPdcpPdu (TransmitPdcpPduParameters params); private: diff --git a/src/lte/model/lte-rlc-sequence-number.h b/src/lte/model/lte-rlc-sequence-number.h index 0a4ccaee0d2..2106a9191e9 100644 --- a/src/lte/model/lte-rlc-sequence-number.h +++ b/src/lte/model/lte-rlc-sequence-number.h @@ -99,7 +99,10 @@ class SequenceNumber10 m_modulusBase = modulusBase; } - /// postfix ++ operator + /** + * postfix ++ operator + * \returns SequenceNumber10 + */ SequenceNumber10 operator++ (int) { SequenceNumber10 retval (m_value); @@ -108,7 +111,11 @@ class SequenceNumber10 return retval; } - /// addition operator + /** + * addition operator + * \param delta the amount to add + * \returns SequenceNumber10 + */ SequenceNumber10 operator + (uint16_t delta) const { SequenceNumber10 ret ((m_value + delta) % 1024); @@ -116,7 +123,11 @@ class SequenceNumber10 return ret; } - /// subtraction operator + /** + * subtraction operator + * \param delta the amount to subtract + * \returns SequenceNumber10 + */ SequenceNumber10 operator - (uint16_t delta) const { SequenceNumber10 ret ((m_value - delta) % 1024); @@ -124,14 +135,22 @@ class SequenceNumber10 return ret; } - /// subtraction operator + /** + * subtraction operator + * \param other the amount to subtract + * \returns SequenceNumber10 + */ uint16_t operator - (const SequenceNumber10 &other) const { uint16_t diff = m_value - other.m_value; return (diff); } - /// greater than operator + /** + * greater than operator + * \param other the object to compare + * \returns true if greater than + */ bool operator > (const SequenceNumber10 &other) const { SequenceNumber10 v1 ((m_value - m_modulusBase) % 1024); @@ -139,31 +158,51 @@ class SequenceNumber10 return ( v1.GetValue () > v2.GetValue () ); } - /// equaity operator + /** + * equality operator + * \param other the object to compare + * \returns true if equal + */ bool operator == (const SequenceNumber10 &other) const { return (m_value == other.m_value); } - /// inequality operator + /** + * inequality operator + * \param other the object to compare + * \returns true if not equal + */ bool operator != (const SequenceNumber10 &other) const { return (m_value != other.m_value); } - /// less than or equal operator + /** + * less than or equal operator + * \param other the object to compare + * \returns true if less than or equal + */ bool operator <= (const SequenceNumber10 &other) const { return (!this->operator> (other)); } - /// greater than or equal operator + /** + * greater than or equal operator + * \param other the object to compare + * \returns true if greater than or equal + */ bool operator >= (const SequenceNumber10 &other) const { return (this->operator> (other) || this->operator== (other)); } - /// less than operator + /** + * less than operator + * \param other the object to compare + * \returns true if less than + */ bool operator < (const SequenceNumber10 &other) const { return !this->operator> (other) && m_value != other.m_value; diff --git a/src/lte/model/lte-rlc-tag.h b/src/lte/model/lte-rlc-tag.h index e8ca5401d9e..92a968f0fd3 100644 --- a/src/lte/model/lte-rlc-tag.h +++ b/src/lte/model/lte-rlc-tag.h @@ -48,7 +48,8 @@ class RlcTag : public Tag */ RlcTag (); /** - * Create an RLC tag with the given senderTimestamp + * Create an RLC tag with the given senderTimestamp + * \param senderTimestamp the time */ RlcTag (Time senderTimestamp); diff --git a/src/lte/model/lte-rlc.h b/src/lte/model/lte-rlc.h index 03c5612f033..33a8579794d 100644 --- a/src/lte/model/lte-rlc.h +++ b/src/lte/model/lte-rlc.h @@ -49,7 +49,9 @@ namespace ns3 { */ class LteRlc : public Object // SimpleRefCount { + /// allow LteRlcSpecificLteMacSapUser class friend access friend class LteRlcSpecificLteMacSapUser; + /// allow LteRlcSpecificLteRlcSapProvider class friend access friend class LteRlcSpecificLteRlcSapProvider; public: LteRlc (); diff --git a/src/lte/model/lte-rrc-protocol-ideal.h b/src/lte/model/lte-rrc-protocol-ideal.h index 4b5b5ba5006..9071d4deef6 100644 --- a/src/lte/model/lte-rrc-protocol-ideal.h +++ b/src/lte/model/lte-rrc-protocol-ideal.h @@ -47,6 +47,7 @@ class LteUeRrc; */ class LteUeRrcProtocolIdeal : public Object { + /// allow MemberLteUeRrcSapUser class friend access friend class MemberLteUeRrcSapUser; public: @@ -149,6 +150,7 @@ class LteUeRrcProtocolIdeal : public Object */ class LteEnbRrcProtocolIdeal : public Object { + /// allow MemberLteEnbRrcSapUser class friend access friend class MemberLteEnbRrcSapUser; public: diff --git a/src/lte/model/lte-rrc-protocol-real.h b/src/lte/model/lte-rrc-protocol-real.h index bd4ec03cf19..e9cd9e4a62a 100644 --- a/src/lte/model/lte-rrc-protocol-real.h +++ b/src/lte/model/lte-rrc-protocol-real.h @@ -52,8 +52,11 @@ class LteUeRrc; */ class LteUeRrcProtocolReal : public Object { + /// allow MemberLteUeRrcSapUser class friend access friend class MemberLteUeRrcSapUser; + /// allow LteRlcSpecificLteRlcSapUser class friend access friend class LteRlcSpecificLteRlcSapUser; + /// allow LtePdcpSpecificLtePdcpSapUser class friend access friend class LtePdcpSpecificLtePdcpSapUser; public: @@ -170,9 +173,13 @@ class LteUeRrcProtocolReal : public Object */ class LteEnbRrcProtocolReal : public Object { + /// allow MemberLteEnbRrcSapUser class friend access friend class MemberLteEnbRrcSapUser; + /// allow LtePdcpSpecificLtePdcpSapUser class friend access friend class LtePdcpSpecificLtePdcpSapUser; + /// allow LteRlcSpecificLteRlcSapUser class friend access friend class LteRlcSpecificLteRlcSapUser; + /// allow RealProtocolRlcSapUser class friend access friend class RealProtocolRlcSapUser; public: diff --git a/src/lte/model/lte-rrc-sap.h b/src/lte/model/lte-rrc-sap.h index 26cb3d024ee..f5832db8882 100644 --- a/src/lte/model/lte-rrc-sap.h +++ b/src/lte/model/lte-rrc-sap.h @@ -94,7 +94,8 @@ class LteRrcSap /// RlcConfig structure struct RlcConfig { - enum + /// the direction choice + enum direction { AM, UM_BI_DIRECTIONAL, @@ -115,7 +116,8 @@ class LteRrcSap /// SoundingRsUlConfigCommon structure struct SoundingRsUlConfigCommon { - enum + /// the config action + enum action { SETUP, RESET } type; ///< action type @@ -126,7 +128,8 @@ class LteRrcSap /// SoundingRsUlConfigDedicated structure struct SoundingRsUlConfigDedicated { - enum + /// the config action + enum action { SETUP, RESET } type; ///< action type @@ -150,11 +153,11 @@ class LteRrcSap /// PdschConfigDedicated structure struct PdschConfigDedicated { - /* + /** * P_A values, TS 36.331 6.3.2 PDSCH-Config * ENUMERATED { dB-6, dB-4dot77, dB-3, dB-1dot77, dB0, dB1, dB2, dB3 } */ - enum + enum db { dB_6, dB_4dot77, @@ -383,7 +386,8 @@ class LteRrcSap /// Time during which specific criteria for the event needs to be met in order to trigger a measurement report. uint16_t timeToTrigger; - enum + /// the report purpose + enum report { REPORT_STRONGEST_CELLS, REPORT_CGI @@ -460,11 +464,13 @@ class LteRrcSap /// MeasGapConfig structure struct MeasGapConfig { - enum + /// the action type + enum action { SETUP, RESET } type; ///< action type - enum + /// the gap offest + enum gap { GP0, GP1 } gapOffsetChoice; ///< gap offset @@ -491,7 +497,8 @@ class LteRrcSap /// SpeedStatePars structure struct SpeedStatePars { - enum + /// the action type + enum action { SETUP, RESET diff --git a/src/lte/model/lte-spectrum-phy.h b/src/lte/model/lte-spectrum-phy.h index b435dc427d3..7c85296950c 100644 --- a/src/lte/model/lte-spectrum-phy.h +++ b/src/lte/model/lte-spectrum-phy.h @@ -441,6 +441,7 @@ class LteSpectrumPhy : public SpectrumPhy */ Ptr GetChannel (); + /// allow LteUePhy class friend access friend class LteUePhy; /** diff --git a/src/lte/model/lte-spectrum-signal-parameters.h b/src/lte/model/lte-spectrum-signal-parameters.h index 6e388180b3f..2dc214fb770 100644 --- a/src/lte/model/lte-spectrum-signal-parameters.h +++ b/src/lte/model/lte-spectrum-signal-parameters.h @@ -49,6 +49,7 @@ struct LteSpectrumSignalParameters : public SpectrumSignalParameters /** * copy constructor + * \param p the LteSpectrumSignalParameters to copy */ LteSpectrumSignalParameters (const LteSpectrumSignalParameters& p); @@ -79,6 +80,7 @@ struct LteSpectrumSignalParametersDataFrame : public SpectrumSignalParameters /** * copy constructor + * \param p the LteSpectrumSignalParametersDataFrame to copy */ LteSpectrumSignalParametersDataFrame (const LteSpectrumSignalParametersDataFrame& p); @@ -111,6 +113,7 @@ struct LteSpectrumSignalParametersDlCtrlFrame : public SpectrumSignalParameters /** * copy constructor + * \param p the LteSpectrumSignalParametersDlCtrlFrame to copy */ LteSpectrumSignalParametersDlCtrlFrame (const LteSpectrumSignalParametersDlCtrlFrame& p); @@ -141,6 +144,7 @@ struct LteSpectrumSignalParametersUlSrsFrame : public SpectrumSignalParameters /** * copy constructor + * \param p the LteSpectrumSignalParametersUlSrsFrame to copy */ LteSpectrumSignalParametersUlSrsFrame (const LteSpectrumSignalParametersUlSrsFrame& p); diff --git a/src/lte/model/lte-ue-ccm-rrc-sap.h b/src/lte/model/lte-ue-ccm-rrc-sap.h index d6af2019b4e..bdd6dd456b4 100644 --- a/src/lte/model/lte-ue-ccm-rrc-sap.h +++ b/src/lte/model/lte-ue-ccm-rrc-sap.h @@ -44,6 +44,7 @@ namespace ns3 { class LteUeCcmRrcSapProvider { +/// allow LteMacSapUser class friend access friend class LteMacSapUser; public: diff --git a/src/lte/model/lte-ue-component-carrier-manager.h b/src/lte/model/lte-ue-component-carrier-manager.h index 471381432fa..b5cca931b78 100644 --- a/src/lte/model/lte-ue-component-carrier-manager.h +++ b/src/lte/model/lte-ue-component-carrier-manager.h @@ -75,6 +75,7 @@ class LteUeComponentCarrierManager : public Object /** * \brief Returns the MAC sap provider interface that if forwarding calls to the * instance of the LteUeComponentCarrierManager. + * \return the reference to the "provider" part of the interface */ virtual LteMacSapProvider* GetLteMacSapProvider () = 0; @@ -88,6 +89,7 @@ class LteUeComponentCarrierManager : public Object /** * \brief Sets number of component carriers that are supported by this UE. + * \param noOfComponentCarriers numbr of compoent carriers */ void SetNumberOfComponentCarriers (uint8_t noOfComponentCarriers); diff --git a/src/lte/model/lte-ue-mac.h b/src/lte/model/lte-ue-mac.h index 361ae22d404..408617cbb13 100644 --- a/src/lte/model/lte-ue-mac.h +++ b/src/lte/model/lte-ue-mac.h @@ -42,8 +42,11 @@ class UniformRandomVariable; class LteUeMac : public Object { + /// allow UeMemberLteUeCmacSapProvider class friend access friend class UeMemberLteUeCmacSapProvider; + /// allow UeMemberLteMacSapProvider class friend access friend class UeMemberLteMacSapProvider; + /// allow UeMemberLteUePhySapUser class friend access friend class UeMemberLteUePhySapUser; public: diff --git a/src/lte/model/lte-ue-phy.h b/src/lte/model/lte-ue-phy.h index d5f7d5db409..c0227fa58e5 100644 --- a/src/lte/model/lte-ue-phy.h +++ b/src/lte/model/lte-ue-phy.h @@ -51,7 +51,9 @@ class LteHarqPhy; class LteUePhy : public LtePhy { + /// allow UeMemberLteUePhySapProvider class friend access friend class UeMemberLteUePhySapProvider; + /// allow MemberLteUeCphySapProvider class friend access friend class MemberLteUeCphySapProvider; public: @@ -227,6 +229,7 @@ class LteUePhy : public LtePhy /** * \brief PhySpectrum received a new PHY-PDU + * \param p the packet received */ void PhyPduReceived (Ptr p); @@ -247,11 +250,13 @@ class LteUePhy : public LtePhy /** * \brief PhySpectrum generated a new DL HARQ feedback + * \param mes the DlInfoListElement_s */ virtual void ReceiveLteDlHarqFeedback (DlInfoListElement_s mes); /** * \brief Set the HARQ PHY module + * \param harq the HARQ PHY module */ void SetHarqPhyModule (Ptr harq); diff --git a/src/lte/model/lte-ue-rrc.h b/src/lte/model/lte-ue-rrc.h index db3501393a3..34c8f263448 100644 --- a/src/lte/model/lte-ue-rrc.h +++ b/src/lte/model/lte-ue-rrc.h @@ -79,12 +79,19 @@ class LteSignalingRadioBearerInfo; class LteUeRrc : public Object { + /// allow UeMemberLteUeCmacSapUser class friend access friend class UeMemberLteUeCmacSapUser; + /// allow UeRrcMemberLteEnbCmacSapUser class friend access friend class UeRrcMemberLteEnbCmacSapUser; + /// allow LtePdcpSpecificLtePdcpSapUser class friend access friend class LtePdcpSpecificLtePdcpSapUser; + /// allow MemberLteAsSapProvider class friend access friend class MemberLteAsSapProvider; + /// allow MemberLteUeCphySapUser class friend access friend class MemberLteUeCphySapUser; + /// allow MemberLteUeRrcSapProvider class friend access friend class MemberLteUeRrcSapProvider; + /// allow MemberLteUeCcmRrcSapUser class friend access friend class MemberLteUeCcmRrcSapUser; public: @@ -427,13 +434,25 @@ class LteUeRrc : public Object // RRC SAP methods - /// Part of the RRC protocol. Implement the LteUeRrcSapProvider::CompleteSetup interface. + /** + * Part of the RRC protocol. Implement the LteUeRrcSapProvider::CompleteSetup interface. + * \param params the LteUeRrcSapProvider::CompleteSetupParameters + */ void DoCompleteSetup (LteUeRrcSapProvider::CompleteSetupParameters params); - /// Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvSystemInformation interface. + /** + * Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvSystemInformation interface. + * \param msg the LteRrcSap::SystemInformation + */ void DoRecvSystemInformation (LteRrcSap::SystemInformation msg); - /// Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionSetup interface. + /** + * Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionSetup interface. + * \param msg the LteRrcSap::RrcConnectionSetup + */ void DoRecvRrcConnectionSetup (LteRrcSap::RrcConnectionSetup msg); - /// Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionReconfiguration interface. + /** + * Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionReconfiguration interface. + * \param msg the LteRrcSap::RrcConnectionReconfiguration + */ void DoRecvRrcConnectionReconfiguration (LteRrcSap::RrcConnectionReconfiguration msg); /** * Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionReestablishment interface. @@ -450,7 +469,10 @@ class LteUeRrc : public Object * \param msg LteRrcSap::RrcConnectionRelease */ void DoRecvRrcConnectionRelease (LteRrcSap::RrcConnectionRelease msg); - /// Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionReject interface. + /** + * Part of the RRC protocol. Implement the LteUeRrcSapProvider::RecvRrcConnectionReject interface. + * \param msg the LteRrcSap::RrcConnectionReject + */ void DoRecvRrcConnectionReject (LteRrcSap::RrcConnectionReject msg); /** diff --git a/src/lte/model/no-op-component-carrier-manager.h b/src/lte/model/no-op-component-carrier-manager.h index eadb28843f2..189f1d2fe6b 100644 --- a/src/lte/model/no-op-component-carrier-manager.h +++ b/src/lte/model/no-op-component-carrier-manager.h @@ -42,9 +42,13 @@ class LteCcmRrcSapProvider; class NoOpComponentCarrierManager : public LteEnbComponentCarrierManager { + /// allow EnbMacMemberLteMacSapProvider class friend access friend class EnbMacMemberLteMacSapProvider; + /// allow MemberLteCcmRrcSapProvider class friend access friend class MemberLteCcmRrcSapProvider; + /// allow MemberLteCcmRrcSapUser class friend access friend class MemberLteCcmRrcSapUser; + /// allow MemberLteCcmMacSapUser class friend access friend class MemberLteCcmMacSapUser; public: diff --git a/src/lte/model/no-op-handover-algorithm.h b/src/lte/model/no-op-handover-algorithm.h index 3a0b5541552..161db13f46a 100644 --- a/src/lte/model/no-op-handover-algorithm.h +++ b/src/lte/model/no-op-handover-algorithm.h @@ -56,7 +56,7 @@ class NoOpHandoverAlgorithm : public LteHandoverAlgorithm virtual void SetLteHandoverManagementSapUser (LteHandoverManagementSapUser* s); virtual LteHandoverManagementSapProvider* GetLteHandoverManagementSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteHandoverManagementSapProvider; protected: diff --git a/src/lte/model/pf-ff-mac-scheduler.h b/src/lte/model/pf-ff-mac-scheduler.h index 57e822c8991..bcff993d96f 100644 --- a/src/lte/model/pf-ff-mac-scheduler.h +++ b/src/lte/model/pf-ff-mac-scheduler.h @@ -102,7 +102,9 @@ class PfFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/pss-ff-mac-scheduler.h b/src/lte/model/pss-ff-mac-scheduler.h index a42f777410f..8078246f46f 100644 --- a/src/lte/model/pss-ff-mac-scheduler.h +++ b/src/lte/model/pss-ff-mac-scheduler.h @@ -110,7 +110,9 @@ class PssFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/rr-ff-mac-scheduler.h b/src/lte/model/rr-ff-mac-scheduler.h index bffad828914..fb1979a6951 100644 --- a/src/lte/model/rr-ff-mac-scheduler.h +++ b/src/lte/model/rr-ff-mac-scheduler.h @@ -89,7 +89,9 @@ class RrFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/simple-ue-component-carrier-manager.h b/src/lte/model/simple-ue-component-carrier-manager.h index e6629a9d1ec..e157ead3730 100644 --- a/src/lte/model/simple-ue-component-carrier-manager.h +++ b/src/lte/model/simple-ue-component-carrier-manager.h @@ -58,11 +58,13 @@ class SimpleUeComponentCarrierManager : public LteUeComponentCarrierManager - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteUeCcmRrcSapProvider; //friend class MemberLteUeCcmRrcSapUser; + /// allow SimpleUeCcmMacSapProvider class friend access friend class SimpleUeCcmMacSapProvider; + /// allow SimpleUeCcmMacSapUser class friend access friend class SimpleUeCcmMacSapUser; protected: diff --git a/src/lte/model/tdbet-ff-mac-scheduler.h b/src/lte/model/tdbet-ff-mac-scheduler.h index 77b1a1e8109..96f04f54a22 100644 --- a/src/lte/model/tdbet-ff-mac-scheduler.h +++ b/src/lte/model/tdbet-ff-mac-scheduler.h @@ -103,7 +103,9 @@ class TdBetFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/tdmt-ff-mac-scheduler.h b/src/lte/model/tdmt-ff-mac-scheduler.h index d640eb10fe7..cfe98a7a839 100644 --- a/src/lte/model/tdmt-ff-mac-scheduler.h +++ b/src/lte/model/tdmt-ff-mac-scheduler.h @@ -94,7 +94,9 @@ class TdMtFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/tdtbfq-ff-mac-scheduler.h b/src/lte/model/tdtbfq-ff-mac-scheduler.h index 2ca56376d97..4815cccf1cb 100644 --- a/src/lte/model/tdtbfq-ff-mac-scheduler.h +++ b/src/lte/model/tdtbfq-ff-mac-scheduler.h @@ -109,7 +109,9 @@ class TdTbfqFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/model/tta-ff-mac-scheduler.h b/src/lte/model/tta-ff-mac-scheduler.h index 36178d6179b..54736fdbf3a 100644 --- a/src/lte/model/tta-ff-mac-scheduler.h +++ b/src/lte/model/tta-ff-mac-scheduler.h @@ -94,7 +94,9 @@ class TtaFfMacScheduler : public FfMacScheduler virtual void SetLteFfrSapProvider (LteFfrSapProvider* s); virtual LteFfrSapUser* GetLteFfrSapUser (); + /// allow MemberCschedSapProvider class friend access friend class MemberCschedSapProvider; + /// allow MemberSchedSapProvider class friend access friend class MemberSchedSapProvider; /** diff --git a/src/lte/test/lte-ffr-simple.h b/src/lte/test/lte-ffr-simple.h index 4ae6a1e2894..f3e497d7af4 100644 --- a/src/lte/test/lte-ffr-simple.h +++ b/src/lte/test/lte-ffr-simple.h @@ -84,8 +84,9 @@ class LteFfrSimple : public LteFfrAlgorithm virtual void SetLteFfrRrcSapUser (LteFfrRrcSapUser* s); virtual LteFfrRrcSapProvider* GetLteFfrRrcSapProvider (); - // let the forwarder class access the protected and private members + /// let the forwarder class access the protected and private members friend class MemberLteFfrSapProvider; + /// let the forwarder class access the protected and private members friend class MemberLteFfrRrcSapProvider; /** diff --git a/src/lte/test/lte-test-cell-selection.h b/src/lte/test/lte-test-cell-selection.h index d07dfedf923..c7bff343310 100644 --- a/src/lte/test/lte-test-cell-selection.h +++ b/src/lte/test/lte-test-cell-selection.h @@ -114,6 +114,9 @@ class LteCellSelectionTestCase : public TestCase /** * \brief Verifies if the given UE is attached to either of the given two * cells and in a CONNECTED_NORMALLY state. + * \param ueDev the UE device + * \param expectedCellId1 the first cell ID + * \param expectedCellId2 the second cell ID */ void CheckPoint (Ptr ueDev, uint16_t expectedCellId1, uint16_t expectedCellId2); diff --git a/src/lte/test/lte-test-cqi-generation.h b/src/lte/test/lte-test-cqi-generation.h index ee384b768de..6c440c6355e 100644 --- a/src/lte/test/lte-test-cqi-generation.h +++ b/src/lte/test/lte-test-cqi-generation.h @@ -43,7 +43,7 @@ class LteCqiGenerationTestSuite : public TestSuite * \ingroup lte-test * \ingroup tests * - * \brief This is the test suite for testing different configuration of CQI generation. + * \brief This is the test case for testing different configuration of CQI generation. * The topology consists of the two UEs and two eNbs. UEs have the same position, * while eNodeBs are at the same distance from both UEs. The checking whether CQI is * generated properly for two different cases: when PDCCH is used for the CQI @@ -54,7 +54,7 @@ class LteCqiGenerationTestCase : public TestCase { public: /** - * Constructor + * \Constructor * * \param name reference name * \param usePdcchForCqiGeneration use PDCCH for CQI generation @@ -95,7 +95,7 @@ class LteCqiGenerationTestCase : public TestCase * \ingroup lte-test * \ingroup tests * - * \brief This test is very simillar to LteCqiGenerationTestCase. The difference is that in this + * \brief This test is very similar to LteCqiGenerationTestCase. The difference is that in this * test is enabled the downlink power control. */ diff --git a/src/lte/test/lte-test-downlink-sinr.h b/src/lte/test/lte-test-downlink-sinr.h index 2313957387e..f1a6defcaf1 100644 --- a/src/lte/test/lte-test-downlink-sinr.h +++ b/src/lte/test/lte-test-downlink-sinr.h @@ -56,6 +56,13 @@ class LteDownlinkSinrTestSuite : public TestSuite class LteDownlinkDataSinrTestCase : public TestCase { public: + /** + * Constructor + * + * \param sv the spectrum value + * \param sinr the SINR + * \param name the name of the test + */ LteDownlinkDataSinrTestCase (Ptr sv, Ptr sinr, std::string name); virtual ~LteDownlinkDataSinrTestCase (); @@ -83,6 +90,13 @@ class LteDownlinkDataSinrTestCase : public TestCase class LteDownlinkCtrlSinrTestCase : public TestCase { public: + /** + * Constructor + * + * \param sv the spectrum value + * \param sinr the SINR + * \param name the name of the test + */ LteDownlinkCtrlSinrTestCase (Ptr sv, Ptr sinr, std::string name); virtual ~LteDownlinkCtrlSinrTestCase (); diff --git a/src/lte/test/lte-test-entities.h b/src/lte/test/lte-test-entities.h index d70fee9b72c..7adb7aafb06 100644 --- a/src/lte/test/lte-test-entities.h +++ b/src/lte/test/lte-test-entities.h @@ -41,6 +41,7 @@ namespace ns3 { */ class LteTestRrc : public Object { + /// allow LtePdcpSpecificLtePdcpSapUser class friend access friend class LtePdcpSpecificLtePdcpSapUser; // friend class EnbMacMemberLteEnbCmacSapProvider; // friend class EnbMacMemberLteMacSapProvider; @@ -139,7 +140,10 @@ class LteTestRrc : public Object void SetDevice (Ptr device); private: - // Interface forwarded by LtePdcpSapUser + /** + * Interface forwarded by LtePdcpSapUser + * \param params the LtePdcpSapUser::ReceivePdcpSduParameters + */ virtual void DoReceivePdcpSdu (LtePdcpSapUser::ReceivePdcpSduParameters params); LtePdcpSapUser* m_pdcpSapUser; ///< PDCP SAP user @@ -171,6 +175,7 @@ class LteTestRrc : public Object */ class LteTestPdcp : public Object { + /// allow LteRlcSpecificLteRlcSapUser class friend access friend class LteRlcSpecificLteRlcSapUser; public: @@ -212,8 +217,11 @@ class LteTestPdcp : public Object std::string GetDataReceived (void); private: - // Interface forwarded by LteRlcSapUser - virtual void DoReceivePdcpPdu (Ptr p); + /** + * Interface forwarded by LteRlcSapUser + * \param p the PDCP PDU packet received + */ + virtual void DoReceivePdcpPdu (Ptr p); LteRlcSapUser* m_rlcSapUser; ///< RLC SAP user LteRlcSapProvider* m_rlcSapProvider; ///< RLC SAP provider @@ -232,6 +240,7 @@ class LteTestPdcp : public Object class LteTestMac : public Object { // friend class EnbMacMemberLteEnbCmacSapProvider; + /// allow EnbMacMemberLteMacSapProvider class friend access friend class EnbMacMemberLteMacSapProvider; // friend class EnbMacMemberFfMacSchedSapUser; // friend class EnbMacMemberFfMacCschedSapUser; @@ -406,6 +415,7 @@ class LteTestMac : public Object */ class EpcTestRrc : public Object { + /// allow MemberEpcEnbS1SapUser class friend access friend class MemberEpcEnbS1SapUser; public: From f5f951d9c8a249991bb76b8108b0aa008da04335 Mon Sep 17 00:00:00 2001 From: Menglei Zhang Date: Fri, 2 Jun 2017 19:52:33 +0200 Subject: [PATCH 080/551] lte: (fixes #2731) Allow retranmission in RLC AM when PR timer expires and vtS is overflowed --- src/lte/model/lte-rlc-am.cc | 71 +++++++++++++++++++++++++++++-------- 1 file changed, 56 insertions(+), 15 deletions(-) diff --git a/src/lte/model/lte-rlc-am.cc b/src/lte/model/lte-rlc-am.cc index f0cffcc3034..9874eb7ab13 100644 --- a/src/lte/model/lte-rlc-am.cc +++ b/src/lte/model/lte-rlc-am.cc @@ -1690,25 +1690,66 @@ LteRlcAm::ExpirePollRetransmitTimer (void) { NS_LOG_INFO ("txonBuffer and retxBuffer empty. Move PDUs up to = " << m_vtS.GetValue () - 1 << " to retxBuffer"); uint16_t sn = 0; - for ( sn = m_vtA.GetValue(); sn < m_vtS.GetValue (); sn++ ) + uint16_t acked = m_vtA.GetValue(); + uint16_t sent = m_vtS.GetValue (); + if(acked <= sent) //If no overflow, no change. { - bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; - - if ( pduAvailable ) - { - NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); - m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); - m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; - m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); - - m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); - m_txedBuffer.at (sn).m_pdu = 0; - m_txedBuffer.at (sn).m_retxCount = 0; - } + for ( sn = m_vtA.GetValue(); sn < m_vtS.GetValue (); sn++ ) + { + bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; + + if ( pduAvailable ) + { + NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); + m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); + m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; + m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); + + m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); + m_txedBuffer.at (sn).m_pdu = 0; + m_txedBuffer.at (sn).m_retxCount = 0; + } + } + } + else//If overflow happened, we retransmit from acked sequence to 1023, then from 0 to sent sequence. + { + for ( sn = m_vtA.GetValue(); sn < 1024; sn++ ) + { + bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; + + if ( pduAvailable ) + { + NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); + m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); + m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; + m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); + + m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); + m_txedBuffer.at (sn).m_pdu = 0; + m_txedBuffer.at (sn).m_retxCount = 0; + } + } + + for ( sn = 0; sn < m_vtS.GetValue (); sn++ ) + { + bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; + + if ( pduAvailable ) + { + NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); + m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); + m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; + m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); + + m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); + m_txedBuffer.at (sn).m_pdu = 0; + m_txedBuffer.at (sn).m_retxCount = 0; + } + } } } - DoReportBufferStatus (); + DoReportBufferStatus (); } From 923f022b5fcc2b90011e9b08f9075984164f13ec Mon Sep 17 00:00:00 2001 From: "Peter D. Barnes, Jr." Date: Fri, 2 Jun 2017 17:13:54 -0700 Subject: [PATCH 081/551] Make asserts actually check the state, fixing warning from gcc-7 --- src/wimax/model/ss-net-device.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/wimax/model/ss-net-device.cc b/src/wimax/model/ss-net-device.cc index a72476eb0fe..7a5ad619a7d 100644 --- a/src/wimax/model/ss-net-device.cc +++ b/src/wimax/model/ss-net-device.cc @@ -922,7 +922,7 @@ SubscriberStationNetDevice::DoReceive (Ptr packet) // intended for base station, ignore break; case ManagementMessageType::MESSAGE_TYPE_RNG_RSP: - NS_ASSERT_MSG (SS_STATE_WAITING_RNG_RSP, + NS_ASSERT_MSG (GetState () == SS_STATE_WAITING_RNG_RSP, "SS: Error while receiving a ranging response message: SS state should be SS_STATE_WAITING_RNG_RSP"); packet->RemoveHeader (rngrsp); m_linkManager->PerformRanging (cid, rngrsp); @@ -941,7 +941,7 @@ SubscriberStationNetDevice::DoReceive (Ptr packet) // intended for base station, ignore break; case ManagementMessageType::MESSAGE_TYPE_RNG_RSP: - NS_ASSERT_MSG (SS_STATE_WAITING_RNG_RSP, + NS_ASSERT_MSG (GetState () == SS_STATE_WAITING_RNG_RSP, "SS: Error while receiving a ranging response message: SS state should be SS_STATE_WAITING_RNG_RSP"); packet->RemoveHeader (rngrsp); m_linkManager->PerformRanging (cid, rngrsp); From 604b537c2ff38da48f176ec28f0b669bb4b605a1 Mon Sep 17 00:00:00 2001 From: "Rohit P. Tahiliani" Date: Fri, 2 Jun 2017 22:38:17 -0700 Subject: [PATCH 082/551] examples: (fixes #2568) Avoid enumerating TCP variants --- examples/tcp/tcp-variants-comparison.cc | 112 +++++------------------- 1 file changed, 23 insertions(+), 89 deletions(-) diff --git a/examples/tcp/tcp-variants-comparison.cc b/examples/tcp/tcp-variants-comparison.cc index a3ef07f15ad..81e3597383d 100644 --- a/examples/tcp/tcp-variants-comparison.cc +++ b/examples/tcp/tcp-variants-comparison.cc @@ -244,6 +244,8 @@ int main (int argc, char *argv[]) cmd.AddValue ("sack", "Enable or disable SACK option", sack); cmd.Parse (argc, argv); + transport_prot = std::string ("ns3::") + transport_prot; + SeedManager::SetSeed (1); SeedManager::SetRun (run); @@ -274,65 +276,18 @@ int main (int argc, char *argv[]) Config::SetDefault ("ns3::TcpSocketBase::Sack", BooleanValue (sack)); // Select TCP variant - if (transport_prot.compare ("TcpNewReno") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpNewReno::GetTypeId ())); - } - else if (transport_prot.compare ("TcpHybla") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpHybla::GetTypeId ())); - } - else if (transport_prot.compare ("TcpHighSpeed") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpHighSpeed::GetTypeId ())); - } - else if (transport_prot.compare ("TcpVegas") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpVegas::GetTypeId ())); - } - else if (transport_prot.compare ("TcpScalable") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpScalable::GetTypeId ())); - } - else if (transport_prot.compare ("TcpHtcp") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpHtcp::GetTypeId ())); - } - else if (transport_prot.compare ("TcpVeno") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpVeno::GetTypeId ())); - } - else if (transport_prot.compare ("TcpBic") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpBic::GetTypeId ())); - } - else if (transport_prot.compare ("TcpYeah") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpYeah::GetTypeId ())); - } - else if (transport_prot.compare ("TcpIllinois") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpIllinois::GetTypeId ())); - } - else if (transport_prot.compare ("TcpWestwood") == 0) - { // the default protocol type in ns3::TcpWestwood is WESTWOOD - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId ())); - Config::SetDefault ("ns3::TcpWestwood::FilterType", EnumValue (TcpWestwood::TUSTIN)); - } - else if (transport_prot.compare ("TcpWestwoodPlus") == 0) - { + if (transport_prot.compare ("ns3::TcpWestwoodPlus") == 0) + { + // TcpWestwoodPlus is not an actual TypeId name; we need TcpWestwood here Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId ())); + // the default protocol type in ns3::TcpWestwood is WESTWOOD Config::SetDefault ("ns3::TcpWestwood::ProtocolType", EnumValue (TcpWestwood::WESTWOODPLUS)); - Config::SetDefault ("ns3::TcpWestwood::FilterType", EnumValue (TcpWestwood::TUSTIN)); - } - else if (transport_prot.compare ("TcpLedbat") == 0) - { - Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpLedbat::GetTypeId ())); } else { - NS_LOG_DEBUG ("Invalid TCP version"); - exit (1); + TypeId tcpTid; + NS_ABORT_MSG_UNLESS (TypeId::LookupByNameFailSafe (transport_prot, &tcpTid), "TypeId " << transport_prot << " not found"); + Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TypeId::LookupByName (transport_prot))); } // Create gateways, sources, and sinks @@ -427,41 +382,20 @@ int main (int argc, char *argv[]) for (uint16_t i = 0; i < sources.GetN (); i++) { AddressValue remoteAddress (InetSocketAddress (sink_interfaces.GetAddress (i, 0), port)); - - if (transport_prot.compare ("TcpNewReno") == 0 - || transport_prot.compare ("TcpWestwood") == 0 - || transport_prot.compare ("TcpWestwoodPlus") == 0 - || transport_prot.compare ("TcpHybla") == 0 - || transport_prot.compare ("TcpHighSpeed") == 0 - || transport_prot.compare ("TcpHtcp") == 0 - || transport_prot.compare ("TcpVegas") == 0 - || transport_prot.compare ("TcpVeno") == 0 - || transport_prot.compare ("TcpBic") == 0 - || transport_prot.compare ("TcpScalable") == 0 - || transport_prot.compare ("TcpYeah") == 0 - || transport_prot.compare ("TcpIllinois") == 0 - || transport_prot.compare ("TcpLedbat") == 0) - { - Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (tcp_adu_size)); - BulkSendHelper ftp ("ns3::TcpSocketFactory", Address ()); - ftp.SetAttribute ("Remote", remoteAddress); - ftp.SetAttribute ("SendSize", UintegerValue (tcp_adu_size)); - ftp.SetAttribute ("MaxBytes", UintegerValue (int(data_mbytes * 1000000))); - - ApplicationContainer sourceApp = ftp.Install (sources.Get (i)); - sourceApp.Start (Seconds (start_time * i)); - sourceApp.Stop (Seconds (stop_time - 3)); - - sinkHelper.SetAttribute ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ())); - ApplicationContainer sinkApp = sinkHelper.Install (sinks); - sinkApp.Start (Seconds (start_time * i)); - sinkApp.Stop (Seconds (stop_time)); - } - else - { - NS_LOG_DEBUG ("Invalid transport protocol " << transport_prot << " specified"); - exit (1); - } + Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (tcp_adu_size)); + BulkSendHelper ftp ("ns3::TcpSocketFactory", Address ()); + ftp.SetAttribute ("Remote", remoteAddress); + ftp.SetAttribute ("SendSize", UintegerValue (tcp_adu_size)); + ftp.SetAttribute ("MaxBytes", UintegerValue (int(data_mbytes * 1000000))); + + ApplicationContainer sourceApp = ftp.Install (sources.Get (i)); + sourceApp.Start (Seconds (start_time * i)); + sourceApp.Stop (Seconds (stop_time - 3)); + + sinkHelper.SetAttribute ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ())); + ApplicationContainer sinkApp = sinkHelper.Install (sinks); + sinkApp.Start (Seconds (start_time * i)); + sinkApp.Stop (Seconds (stop_time)); } // Set up tracing if enabled From c1e2312e2a479c9d83858b6108bd03b62ac2b1d5 Mon Sep 17 00:00:00 2001 From: "Rohit P. Tahiliani" Date: Fri, 2 Jun 2017 22:40:33 -0700 Subject: [PATCH 083/551] examples: (fixes #2520) TCP variant not configured in wifi-tcp.cc --- examples/wireless/wifi-tcp.cc | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/examples/wireless/wifi-tcp.cc b/examples/wireless/wifi-tcp.cc index a9e20bff915..6b896518955 100644 --- a/examples/wireless/wifi-tcp.cc +++ b/examples/wireless/wifi-tcp.cc @@ -60,7 +60,7 @@ main (int argc, char *argv[]) { uint32_t payloadSize = 1472; /* Transport layer payload size in bytes. */ std::string dataRate = "100Mbps"; /* Application layer datarate. */ - std::string tcpVariant = "ns3::TcpNewReno"; /* TCP variant type. */ + std::string tcpVariant = "TcpNewReno"; /* TCP variant type. */ std::string phyRate = "HtMcs7"; /* Physical layer bitrate. */ double simulationTime = 10; /* Simulation time in seconds. */ bool pcapTracing = false; /* PCAP Tracing is enabled or not. */ @@ -69,16 +69,35 @@ main (int argc, char *argv[]) CommandLine cmd; cmd.AddValue ("payloadSize", "Payload size in bytes", payloadSize); cmd.AddValue ("dataRate", "Application data ate", dataRate); - cmd.AddValue ("tcpVariant", "Transport protocol to use: TcpTahoe, TcpReno, TcpNewReno, TcpWestwood, TcpWestwoodPlus ", tcpVariant); + cmd.AddValue ("tcpVariant", "Transport protocol to use: TcpNewReno, " + "TcpHybla, TcpHighSpeed, TcpHtcp, TcpVegas, TcpScalable, TcpVeno, " + "TcpBic, TcpYeah, TcpIllinois, TcpWestwood, TcpWestwoodPlus, TcpLedbat ", tcpVariant); cmd.AddValue ("phyRate", "Physical layer bitrate", phyRate); cmd.AddValue ("simulationTime", "Simulation time in seconds", simulationTime); cmd.AddValue ("pcap", "Enable/disable PCAP Tracing", pcapTracing); cmd.Parse (argc, argv); + tcpVariant = std::string ("ns3::") + tcpVariant; + /* No fragmentation and no RTS/CTS */ Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("999999")); Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("999999")); + // Select TCP variant + if (tcpVariant.compare ("ns3::TcpWestwoodPlus") == 0) + { + // TcpWestwoodPlus is not an actual TypeId name; we need TcpWestwood here + Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId ())); + // the default protocol type in ns3::TcpWestwood is WESTWOOD + Config::SetDefault ("ns3::TcpWestwood::ProtocolType", EnumValue (TcpWestwood::WESTWOODPLUS)); + } + else + { + TypeId tcpTid; + NS_ABORT_MSG_UNLESS (TypeId::LookupByNameFailSafe (tcpVariant, &tcpTid), "TypeId " << tcpVariant << " not found"); + Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TypeId::LookupByName (tcpVariant))); + } + /* Configure TCP Options */ Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (payloadSize)); @@ -189,6 +208,6 @@ main (int argc, char *argv[]) NS_LOG_ERROR ("Obtained throughput is not in the expected boundaries!"); exit (1); } - std::cout << "\nAverage throughtput: " << averageThroughput << " Mbit/s" << std::endl; + std::cout << "\nAverage throughput: " << averageThroughput << " Mbit/s" << std::endl; return 0; } From 222b2778aa0043d884fa23be3dd1c8b344d98dc1 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 3 Jun 2017 06:56:21 -0700 Subject: [PATCH 084/551] wimax: Relax assumption of current state when receiving a ranging response The changeset 12906:98ce80ed995f fixed a bug in the assert, but the check for == SS_STATE_WAITING_RNG_RSP appears to be too strict, as the device may have moved to another state. Review of wimax examples and tests shows that this device may be in states 4, 5, 6, 7, or 8 when this message is received, so the assert condition was relaxed. --- src/wimax/model/ss-net-device.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/wimax/model/ss-net-device.cc b/src/wimax/model/ss-net-device.cc index 7a5ad619a7d..d715d986e31 100644 --- a/src/wimax/model/ss-net-device.cc +++ b/src/wimax/model/ss-net-device.cc @@ -922,8 +922,8 @@ SubscriberStationNetDevice::DoReceive (Ptr packet) // intended for base station, ignore break; case ManagementMessageType::MESSAGE_TYPE_RNG_RSP: - NS_ASSERT_MSG (GetState () == SS_STATE_WAITING_RNG_RSP, - "SS: Error while receiving a ranging response message: SS state should be SS_STATE_WAITING_RNG_RSP"); + NS_ASSERT_MSG (GetState () >= SS_STATE_WAITING_REG_RANG_INTRVL, + "SS: Error while receiving a ranging response message: SS state should be at least SS_STATE_WAITING_REG_RANG_INTRVL"); packet->RemoveHeader (rngrsp); m_linkManager->PerformRanging (cid, rngrsp); break; From 8a395dc05a5e3ea59a7b1689e57bd492e8076263 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 3 Jun 2017 07:59:20 -0700 Subject: [PATCH 085/551] csma: (fixes #2556) Avoid modification of transmitted packets Packets sent to channel may later be modified by calling device. Possible solutions are to copy before or after sending the packet to the channel. Adopted solution similar to YansWifiChannel; a Ptr is instead passed to the channel object, and channel object is responsible for copy. --- src/csma/model/csma-channel.cc | 4 ++-- src/csma/model/csma-channel.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/csma/model/csma-channel.cc b/src/csma/model/csma-channel.cc index 7f96b467307..0ba64b53785 100644 --- a/src/csma/model/csma-channel.cc +++ b/src/csma/model/csma-channel.cc @@ -170,7 +170,7 @@ CsmaChannel::Detach (Ptr device) } bool -CsmaChannel::TransmitStart (Ptr p, uint32_t srcId) +CsmaChannel::TransmitStart (Ptr p, uint32_t srcId) { NS_LOG_FUNCTION (this << p << srcId); NS_LOG_INFO ("UID is " << p->GetUid () << ")"); @@ -188,7 +188,7 @@ CsmaChannel::TransmitStart (Ptr p, uint32_t srcId) } NS_LOG_LOGIC ("switch to TRANSMITTING"); - m_currentPkt = p; + m_currentPkt = p->Copy (); m_currentSrc = srcId; m_state = TRANSMITTING; return true; diff --git a/src/csma/model/csma-channel.h b/src/csma/model/csma-channel.h index ae4859941bc..4bbcfd873b1 100644 --- a/src/csma/model/csma-channel.h +++ b/src/csma/model/csma-channel.h @@ -184,7 +184,7 @@ class CsmaChannel : public Channel * \return True if the channel is not busy and the transmitting net * device is currently active. */ - bool TransmitStart (Ptr p, uint32_t srcId); + bool TransmitStart (Ptr p, uint32_t srcId); /** * \brief Indicates that the net device has finished transmitting From 7eab0b51c9d48395d45d3230ddd0b44b94aefa97 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 3 Jun 2017 08:10:44 -0700 Subject: [PATCH 086/551] point-to-point: (fixes #2556) Avoid modification of transmitted packets Packets sent to channel may later be modified by calling device. Possible solutions are to copy before or after sending the packet to the channel. Adopted solution similar to YansWifiChannel; a Ptr is instead passed to the channel object, and channel object is responsible for copy. --- src/point-to-point/model/point-to-point-channel.cc | 4 ++-- src/point-to-point/model/point-to-point-channel.h | 2 +- src/point-to-point/model/point-to-point-remote-channel.cc | 4 ++-- src/point-to-point/model/point-to-point-remote-channel.h | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/point-to-point/model/point-to-point-channel.cc b/src/point-to-point/model/point-to-point-channel.cc index d59cbd17b20..77dd626d50c 100644 --- a/src/point-to-point/model/point-to-point-channel.cc +++ b/src/point-to-point/model/point-to-point-channel.cc @@ -85,7 +85,7 @@ PointToPointChannel::Attach (Ptr device) bool PointToPointChannel::TransmitStart ( - Ptr p, + Ptr p, Ptr src, Time txTime) { @@ -99,7 +99,7 @@ PointToPointChannel::TransmitStart ( Simulator::ScheduleWithContext (m_link[wire].m_dst->GetNode ()->GetId (), txTime + m_delay, &PointToPointNetDevice::Receive, - m_link[wire].m_dst, p); + m_link[wire].m_dst, p->Copy ()); // Call the tx anim callback on the net device m_txrxPointToPoint (p, src, m_link[wire].m_dst, txTime, txTime + m_delay); diff --git a/src/point-to-point/model/point-to-point-channel.h b/src/point-to-point/model/point-to-point-channel.h index e53bfe14129..732bfca94a0 100644 --- a/src/point-to-point/model/point-to-point-channel.h +++ b/src/point-to-point/model/point-to-point-channel.h @@ -78,7 +78,7 @@ class PointToPointChannel : public Channel * \param txTime Transmit time to apply * \returns true if successful (currently always true) */ - virtual bool TransmitStart (Ptr p, Ptr src, Time txTime); + virtual bool TransmitStart (Ptr p, Ptr src, Time txTime); /** * \brief Get number of devices on this channel diff --git a/src/point-to-point/model/point-to-point-remote-channel.cc b/src/point-to-point/model/point-to-point-remote-channel.cc index 40f98cecbba..46fe81be33a 100644 --- a/src/point-to-point/model/point-to-point-remote-channel.cc +++ b/src/point-to-point/model/point-to-point-remote-channel.cc @@ -55,7 +55,7 @@ PointToPointRemoteChannel::~PointToPointRemoteChannel () bool PointToPointRemoteChannel::TransmitStart ( - Ptr p, + Ptr p, Ptr src, Time txTime) { @@ -70,7 +70,7 @@ PointToPointRemoteChannel::TransmitStart ( #ifdef NS3_MPI // Calculate the rxTime (absolute) Time rxTime = Simulator::Now () + txTime + GetDelay (); - MpiInterface::SendPacket (p, rxTime, dst->GetNode ()->GetId (), dst->GetIfIndex ()); + MpiInterface::SendPacket (p->Copy (), rxTime, dst->GetNode ()->GetId (), dst->GetIfIndex ()); #else NS_FATAL_ERROR ("Can't use distributed simulator without MPI compiled in"); #endif diff --git a/src/point-to-point/model/point-to-point-remote-channel.h b/src/point-to-point/model/point-to-point-remote-channel.h index fd1a9a8a59b..f10b2df913c 100644 --- a/src/point-to-point/model/point-to-point-remote-channel.h +++ b/src/point-to-point/model/point-to-point-remote-channel.h @@ -66,7 +66,7 @@ class PointToPointRemoteChannel : public PointToPointChannel * \param txTime Transmit time to apply * \returns true if successful (currently always true) */ - virtual bool TransmitStart (Ptr p, Ptr src, + virtual bool TransmitStart (Ptr p, Ptr src, Time txTime); }; From 652291722f67aa94c1f1acece338f3864757c03d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20D=C3=B6pmann?= Date: Sat, 3 Jun 2017 11:42:01 -0700 Subject: [PATCH 087/551] core: (fixes #2658) Avoid unexpected TracedValue type conversions --- src/core/model/traced-value.h | 122 +++++++++++++++++----------------- 1 file changed, 61 insertions(+), 61 deletions(-) diff --git a/src/core/model/traced-value.h b/src/core/model/traced-value.h index 28b33afc65a..d1bc9dede21 100644 --- a/src/core/model/traced-value.h +++ b/src/core/model/traced-value.h @@ -150,7 +150,7 @@ class TracedValue */ template TracedValue (const TracedValue &other) - : m_v (other.m_v) + : m_v (other.Get ()) {} /** * Copy from a variable type compatible with this underlying type. @@ -441,192 +441,192 @@ bool operator > (const U &lhs, const TracedValue &rhs) * the underlying values. */ template -TracedValue operator + (const TracedValue &lhs, const TracedValue &rhs) { +auto operator + (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x+x"); - return TracedValue (lhs.Get () + rhs.Get ()); + return TracedValue(lhs.Get () + rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator + (const TracedValue &lhs, const U &rhs) { +auto operator + (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x+"); - return TracedValue (lhs.Get () + rhs); + return TracedValue(lhs.Get () + rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator + (const U &lhs, const TracedValue &rhs) { +auto operator + (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("+x"); - return TracedValue (lhs + rhs.Get ()); + return TracedValue(lhs + rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator - (const TracedValue &lhs, const TracedValue &rhs) { +auto operator - (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x-x"); - return TracedValue (lhs.Get () - rhs.Get ()); + return TracedValue(lhs.Get () - rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator - (const TracedValue &lhs, const U &rhs) { +auto operator - (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x-"); - return TracedValue (lhs.Get () - rhs); + return TracedValue(lhs.Get () - rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator - (const U &lhs, const TracedValue &rhs) { +auto operator - (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("-x"); - return TracedValue (lhs - rhs.Get ()); + return TracedValue(lhs - rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator * (const TracedValue &lhs, const TracedValue &rhs) { +auto operator * (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x*x"); - return TracedValue (lhs.Get () * rhs.Get ()); + return TracedValue(lhs.Get () * rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator * (const TracedValue &lhs, const U &rhs) { +auto operator * (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x*"); - return TracedValue (lhs.Get () * rhs); + return TracedValue(lhs.Get () * rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator * (const U &lhs, const TracedValue &rhs) { +auto operator * (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("*x"); - return TracedValue (lhs * rhs.Get ()); + return TracedValue(lhs * rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator / (const TracedValue &lhs, const TracedValue &rhs) { +auto operator / (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x/x"); - return TracedValue (lhs.Get () / rhs.Get ()); + return TracedValue(lhs.Get () / rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator / (const TracedValue &lhs, const U &rhs) { +auto operator / (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x/"); - return TracedValue (lhs.Get () / rhs); + return TracedValue(lhs.Get () / rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator / (const U &lhs, const TracedValue &rhs) { +auto operator / (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("/x"); - return TracedValue (lhs / rhs.Get ()); + return TracedValue(lhs / rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator % (const TracedValue &lhs, const TracedValue &rhs) { +auto operator % (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x%x"); - return TracedValue (lhs.Get () % rhs.Get ()); + return TracedValue(lhs.Get () % rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator % (const TracedValue &lhs, const U &rhs) { +auto operator % (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x%"); - return TracedValue (lhs.Get () % rhs); + return TracedValue(lhs.Get () % rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator % (const U &lhs, const TracedValue &rhs) { +auto operator % (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("%x"); - return TracedValue (lhs % rhs.Get ()); + return TracedValue(lhs % rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator ^ (const TracedValue &lhs, const TracedValue &rhs) { +auto operator ^ (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x^x"); - return TracedValue (lhs.Get () ^ rhs.Get ()); + return TracedValue(lhs.Get () ^ rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator ^ (const TracedValue &lhs, const U &rhs) { +auto operator ^ (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x^"); - return TracedValue (lhs.Get () ^ rhs); + return TracedValue(lhs.Get () ^ rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator ^ (const U &lhs, const TracedValue &rhs) { +auto operator ^ (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("^x"); - return TracedValue (lhs ^ rhs.Get ()); + return TracedValue(lhs ^ rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator | (const TracedValue &lhs, const TracedValue &rhs) { +auto operator | (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x|x"); - return TracedValue (lhs.Get () | rhs.Get ()); + return TracedValue(lhs.Get () | rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator | (const TracedValue &lhs, const U &rhs) { +auto operator | (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x|"); - return TracedValue (lhs.Get () | rhs); + return TracedValue(lhs.Get () | rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator | (const U &lhs, const TracedValue &rhs) { +auto operator | (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("|x"); - return TracedValue (lhs | rhs.Get ()); + return TracedValue(lhs | rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator & (const TracedValue &lhs, const TracedValue &rhs) { +auto operator & (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x&x"); - return TracedValue (lhs.Get () & rhs.Get ()); + return TracedValue(lhs.Get () & rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator & (const TracedValue &lhs, const U &rhs) { +auto operator & (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x&"); - return TracedValue (lhs.Get () & rhs); + return TracedValue(lhs.Get () & rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator & (const U &lhs, const TracedValue &rhs) { +auto operator & (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("&x"); - return TracedValue (lhs & rhs.Get ()); + return TracedValue(lhs & rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator << (const TracedValue &lhs, const TracedValue &rhs) { +auto operator << (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x< (lhs.Get () << rhs.Get ()); + return TracedValue(lhs.Get () << rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator << (const TracedValue &lhs, const U &rhs) { +auto operator << (const TracedValue &lhs, const U &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("x<<"); - return TracedValue (lhs.Get () << rhs); + return TracedValue(lhs.Get () << rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator << (const U &lhs, const TracedValue &rhs) { +auto operator << (const U &lhs, const TracedValue &rhs) -> TracedValue { TRACED_VALUE_DEBUG ("< (lhs << rhs.Get ()); + return TracedValue(lhs << rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator >> (const TracedValue &lhs, const TracedValue &rhs) { +auto operator >> (const TracedValue &lhs, const TracedValue &rhs) -> TracedValue> rhs.Get())> { TRACED_VALUE_DEBUG ("x>>x"); - return TracedValue (lhs.Get () >> rhs.Get ()); + return TracedValue> rhs.Get())>(lhs.Get () >> rhs.Get ()); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator >> (const TracedValue &lhs, const U &rhs) { +auto operator >> (const TracedValue &lhs, const U &rhs) -> TracedValue> rhs)> { TRACED_VALUE_DEBUG ("x>>"); - return TracedValue (lhs.Get () >> rhs); + return TracedValue> rhs)>(lhs.Get () >> rhs); } /** \copydoc operator+(const TracedValue&lhs,const TracedValue&rhs) */ template -TracedValue operator >> (const U &lhs, const TracedValue &rhs) { +auto operator >> (const U &lhs, const TracedValue &rhs) -> TracedValue> rhs.Get())> { TRACED_VALUE_DEBUG (">>x"); - return TracedValue (lhs >> rhs.Get ()); + return TracedValue> rhs.Get())>(lhs >> rhs.Get ()); } /** From 6bfbef9f30ea098492f0150dfeee92b35642a822 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20D=C3=B6pmann?= Date: Sat, 3 Jun 2017 11:46:52 -0700 Subject: [PATCH 088/551] internet: Explicitly cast a floating point computation (related to bug #2658) --- src/internet/model/tcp-hybla.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/internet/model/tcp-hybla.cc b/src/internet/model/tcp-hybla.cc index 46f039ddd6a..a23e4496a41 100644 --- a/src/internet/model/tcp-hybla.cc +++ b/src/internet/model/tcp-hybla.cc @@ -110,7 +110,7 @@ TcpHybla::SlowStart (Ptr tcb, uint32_t segmentsAcked) double increment = std::pow (2, m_rho) - 1.0; NS_LOG_INFO ("Slow start: inc=" << increment); - tcb->m_cWnd = std::min (tcb->m_cWnd + (increment * tcb->m_segmentSize), + tcb->m_cWnd = std::min (tcb->m_cWnd + (uint32_t)(increment * tcb->m_segmentSize), tcb->m_ssThresh); NS_LOG_INFO ("In SlowStart, updated to cwnd " << tcb->m_cWnd << From be325774b31dee6717c787a59800643fb8d34640 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 5 Apr 2016 14:56:46 +0300 Subject: [PATCH 089/551] spectrum: Make it possible to chain propagation loss models For example, this change makes it possible to chain fading model with frequency-dependent pathloss model. --- src/spectrum/model/multi-model-spectrum-channel.cc | 11 +++++++++-- src/spectrum/model/single-model-spectrum-channel.cc | 10 ++++++++-- src/spectrum/model/spectrum-channel.h | 6 +++--- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/src/spectrum/model/multi-model-spectrum-channel.cc b/src/spectrum/model/multi-model-spectrum-channel.cc index 1461a8e5fe4..6f40d96e577 100644 --- a/src/spectrum/model/multi-model-spectrum-channel.cc +++ b/src/spectrum/model/multi-model-spectrum-channel.cc @@ -438,14 +438,21 @@ void MultiModelSpectrumChannel::AddPropagationLossModel (Ptr loss) { NS_LOG_FUNCTION (this << loss); - NS_ASSERT (m_propagationLoss == 0); + if (m_propagationLoss) + { + loss->SetNext (m_propagationLoss); + } m_propagationLoss = loss; } void MultiModelSpectrumChannel::AddSpectrumPropagationLossModel (Ptr loss) { - NS_ASSERT (m_spectrumPropagationLoss == 0); + NS_LOG_FUNCTION (this << loss); + if (m_spectrumPropagationLoss) + { + loss->SetNext (m_spectrumPropagationLoss); + } m_spectrumPropagationLoss = loss; } diff --git a/src/spectrum/model/single-model-spectrum-channel.cc b/src/spectrum/model/single-model-spectrum-channel.cc index 8a4e104da31..fcceb14622f 100644 --- a/src/spectrum/model/single-model-spectrum-channel.cc +++ b/src/spectrum/model/single-model-spectrum-channel.cc @@ -239,7 +239,10 @@ void SingleModelSpectrumChannel::AddPropagationLossModel (Ptr loss) { NS_LOG_FUNCTION (this << loss); - NS_ASSERT (m_propagationLoss == 0); + if (m_propagationLoss) + { + loss->SetNext (m_propagationLoss); + } m_propagationLoss = loss; } @@ -248,7 +251,10 @@ void SingleModelSpectrumChannel::AddSpectrumPropagationLossModel (Ptr loss) { NS_LOG_FUNCTION (this << loss); - NS_ASSERT (m_spectrumPropagationLoss == 0); + if (m_spectrumPropagationLoss) + { + loss->SetNext (m_spectrumPropagationLoss); + } m_spectrumPropagationLoss = loss; } diff --git a/src/spectrum/model/spectrum-channel.h b/src/spectrum/model/spectrum-channel.h index 1de4fbb06c6..09b95d562e6 100644 --- a/src/spectrum/model/spectrum-channel.h +++ b/src/spectrum/model/spectrum-channel.h @@ -55,7 +55,7 @@ class SpectrumChannel : public Channel static TypeId GetTypeId (void); /** - * Set the single-frequency propagation loss model to be used + * Add the single-frequency propagation loss model to be used * \warning only models that do not depend on the TX power should be used. * * \param loss a pointer to the propagation loss model to be used. @@ -63,13 +63,13 @@ class SpectrumChannel : public Channel virtual void AddPropagationLossModel (Ptr loss) = 0; /** - * Set the frequency-dependent propagation loss model to be used + * Add the frequency-dependent propagation loss model to be used * \param loss a pointer to the propagation loss model to be used. */ virtual void AddSpectrumPropagationLossModel (Ptr loss) = 0; /** - * Set the propagation delay model to be used + * Set the propagation delay model to be used * \param delay Ptr to the propagation delay model to be used. */ virtual void SetPropagationDelayModel (Ptr delay) = 0; From 64176da4392b6c18fcfc1a21bb0485ca77f4b2b2 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 16 May 2017 18:19:12 +0300 Subject: [PATCH 090/551] lte: Remove m_ prefix from local variables --- src/lte/helper/lte-helper.cc | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index b0bce71be42..844b5983e8d 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -241,8 +241,8 @@ LteHelper::ChannelModelInitialization (void) Ptr downlinkChannelElem = m_channelFactory.Create (); Ptr uplinkChannelElem = m_channelFactory.Create (); - Ptr m_downlinkPathlossModelElem = m_dlPathlossModelFactory.Create (); - Ptr dlSplm = m_downlinkPathlossModelElem->GetObject (); + Ptr downlinkPathlossModelElem = m_dlPathlossModelFactory.Create (); + Ptr dlSplm = downlinkPathlossModelElem->GetObject (); if (dlSplm != 0) { NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in DL"); @@ -251,13 +251,13 @@ LteHelper::ChannelModelInitialization (void) else { NS_LOG_LOGIC (this << " using a PropagationLossModel in DL"); - Ptr dlPlm = m_downlinkPathlossModelElem->GetObject (); - NS_ASSERT_MSG (dlPlm != 0, " " << m_downlinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); + Ptr dlPlm = downlinkPathlossModelElem->GetObject (); + NS_ASSERT_MSG (dlPlm != 0, " " << downlinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); downlinkChannelElem->AddPropagationLossModel (dlPlm); } - Ptr m_uplinkPathlossModelElem = m_ulPathlossModelFactory.Create (); - Ptr ulSplm = m_uplinkPathlossModelElem->GetObject (); + Ptr uplinkPathlossModelElem = m_ulPathlossModelFactory.Create (); + Ptr ulSplm = uplinkPathlossModelElem->GetObject (); if (ulSplm != 0) { NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in UL"); @@ -266,8 +266,8 @@ LteHelper::ChannelModelInitialization (void) else { NS_LOG_LOGIC (this << " using a PropagationLossModel in UL"); - Ptr ulPlm = m_uplinkPathlossModelElem->GetObject (); - NS_ASSERT_MSG (ulPlm != 0, " " << m_uplinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); + Ptr ulPlm = uplinkPathlossModelElem->GetObject (); + NS_ASSERT_MSG (ulPlm != 0, " " << uplinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); uplinkChannelElem->AddPropagationLossModel (ulPlm); } if (!m_fadingModelType.empty ()) @@ -279,8 +279,8 @@ LteHelper::ChannelModelInitialization (void) } m_downlinkChannel.push_back (downlinkChannelElem); m_uplinkChannel.push_back (uplinkChannelElem); - m_uplinkPathlossModel.push_back (m_uplinkPathlossModelElem); - m_downlinkPathlossModel.push_back (m_downlinkPathlossModelElem); + m_uplinkPathlossModel.push_back (uplinkPathlossModelElem); + m_downlinkPathlossModel.push_back (downlinkPathlossModelElem); } } From 812697855a916c387365539f5a3c067222079b1f Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 16 May 2017 18:34:43 +0300 Subject: [PATCH 091/551] lte: Create single uplink and single downlink channel Note that lte-carrier-aggregation test suite crashes now. It is because the test suite does not configure component carriers with different frequencies, so different bands overlap and UE PHY receives overlapping control messages. --- src/lte/helper/lte-helper.cc | 107 +++++++++++++++-------------------- src/lte/helper/lte-helper.h | 16 ++---- 2 files changed, 51 insertions(+), 72 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index 844b5983e8d..ac0b9be99a9 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -205,8 +205,8 @@ void LteHelper::DoDispose () { NS_LOG_FUNCTION (this); - m_downlinkChannel.clear (); - m_uplinkChannel.clear (); + m_downlinkChannel = 0; + m_uplinkChannel = 0; m_componentCarrierPhyParams.clear(); Object::DoDispose (); } @@ -214,19 +214,13 @@ LteHelper::DoDispose () Ptr LteHelper::GetUplinkSpectrumChannel (void) const { - return m_uplinkChannel.at(0); + return m_uplinkChannel; } Ptr LteHelper::GetDownlinkSpectrumChannel (void) const { - return m_downlinkChannel.at(0); -} - -Ptr -LteHelper::GetDownlinkSpectrumChannel (uint8_t carrierId) const -{ - return m_downlinkChannel.at(carrierId); + return m_downlinkChannel; } void @@ -236,51 +230,44 @@ LteHelper::ChannelModelInitialization (void) // PathLossModel Objects are vectors --> in InstallSingleEnb we will set the frequency NS_LOG_FUNCTION (this << m_noOfCcs); - for (uint16_t i = 0; i < m_noOfCcs; i++) - { - Ptr downlinkChannelElem = m_channelFactory.Create (); - Ptr uplinkChannelElem = m_channelFactory.Create (); + m_downlinkChannel = m_channelFactory.Create (); + m_uplinkChannel = m_channelFactory.Create (); - Ptr downlinkPathlossModelElem = m_dlPathlossModelFactory.Create (); - Ptr dlSplm = downlinkPathlossModelElem->GetObject (); - if (dlSplm != 0) - { - NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in DL"); - downlinkChannelElem->AddSpectrumPropagationLossModel (dlSplm); - } - else - { - NS_LOG_LOGIC (this << " using a PropagationLossModel in DL"); - Ptr dlPlm = downlinkPathlossModelElem->GetObject (); - NS_ASSERT_MSG (dlPlm != 0, " " << downlinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); - downlinkChannelElem->AddPropagationLossModel (dlPlm); - } + m_downlinkPathlossModel = m_dlPathlossModelFactory.Create (); + Ptr dlSplm = m_downlinkPathlossModel->GetObject (); + if (dlSplm != 0) + { + NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in DL"); + m_downlinkChannel->AddSpectrumPropagationLossModel (dlSplm); + } + else + { + NS_LOG_LOGIC (this << " using a PropagationLossModel in DL"); + Ptr dlPlm = m_downlinkPathlossModel->GetObject (); + NS_ASSERT_MSG (dlPlm != 0, " " << m_downlinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); + m_downlinkChannel->AddPropagationLossModel (dlPlm); + } - Ptr uplinkPathlossModelElem = m_ulPathlossModelFactory.Create (); - Ptr ulSplm = uplinkPathlossModelElem->GetObject (); - if (ulSplm != 0) - { - NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in UL"); - uplinkChannelElem->AddSpectrumPropagationLossModel (ulSplm); - } - else - { - NS_LOG_LOGIC (this << " using a PropagationLossModel in UL"); - Ptr ulPlm = uplinkPathlossModelElem->GetObject (); - NS_ASSERT_MSG (ulPlm != 0, " " << uplinkPathlossModelElem << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); - uplinkChannelElem->AddPropagationLossModel (ulPlm); - } - if (!m_fadingModelType.empty ()) - { - m_fadingModule = m_fadingModelFactory.Create (); - m_fadingModule->Initialize (); - downlinkChannelElem->AddSpectrumPropagationLossModel (m_fadingModule); - uplinkChannelElem->AddSpectrumPropagationLossModel (m_fadingModule); - } - m_downlinkChannel.push_back (downlinkChannelElem); - m_uplinkChannel.push_back (uplinkChannelElem); - m_uplinkPathlossModel.push_back (uplinkPathlossModelElem); - m_downlinkPathlossModel.push_back (downlinkPathlossModelElem); + m_uplinkPathlossModel = m_ulPathlossModelFactory.Create (); + Ptr ulSplm = m_uplinkPathlossModel->GetObject (); + if (ulSplm != 0) + { + NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in UL"); + m_uplinkChannel->AddSpectrumPropagationLossModel (ulSplm); + } + else + { + NS_LOG_LOGIC (this << " using a PropagationLossModel in UL"); + Ptr ulPlm = m_uplinkPathlossModel->GetObject (); + NS_ASSERT_MSG (ulPlm != 0, " " << m_uplinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel"); + m_uplinkChannel->AddPropagationLossModel (ulPlm); + } + if (!m_fadingModelType.empty ()) + { + m_fadingModule = m_fadingModelFactory.Create (); + m_fadingModule->Initialize (); + m_downlinkChannel->AddSpectrumPropagationLossModel (m_fadingModule); + m_uplinkChannel->AddSpectrumPropagationLossModel (m_fadingModule); } } @@ -581,8 +568,8 @@ LteHelper::InstallSingleEnbDevice (Ptr n) pInterf->AddCallback (MakeCallback (&LteEnbPhy::ReportInterference, phy)); ulPhy->AddInterferenceDataChunkProcessor (pInterf); // for interference power tracing - dlPhy->SetChannel (m_downlinkChannel.at (it->first)); - ulPhy->SetChannel (m_uplinkChannel.at (it->first)); + dlPhy->SetChannel (m_downlinkChannel); + ulPhy->SetChannel (m_uplinkChannel); Ptr mm = n->GetObject (); NS_ASSERT_MSG (mm, "MobilityModel needs to be set on node before calling LteHelper::InstallEnbDevice ()"); @@ -730,7 +717,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) NS_LOG_LOGIC ("set the propagation model frequencies"); double dlFreq = LteSpectrumValueHelper::GetCarrierFrequency (it->second->m_dlEarfcn); NS_LOG_LOGIC ("DL freq: " << dlFreq); - bool dlFreqOk = m_downlinkPathlossModel.at (it->first)->SetAttributeFailSafe ("Frequency", DoubleValue (dlFreq)); + bool dlFreqOk = m_downlinkPathlossModel->SetAttributeFailSafe ("Frequency", DoubleValue (dlFreq)); if (!dlFreqOk) { NS_LOG_WARN ("DL propagation model does not have a Frequency attribute"); @@ -739,7 +726,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) double ulFreq = LteSpectrumValueHelper::GetCarrierFrequency (it->second->m_ulEarfcn); NS_LOG_LOGIC ("UL freq: " << ulFreq); - bool ulFreqOk = m_uplinkPathlossModel.at(it->first)->SetAttributeFailSafe ("Frequency", DoubleValue (ulFreq)); + bool ulFreqOk = m_uplinkPathlossModel->SetAttributeFailSafe ("Frequency", DoubleValue (ulFreq)); if (!ulFreqOk) { NS_LOG_WARN ("UL propagation model does not have a Frequency attribute"); @@ -751,7 +738,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) for (it = ccMap.begin (); it != ccMap.end (); ++it) { - m_uplinkChannel.at (it->first)->AddRx (it->second->GetPhy ()->GetUlSpectrumPhy ()); + m_uplinkChannel->AddRx (it->second->GetPhy ()->GetUlSpectrumPhy ()); } if (m_epcHelper != 0) @@ -840,8 +827,8 @@ LteHelper::InstallSingleUeDevice (Ptr n) pCtrl->AddCallback (MakeCallback (&LteUePhy::GenerateCtrlCqiReport, phy)); } - dlPhy->SetChannel (m_downlinkChannel.at (it->first)); - ulPhy->SetChannel (m_uplinkChannel.at (it->first)); + dlPhy->SetChannel (m_downlinkChannel); + ulPhy->SetChannel (m_uplinkChannel); Ptr mm = n->GetObject (); NS_ASSERT_MSG (mm, "MobilityModel needs to be set on node before calling LteHelper::InstallUeDevice ()"); diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index fa5717b060f..94461aea893 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -662,14 +662,6 @@ class LteHelper : public Object */ Ptr GetDownlinkSpectrumChannel (void) const; - /** - * Get downlink spectrum channel of a given carrier. - * - * \param carrierId the carrier ID - * \return a pointer to the SpectrumChannel instance used for the downlink on a given carrier - */ - Ptr GetDownlinkSpectrumChannel (uint8_t carrierId) const; - protected: // inherited from Object @@ -736,13 +728,13 @@ class LteHelper : public Object */ /// The downlink LTE channel used in the simulation. - std::vector > m_downlinkChannel; + Ptr m_downlinkChannel; /// The uplink LTE channel used in the simulation. - std::vector< Ptr > m_uplinkChannel; + Ptr m_uplinkChannel; /// The path loss model used in the downlink channel. - std::vector< Ptr > m_downlinkPathlossModel; + Ptr m_downlinkPathlossModel; /// The path loss model used in the uplink channel. - std::vector< Ptr > m_uplinkPathlossModel; + Ptr m_uplinkPathlossModel; /// Factory of MAC scheduler object. ObjectFactory m_schedulerFactory; From 76866e70e8555d921b06fe5348d18b6d93f80a55 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 16 May 2017 19:18:08 +0300 Subject: [PATCH 092/551] lte: Fix CcHelper::EquallySpacedCcs Before fix the method created overlapping CCs. Error is described in the comment to avoid it in the future. --- src/lte/helper/cc-helper.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/lte/helper/cc-helper.cc b/src/lte/helper/cc-helper.cc index 6aebe9e25dd..65e858bd774 100644 --- a/src/lte/helper/cc-helper.cc +++ b/src/lte/helper/cc-helper.cc @@ -175,8 +175,11 @@ CcHelper::EquallySpacedCcs () for (uint8_t i = 0; i < m_numberOfComponentCarriers; i++) { bool pc =false; - uint32_t ul = m_ulEarfcn + i * m_ulBandwidth; - uint32_t dl = m_dlEarfcn + i * m_dlBandwidth; + + // One RB is 200 kHz wide, while increment by 1 in corresponds to 100 kHz shift + // Therefore, we need to multiply by 2 here. + uint32_t ul = m_ulEarfcn + i * 2 * m_ulBandwidth; + uint32_t dl = m_dlEarfcn + i * 2 * m_dlBandwidth; if (i == 0) { pc = true; From e7a6e4b6ab7a5189477c95aab89635a6bd5c6023 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 16 May 2017 19:46:22 +0300 Subject: [PATCH 093/551] lte: Fix overlapping CC bands in lte-carrier-aggregation test suite Previously test suite did not configure CCs explicitly so they all operated on the same frequency. It worked correctly only because different eNB-UE pairs of PHYs used different channels. --- src/lte/test/lte-test-carrier-aggregation.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/lte/test/lte-test-carrier-aggregation.cc b/src/lte/test/lte-test-carrier-aggregation.cc index 84e6a60f32d..300056edda2 100644 --- a/src/lte/test/lte-test-carrier-aggregation.cc +++ b/src/lte/test/lte-test-carrier-aggregation.cc @@ -289,6 +289,14 @@ CarrierAggregationTestCase::DoRun (void) lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); + auto cch = CreateObject (); + cch->SetDlEarfcn (100); // Same as default value for LteEnbNetDevice + cch->SetUlEarfcn (100 + 18000); // Same as default value for LteEnbNetDevice + cch->SetDlBandwidth (m_dlBandwidth); + cch->SetUlBandwidth (m_ulBandwidth); + cch->SetNumberOfComponentCarriers (m_numberOfComponentCarriers); + lteHelper->SetCcPhyParams (cch->EquallySpacedCcs ()); + // Create Nodes: eNodeB and UE NodeContainer enbNodes; NodeContainer ueNodes; From bf9189dbc6c231adecd29e2a4c9e1eadad22bfa9 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 17 May 2017 20:11:15 +0300 Subject: [PATCH 094/551] lte: Rename UlFreq and DlFreq attiributes to UlEarfcn and DlEarfcn --- src/lte/helper/cc-helper.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/helper/cc-helper.cc b/src/lte/helper/cc-helper.cc index 65e858bd774..b31ec223691 100644 --- a/src/lte/helper/cc-helper.cc +++ b/src/lte/helper/cc-helper.cc @@ -61,12 +61,12 @@ TypeId CcHelper::GetTypeId (void) UintegerValue (1), MakeUintegerAccessor (&CcHelper::m_numberOfComponentCarriers), MakeUintegerChecker (MIN_CC, MAX_CC)) - .AddAttribute ("UlFreq", + .AddAttribute ("UlEarfcn", "Set Ul Channel [EARFCN] for the first carrier component", UintegerValue (0), MakeUintegerAccessor (&CcHelper::m_ulEarfcn), MakeUintegerChecker ()) - .AddAttribute ("DlFreq", + .AddAttribute ("DlEarfcn", "Set Dl Channel [EARFCN] for the first carrier component", UintegerValue (0), MakeUintegerAccessor (&CcHelper::m_dlEarfcn), From 16b85f8c84be3c1d649a16b0b90e339fb5eb6942 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 23 May 2017 20:16:27 +0300 Subject: [PATCH 095/551] lte: Add CellId to ComponentCarrierEnb Now all Component Carriers share the same CellId. Each carrier should have its own cell id, so it should be stored separately for each carrier. --- src/lte/model/component-carrier-enb.cc | 13 +++++++++++++ src/lte/model/component-carrier-enb.h | 16 +++++++++++++++- 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/src/lte/model/component-carrier-enb.cc b/src/lte/model/component-carrier-enb.cc index 262ab337c7c..98c1f2dee1b 100644 --- a/src/lte/model/component-carrier-enb.cc +++ b/src/lte/model/component-carrier-enb.cc @@ -116,6 +116,12 @@ ComponentCarrierEnb::DoInitialize (void) } +uint16_t +ComponentCarrierEnb::GetCellId () +{ + return m_cellId; +} + Ptr ComponentCarrierEnb::GetPhy () { @@ -123,6 +129,13 @@ ComponentCarrierEnb::GetPhy () return m_phy; } +void +ComponentCarrierEnb::SetCellId (uint16_t cellId) +{ + NS_LOG_FUNCTION (this << cellId); + m_cellId = cellId; +} + void ComponentCarrierEnb::SetPhy (Ptr s) { diff --git a/src/lte/model/component-carrier-enb.h b/src/lte/model/component-carrier-enb.h index 7b4b6ae733c..b2f0ba4e95a 100644 --- a/src/lte/model/component-carrier-enb.h +++ b/src/lte/model/component-carrier-enb.h @@ -58,7 +58,13 @@ class ComponentCarrierEnb : public ComponentCarrier virtual ~ComponentCarrierEnb (void); virtual void DoDispose (void); - + + /** + * Get cell identifier + * \return cell identifer + */ + uint16_t GetCellId (); + /** * \return a pointer to the physical layer. */ @@ -78,6 +84,13 @@ class ComponentCarrierEnb : public ComponentCarrier * \return a pointer to the Mac Scheduler. */ Ptr GetFfMacScheduler (); + + /** + * Set physical cell identifier + * \param cellId cell identifier + */ + void SetCellId (uint16_t cellId); + /** * Set the LteEnbPhy * \param s a pointer to the LteEnbPhy @@ -107,6 +120,7 @@ class ComponentCarrierEnb : public ComponentCarrier private: + uint16_t m_cellId; ///< Cell identifer Ptr m_phy; ///< the Phy instance of this eNodeB component carrier Ptr m_mac; ///< the MAC instance of this eNodeB component carrier Ptr m_scheduler; ///< the scheduler instance of this eNodeB component carrier From 4b70ebf37f4b6fe98398dbc1ee0d65925583f235 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 23 May 2017 20:23:19 +0300 Subject: [PATCH 096/551] lte: Make LteEnbRrc::ConfigureCarriers accept map of ComponentCarrierEnb ComponentCarrierEnb has additional CellId parameter compared to ComponentCarrier. eNB RRC needs it to configure PHYs correctly. --- src/lte/helper/lte-helper.cc | 2 +- src/lte/model/lte-enb-rrc.cc | 34 +++++++++++++++++----------------- src/lte/model/lte-enb-rrc.h | 4 ++-- 3 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index ac0b9be99a9..818eb3456ce 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -594,7 +594,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) Ptr rrc = CreateObject (); Ptr ccmEnbManager = m_enbComponentCarrierManagerFactory.Create (); - rrc->ConfigureCarriers(m_componentCarrierPhyParams, m_noOfCcs); + rrc->ConfigureCarriers(ccMap, m_noOfCcs); //ComponentCarrierManager SAP rrc->SetLteCcmRrcSapProvider (ccmEnbManager->GetLteCcmRrcSapProvider ()); diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 8f2cfbef1f4..cb60d1013bc 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1398,26 +1398,26 @@ UeManager::BuildNonCriticalExtentionConfigurationCa () std::list SccCon; // sCellToReleaseList is always empty since no Scc is released - std::map::iterator it = m_rrc->m_componentCarrierPhyConf.begin(); + auto it = m_rrc->m_componentCarrierPhyConf.begin(); it++; for (;it!=m_rrc->m_componentCarrierPhyConf.end(); it++) { uint8_t ccId = it->first; - ComponentCarrier eNbCcm = it->second; + Ptr eNbCcm = it->second; LteRrcSap::SCellToAddMod component; component.sCellIndex = ccId; - component.cellIdentification.physCellId = m_rrc->m_cellId; - component.cellIdentification.dlCarrierFreq = eNbCcm.m_dlEarfcn; + component.cellIdentification.physCellId = eNbCcm->GetCellId (); + component.cellIdentification.dlCarrierFreq = eNbCcm->GetDlEarfcn (); component.radioResourceConfigCommonSCell.haveNonUlConfiguration = true; - component.radioResourceConfigCommonSCell.nonUlConfiguration.dlBandwidth = eNbCcm.m_dlBandwidth; + component.radioResourceConfigCommonSCell.nonUlConfiguration.dlBandwidth = eNbCcm->GetDlBandwidth (); component.radioResourceConfigCommonSCell.nonUlConfiguration.antennaInfoCommon.antennaPortsCount = 0; component.radioResourceConfigCommonSCell.nonUlConfiguration.pdschConfigCommon.referenceSignalPower = m_rrc->m_cphySapProvider.at (0)->GetReferenceSignalPower (); component.radioResourceConfigCommonSCell.nonUlConfiguration.pdschConfigCommon.pb = 0; component.radioResourceConfigCommonSCell.haveUlConfiguration = true; - component.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulCarrierFreq = eNbCcm.m_ulEarfcn; - component.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulBandwidth = eNbCcm.m_ulBandwidth; + component.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulCarrierFreq = eNbCcm->GetUlEarfcn (); + component.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulBandwidth = eNbCcm->GetUlBandwidth (); component.radioResourceConfigCommonSCell.ulConfiguration.ulPowerControlCommonSCell.alpha = 0; //component.radioResourceConfigCommonSCell.ulConfiguration.soundingRsUlConfigCommon.type = LteRrcSap::SoundingRsUlConfigDedicated::SETUP; component.radioResourceConfigCommonSCell.ulConfiguration.soundingRsUlConfigCommon.srsBandwidthConfig = 0; @@ -1495,7 +1495,7 @@ LteEnbRrc::LteEnbRrc () m_ffrRrcSapProvider.push_back (0); } -void LteEnbRrc::ConfigureCarriers(std::map ccPhyConf, uint16_t numberOfComponentCarriers) +void LteEnbRrc::ConfigureCarriers(std::map> ccPhyConf, uint16_t numberOfComponentCarriers) { NS_ASSERT_MSG (!m_carriersConfigured, "Secondary carriers can be configured only once."); m_componentCarrierPhyConf = ccPhyConf; @@ -2004,23 +2004,23 @@ LteEnbRrc::AddUeMeasReportConfig (LteRrcSap::ReportConfigEutra config) void LteEnbRrc::ConfigureCell (uint16_t cellId) { - std::map::iterator it = m_componentCarrierPhyConf.begin (); - uint8_t ulBandwidth = it->second.m_ulBandwidth; - uint8_t dlBandwidth = it->second.m_dlBandwidth; - uint32_t ulEarfcn = it->second.m_ulEarfcn; - uint32_t dlEarfcn = it->second.m_dlEarfcn; + auto it = m_componentCarrierPhyConf.begin (); + uint8_t ulBandwidth = it->second->GetUlBandwidth (); + uint8_t dlBandwidth = it->second->GetDlBandwidth (); + uint32_t ulEarfcn = it->second->GetUlEarfcn (); + uint32_t dlEarfcn = it->second->GetDlEarfcn (); NS_LOG_FUNCTION (this << (uint16_t) ulBandwidth << (uint16_t) dlBandwidth << ulEarfcn << dlEarfcn << cellId); NS_ASSERT (!m_configured); for (it = m_componentCarrierPhyConf.begin (); it != m_componentCarrierPhyConf.end (); ++it) { - m_cphySapProvider[it->first]->SetBandwidth (it->second.m_ulBandwidth, it->second.m_dlBandwidth); - m_cphySapProvider[it->first]->SetEarfcn (it->second.m_ulEarfcn, it->second.m_dlEarfcn); + m_cphySapProvider[it->first]->SetBandwidth (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); + m_cphySapProvider[it->first]->SetEarfcn (it->second->GetUlEarfcn (), it->second->GetDlEarfcn ()); m_cphySapProvider[it->first]->SetCellId (cellId); - m_cmacSapProvider[it->first]->ConfigureMac (it->second.m_ulBandwidth, it->second.m_dlBandwidth); + m_cmacSapProvider[it->first]->ConfigureMac (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); m_ffrRrcSapProvider[it->first]->SetCellId (cellId); - m_ffrRrcSapProvider[it->first]->SetBandwidth (it->second.m_ulBandwidth, it->second.m_dlBandwidth); + m_ffrRrcSapProvider[it->first]->SetBandwidth (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); } m_dlEarfcn = dlEarfcn; diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index ba08c19074b..f4893ebd418 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -851,7 +851,7 @@ class LteEnbRrc : public Object * \param ccPhyConf the component carrier configuration * \param numberOfCarriers the number of carriers */ - void ConfigureCarriers (std::map ccPhyConf, uint16_t numberOfCarriers); + void ConfigureCarriers (std::map> ccPhyConf, uint16_t numberOfCarriers); /** * set the cell id of this eNB @@ -1549,7 +1549,7 @@ class LteEnbRrc : public Object bool m_carriersConfigured; ///< are carriers configured - std::map m_componentCarrierPhyConf; ///< component carrier phy configuration + std::map> m_componentCarrierPhyConf; ///< component carrier phy configuration }; // end of `class LteEnbRrc` From 2faacd8384837522678c709364ce038fbfdc110b Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 24 May 2017 11:55:11 +0300 Subject: [PATCH 097/551] lte: Make sure CC map is set on LteEnbNetDevice before cell configuration --- src/lte/model/lte-enb-net-device.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/model/lte-enb-net-device.cc b/src/lte/model/lte-enb-net-device.cc index 13e2f33c5f9..c5d248ca44c 100644 --- a/src/lte/model/lte-enb-net-device.cc +++ b/src/lte/model/lte-enb-net-device.cc @@ -342,6 +342,7 @@ LteEnbNetDevice::GetCcMap () void LteEnbNetDevice::SetCcMap (std::map< uint8_t, Ptr > ccm) { + NS_ASSERT_MSG (!m_isConfigured, "attempt to set CC map after configuration"); m_ccMap = ccm; } From f672b50a2807982c6de359d9f4737633aadc039c Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 1 Jun 2017 13:25:39 +0300 Subject: [PATCH 098/551] lte: use the same pathloss model factory for uplink and downlink Uplink and downlink pathloss model objects are still different, because if non-spectrum pathloss model is used, Frequency attribute has to be set to different values for uplink and downlink. --- src/lte/helper/lte-helper.cc | 15 ++++++--------- src/lte/helper/lte-helper.h | 6 ++---- 2 files changed, 8 insertions(+), 13 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index 818eb3456ce..ca3ec520a1f 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -233,7 +233,7 @@ LteHelper::ChannelModelInitialization (void) m_downlinkChannel = m_channelFactory.Create (); m_uplinkChannel = m_channelFactory.Create (); - m_downlinkPathlossModel = m_dlPathlossModelFactory.Create (); + m_downlinkPathlossModel = m_pathlossModelFactory.Create (); Ptr dlSplm = m_downlinkPathlossModel->GetObject (); if (dlSplm != 0) { @@ -248,7 +248,7 @@ LteHelper::ChannelModelInitialization (void) m_downlinkChannel->AddPropagationLossModel (dlPlm); } - m_uplinkPathlossModel = m_ulPathlossModelFactory.Create (); + m_uplinkPathlossModel = m_pathlossModelFactory.Create (); Ptr ulSplm = m_uplinkPathlossModel->GetObject (); if (ulSplm != 0) { @@ -388,18 +388,15 @@ void LteHelper::SetPathlossModelType (std::string type) { NS_LOG_FUNCTION (this << type); - m_dlPathlossModelFactory = ObjectFactory (); - m_dlPathlossModelFactory.SetTypeId (type); - m_ulPathlossModelFactory = ObjectFactory (); - m_ulPathlossModelFactory.SetTypeId (type); + m_pathlossModelFactory = ObjectFactory (); + m_pathlossModelFactory.SetTypeId (type); } void LteHelper::SetPathlossModelAttribute (std::string n, const AttributeValue &v) { NS_LOG_FUNCTION (this << n); - m_dlPathlossModelFactory.Set (n, v); - m_ulPathlossModelFactory.Set (n, v); + m_pathlossModelFactory.Set (n, v); } void @@ -1316,7 +1313,7 @@ LteHelper::EnableLogComponents (void) LogComponentEnable ("LteInterference", LOG_LEVEL_ALL); LogComponentEnable ("LteChunkProcessor", LOG_LEVEL_ALL); - std::string propModelStr = m_dlPathlossModelFactory.GetTypeId ().GetName ().erase (0,5).c_str (); + std::string propModelStr = m_pathlossModelFactory.GetTypeId ().GetName ().erase (0,5).c_str (); LogComponentEnable ("LteNetDevice", LOG_LEVEL_ALL); LogComponentEnable ("LteUeNetDevice", LOG_LEVEL_ALL); LogComponentEnable ("LteEnbNetDevice", LOG_LEVEL_ALL); diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index 94461aea893..0a1f8a72888 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -754,10 +754,8 @@ class LteHelper : public Object ObjectFactory m_ueNetDeviceFactory; /// Factory of antenna object for UE. ObjectFactory m_ueAntennaModelFactory; - /// Factory of path loss model object for the downlink channel. - ObjectFactory m_dlPathlossModelFactory; - /// Factory of path loss model object for the uplink channel. - ObjectFactory m_ulPathlossModelFactory; + /// Factory of path loss model object. + ObjectFactory m_pathlossModelFactory; /// Factory of both the downlink and uplink LTE channels. ObjectFactory m_channelFactory; From c54696446619c20f9172c661c16863b339b87912 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 6 Jun 2017 15:10:20 +0300 Subject: [PATCH 099/551] lte: Add LteHelper::HandoverRequest version that accepts CellId It is to be used to trigger handover between different component carriers of the same eNB. --- src/lte/helper/lte-helper.cc | 16 ++++++++++++---- src/lte/helper/lte-helper.h | 22 ++++++++++++++++++---- 2 files changed, 30 insertions(+), 8 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index ca3ec520a1f..eaef6fabf51 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -1228,15 +1228,23 @@ LteHelper::HandoverRequest (Time hoTime, Ptr ueDev, Ptr so { NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetEnbDev); NS_ASSERT_MSG (m_epcHelper, "Handover requires the use of the EPC - did you forget to call LteHelper::SetEpcHelper () ?"); - Simulator::Schedule (hoTime, &LteHelper::DoHandoverRequest, this, ueDev, sourceEnbDev, targetEnbDev); + uint16_t targetCellId = targetEnbDev->GetObject ()->GetCellId (); + Simulator::Schedule (hoTime, &LteHelper::DoHandoverRequest, this, ueDev, sourceEnbDev, targetCellId); } void -LteHelper::DoHandoverRequest (Ptr ueDev, Ptr sourceEnbDev, Ptr targetEnbDev) +LteHelper::HandoverRequest (Time hoTime, Ptr ueDev, Ptr sourceEnbDev, uint16_t targetCellId) { - NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetEnbDev); + NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetCellId); + NS_ASSERT_MSG (m_epcHelper, "Handover requires the use of the EPC - did you forget to call LteHelper::SetEpcHelper () ?"); + Simulator::Schedule (hoTime, &LteHelper::DoHandoverRequest, this, ueDev, sourceEnbDev, targetCellId); +} + +void +LteHelper::DoHandoverRequest (Ptr ueDev, Ptr sourceEnbDev, uint16_t targetCellId) +{ + NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetCellId); - uint16_t targetCellId = targetEnbDev->GetObject ()->GetCellId (); Ptr sourceRrc = sourceEnbDev->GetObject ()->GetRrc (); uint16_t rnti = ueDev->GetObject ()->GetRrc ()->GetRnti (); sourceRrc->SendHandoverRequest (rnti, targetCellId); diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index 0a1f8a72888..0508765a873 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -516,6 +516,21 @@ class LteHelper : public Object Ptr sourceEnbDev, Ptr targetEnbDev); + /** + * Manually trigger an X2-based handover. + * + * \param hoTime when the handover shall be initiated + * \param ueDev the UE that hands off, must be of the type LteUeNetDevice + * \param sourceEnbDev source eNB, must be of the type LteEnbNetDevice + * (originally the UE is attached to this eNB) + * \param targetCellId target CellId (the UE primary component carrier will + * be connected to this cell after the handover) + * + * \warning Requires the use of EPC mode. See SetEpcHelper() method + */ + void HandoverRequest (Time hoTime, Ptr ueDev, + Ptr sourceEnbDev, uint16_t targetCellId); + /** * Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation). * @@ -697,16 +712,15 @@ class LteHelper : public Object * \param ueDev the UE that hands off, must be of the type LteUeNetDevice * \param sourceEnbDev source eNB, must be of the type LteEnbNetDevice * (originally the UE is attached to this eNB) - * \param targetEnbDev target eNB, must be of the type LteEnbNetDevice - * (the UE would be connected to this eNB after the - * handover) + * \param targetCellId target CellId (the UE primary component carrier will + * be connected to this cell after the handover) * * This method is normally scheduled by HandoverRequest() to run at a specific * time where a manual handover is desired by the simulation user. */ void DoHandoverRequest (Ptr ueDev, Ptr sourceEnbDev, - Ptr targetEnbDev); + uint16_t targetCellId); /** From 238fe2cccf6d081b186e1fe8ee359913e84d7969 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 6 Jun 2017 18:51:45 +0300 Subject: [PATCH 100/551] lte: Set Cell ID for ComponentCarrierEnb --- src/lte/helper/lte-helper.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index eaef6fabf51..f4deab50252 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -536,6 +536,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) cc->SetDlEarfcn(it->second.GetDlEarfcn()); cc->SetUlEarfcn(it->second.GetUlEarfcn()); cc->SetAsPrimary(it->second.IsPrimary()); + cc->SetCellId (cellId); ccMap [it->first] = cc; } NS_ABORT_MSG_IF (m_useCa && ccMap.size()<2, "You have to either specify carriers or disable carrier aggregation"); From af31e71732fa061fcedc8738c6df2e6580453404 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 24 May 2017 15:13:43 +0300 Subject: [PATCH 101/551] lte: Pass all cell configuration to LteEnbRrc::ConfigureCell --- src/lte/model/lte-enb-net-device.cc | 3 ++- src/lte/model/lte-enb-rrc.cc | 28 +++++++++++++++------------- src/lte/model/lte-enb-rrc.h | 4 +++- 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/src/lte/model/lte-enb-net-device.cc b/src/lte/model/lte-enb-net-device.cc index c5d248ca44c..8b4c5d284ff 100644 --- a/src/lte/model/lte-enb-net-device.cc +++ b/src/lte/model/lte-enb-net-device.cc @@ -390,7 +390,8 @@ LteEnbNetDevice::UpdateConfig (void) { NS_LOG_LOGIC (this << " Configure cell " << m_cellId); // we have to make sure that this function is called only once - m_rrc->ConfigureCell (m_cellId); + NS_ASSERT (!m_ccMap.empty ()); + m_rrc->ConfigureCell (m_ccMap); m_isConfigured = true; } diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index cb60d1013bc..c2377e633fa 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -2002,25 +2002,27 @@ LteEnbRrc::AddUeMeasReportConfig (LteRrcSap::ReportConfigEutra config) } void -LteEnbRrc::ConfigureCell (uint16_t cellId) +LteEnbRrc::ConfigureCell (std::map> ccPhyConf) { - auto it = m_componentCarrierPhyConf.begin (); + auto it = ccPhyConf.begin (); + NS_ASSERT (it != ccPhyConf.end ()); uint8_t ulBandwidth = it->second->GetUlBandwidth (); uint8_t dlBandwidth = it->second->GetDlBandwidth (); uint32_t ulEarfcn = it->second->GetUlEarfcn (); uint32_t dlEarfcn = it->second->GetDlEarfcn (); + uint16_t cellId = it->second->GetCellId (); NS_LOG_FUNCTION (this << (uint16_t) ulBandwidth << (uint16_t) dlBandwidth - << ulEarfcn << dlEarfcn << cellId); + << ulEarfcn << dlEarfcn); NS_ASSERT (!m_configured); - for (it = m_componentCarrierPhyConf.begin (); it != m_componentCarrierPhyConf.end (); ++it) + for (const auto &it: ccPhyConf) { - m_cphySapProvider[it->first]->SetBandwidth (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); - m_cphySapProvider[it->first]->SetEarfcn (it->second->GetUlEarfcn (), it->second->GetDlEarfcn ()); - m_cphySapProvider[it->first]->SetCellId (cellId); - m_cmacSapProvider[it->first]->ConfigureMac (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); - m_ffrRrcSapProvider[it->first]->SetCellId (cellId); - m_ffrRrcSapProvider[it->first]->SetBandwidth (it->second->GetUlBandwidth (), it->second->GetDlBandwidth ()); + m_cphySapProvider.at (it.first)->SetBandwidth (it.second->GetUlBandwidth (), it.second->GetDlBandwidth ()); + m_cphySapProvider.at (it.first)->SetEarfcn (it.second->GetUlEarfcn (), it.second->GetDlEarfcn ()); + m_cphySapProvider.at (it.first)->SetCellId (it.second->GetCellId ()); + m_cmacSapProvider.at (it.first)->ConfigureMac (it.second->GetUlBandwidth (), it.second->GetDlBandwidth ()); + m_ffrRrcSapProvider.at (it.first)->SetCellId (it.second->GetCellId ()); + m_ffrRrcSapProvider.at (it.first)->SetBandwidth (it.second->GetUlBandwidth (), it.second->GetDlBandwidth ()); } m_dlEarfcn = dlEarfcn; @@ -2064,10 +2066,10 @@ LteEnbRrc::ConfigureCell (uint16_t cellId) m_sib1.cellSelectionInfo.qQualMin = -34; // not used, set as minimum value m_sib1.cellSelectionInfo.qRxLevMin = m_qRxLevMin; // set as minimum value - for (it = m_componentCarrierPhyConf.begin (); it != m_componentCarrierPhyConf.end (); ++it) + for (const auto &it: ccPhyConf) { - m_cphySapProvider.at (it->first)->SetMasterInformationBlock (mib); - m_cphySapProvider.at (it->first)->SetSystemInformationBlockType1 (m_sib1); + m_cphySapProvider.at (it.first)->SetMasterInformationBlock (mib); + m_cphySapProvider.at (it.first)->SetSystemInformationBlockType1 (m_sib1); } /* * Enabling transmission of other SIB. The first time System Information is diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index f4893ebd418..49a6113dd0f 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -843,8 +843,10 @@ class LteEnbRrc : public Object * `LteHelper::InstallEnbDevice` (i.e. before the simulation starts). * * \warning Raises an error when executed more than once. + * + * \param ccPhyConf the component carrier configuration */ - void ConfigureCell (uint16_t cellId); + void ConfigureCell (std::map> ccPhyConf); /** * \brief Configure carriers. From fb258a0f491ff3bf70671d197f4e609a7b397e8a Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 3 Jun 2017 15:03:28 -0700 Subject: [PATCH 102/551] tcp: (fixes #2565) Notify normal close when entering TIME_WAIT --- src/internet/model/tcp-socket-base.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/internet/model/tcp-socket-base.cc b/src/internet/model/tcp-socket-base.cc index 3c3fbb46762..c8deabce6d9 100644 --- a/src/internet/model/tcp-socket-base.cc +++ b/src/internet/model/tcp-socket-base.cc @@ -3382,6 +3382,14 @@ TcpSocketBase::TimeWait () NS_LOG_DEBUG (TcpStateName[m_state] << " -> TIME_WAIT"); m_state = TIME_WAIT; CancelAllTimers (); + if (!m_closeNotified) + { + // Technically the connection is not fully closed, but we notify now + // because an implementation (real socket) would behave as if closed. + // Notify normal close when entering TIME_WAIT or leaving LAST_ACK. + NotifyNormalClose (); + m_closeNotified = true; + } // Move from TIME_WAIT to CLOSED after 2*MSL. Max segment lifetime is 2 min // according to RFC793, p.28 m_timewaitEvent = Simulator::Schedule (Seconds (2 * m_msl), From 06b2fe00ed046a1310c44c0a7d07aac7ac5d1e09 Mon Sep 17 00:00:00 2001 From: Luciano J Chaves Date: Sat, 3 Jun 2017 15:05:28 -0700 Subject: [PATCH 103/551] tcp: (fixes #2716) Patch for bug when closing the TCP connection --- src/internet/model/tcp-socket-base.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/internet/model/tcp-socket-base.cc b/src/internet/model/tcp-socket-base.cc index c8deabce6d9..d9dd7a26f29 100644 --- a/src/internet/model/tcp-socket-base.cc +++ b/src/internet/model/tcp-socket-base.cc @@ -2073,7 +2073,7 @@ TcpSocketBase::ProcessWait (Ptr packet, const TcpHeader& tcpHeader) // Extract the flags. PSH and URG are not honoured. uint8_t tcpflags = tcpHeader.GetFlags () & ~(TcpHeader::PSH | TcpHeader::URG); - if (packet->GetSize () > 0 && tcpflags != TcpHeader::ACK) + if (packet->GetSize () > 0 && !(tcpflags & TcpHeader::ACK)) { // Bare data, accept it ReceivedData (packet, tcpHeader); } From 6dffcbb2fa4c80ef90af71d2728d3934437c319c Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Mon, 5 Jun 2017 11:23:19 +0200 Subject: [PATCH 104/551] wifi: WifiMacQueue needs to override some QueueBase methods --- src/wifi/model/dca-txop.cc | 8 +++--- src/wifi/model/edca-txop-n.cc | 8 +++--- src/wifi/model/wifi-mac-queue.cc | 44 ++++++++++++++++++++++++++++---- src/wifi/model/wifi-mac-queue.h | 27 +++++++++++++++++--- 4 files changed, 70 insertions(+), 17 deletions(-) diff --git a/src/wifi/model/dca-txop.cc b/src/wifi/model/dca-txop.cc index 1f418ccf6e2..099190b94f9 100644 --- a/src/wifi/model/dca-txop.cc +++ b/src/wifi/model/dca-txop.cc @@ -240,7 +240,7 @@ DcaTxop::RestartAccessIfNeeded (void) { NS_LOG_FUNCTION (this); if ((m_currentPacket != 0 - || m_queue->HasPackets ()) + || !m_queue->IsEmpty ()) && !m_dcf->IsAccessRequested ()) { m_manager->RequestAccess (m_dcf); @@ -252,7 +252,7 @@ DcaTxop::StartAccessIfNeeded (void) { NS_LOG_FUNCTION (this); if (m_currentPacket == 0 - && m_queue->HasPackets () + && !m_queue->IsEmpty () && !m_dcf->IsAccessRequested ()) { m_manager->RequestAccess (m_dcf); @@ -360,7 +360,7 @@ bool DcaTxop::NeedsAccess (void) const { NS_LOG_FUNCTION (this); - return m_queue->HasPackets () || m_currentPacket != 0; + return !m_queue->IsEmpty () || m_currentPacket != 0; } void @@ -369,7 +369,7 @@ DcaTxop::NotifyAccessGranted (void) NS_LOG_FUNCTION (this); if (m_currentPacket == 0) { - if (!m_queue->HasPackets ()) + if (m_queue->IsEmpty ()) { NS_LOG_DEBUG ("queue empty"); return; diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index daef99e4416..a16a089e3aa 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -153,7 +153,7 @@ bool EdcaTxopN::NeedsAccess (void) const { NS_LOG_FUNCTION (this); - return m_queue->HasPackets () || m_currentPacket != 0 || m_baManager->HasPackets (); + return !m_queue->IsEmpty () || m_currentPacket != 0 || m_baManager->HasPackets (); } uint16_t EdcaTxopN::GetNextSequenceNumberFor (WifiMacHeader *hdr) @@ -186,7 +186,7 @@ EdcaTxopN::NotifyAccessGranted (void) m_startTxop = Simulator::Now (); if (m_currentPacket == 0) { - if (!m_queue->HasPackets () && !m_baManager->HasPackets ()) + if (m_queue->IsEmpty () && !m_baManager->HasPackets ()) { NS_LOG_DEBUG ("queue is empty"); return; @@ -724,7 +724,7 @@ EdcaTxopN::RestartAccessIfNeeded (void) { NS_LOG_FUNCTION (this); if ((m_currentPacket != 0 - || m_queue->HasPackets () || m_baManager->HasPackets ()) + || !m_queue->IsEmpty () || m_baManager->HasPackets ()) && !m_dcf->IsAccessRequested ()) { Ptr packet; @@ -765,7 +765,7 @@ EdcaTxopN::StartAccessIfNeeded (void) { //NS_LOG_FUNCTION (this); if (m_currentPacket == 0 - && (m_queue->HasPackets () || m_baManager->HasPackets ()) + && (!m_queue->IsEmpty () || m_baManager->HasPackets ()) && !m_dcf->IsAccessRequested ()) { Ptr packet; diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index 5ceae0da5b7..28bd5ea6944 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -403,7 +403,7 @@ WifiMacQueue::GetNPacketsByTidAndAddress (uint8_t tid, WifiMacHeader::AddressTyp template<> bool -WifiMacQueue::HasPackets (void) +WifiMacQueue::IsEmpty (void) { NS_LOG_FUNCTION (this); @@ -411,12 +411,46 @@ WifiMacQueue::HasPackets (void) { if (!TtlExceeded (it)) { - NS_LOG_DEBUG ("returns true"); - return true; + NS_LOG_DEBUG ("returns false"); + return false; } } - NS_LOG_DEBUG ("returns false"); - return false; + NS_LOG_DEBUG ("returns true"); + return true; +} + +template<> +uint32_t +WifiMacQueue::GetNPackets (void) +{ + NS_LOG_FUNCTION (this); + + // remove packets that stayed in the queue for too long + for (auto it = Head (); it != Tail (); ) + { + if (!TtlExceeded (it)) + { + it++; + } + } + return QueueBase::GetNPackets (); +} + +template<> +uint32_t +WifiMacQueue::GetNBytes (void) +{ + NS_LOG_FUNCTION (this); + + // remove packets that stayed in the queue for too long + for (auto it = Head (); it != Tail (); ) + { + if (!TtlExceeded (it)) + { + it++; + } + } + return QueueBase::GetNBytes (); } NS_OBJECT_TEMPLATE_CLASS_DEFINE (WifiQueue,WifiMacQueueItem); diff --git a/src/wifi/model/wifi-mac-queue.h b/src/wifi/model/wifi-mac-queue.h index 9815826f768..09e023c206c 100644 --- a/src/wifi/model/wifi-mac-queue.h +++ b/src/wifi/model/wifi-mac-queue.h @@ -284,13 +284,27 @@ class WifiQueue : public Queue uint32_t GetNPacketsByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address addr); + + /** + * \return true if the queue is empty; false otherwise + * + * Overrides the IsEmpty method provided by QueueBase + */ + bool IsEmpty (void); + /** - * This method must be used (instead of the IsEmpty method of the base class) - * to check whether there are packets with unexpired time to live in the queue + * \return The number of packets currently stored in the Queue * - * \return true if there are packets with unexpired time to live + * Overrides the GetNPackets method provided by QueueBase */ - bool HasPackets (void); + uint32_t GetNPackets (void); + + /** + * \return The number of bytes currently occupied by the packets in the Queue + * + * Overrides the GetNBytes method provided by QueueBase + */ + uint32_t GetNBytes (void); private: /** @@ -307,6 +321,11 @@ class WifiQueue : public Queue DropPolicy m_dropPolicy; //!< Drop behavior of queue }; +/// Forward declare overridden methods to avoid specializing after instantiation +template<> bool WifiQueue::IsEmpty (void); +template<> uint32_t WifiQueue::GetNPackets (void); +template<> uint32_t WifiQueue::GetNBytes (void); + /// Declare WifiMacQueue as a specialization of template class WifiQueue typedef WifiQueue WifiMacQueue; From 9dfbd94ae1c11755c04cec4eedbf7040cb18826a Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Mon, 5 Jun 2017 12:54:05 -0700 Subject: [PATCH 105/551] point-to-point: Update bindings --- src/point-to-point/bindings/modulegen__gcc_ILP32.py | 8 ++++---- src/point-to-point/bindings/modulegen__gcc_LP64.py | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/point-to-point/bindings/modulegen__gcc_ILP32.py b/src/point-to-point/bindings/modulegen__gcc_ILP32.py index 774e20f8f0f..24ed0f12a50 100644 --- a/src/point-to-point/bindings/modulegen__gcc_ILP32.py +++ b/src/point-to-point/bindings/modulegen__gcc_ILP32.py @@ -5647,10 +5647,10 @@ def register_Ns3PointToPointChannel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## point-to-point-channel.h (module 'point-to-point'): bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] + ## point-to-point-channel.h (module 'point-to-point'): bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] cls.add_method('TransmitStart', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], + [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], is_virtual=True) ## point-to-point-channel.h (module 'point-to-point'): ns3::Time ns3::PointToPointChannel::GetDelay() const [member function] cls.add_method('GetDelay', @@ -5863,10 +5863,10 @@ def register_Ns3PointToPointRemoteChannel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## point-to-point-remote-channel.h (module 'point-to-point'): bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] + ## point-to-point-remote-channel.h (module 'point-to-point'): bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] cls.add_method('TransmitStart', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], + [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], is_virtual=True) return diff --git a/src/point-to-point/bindings/modulegen__gcc_LP64.py b/src/point-to-point/bindings/modulegen__gcc_LP64.py index 774e20f8f0f..24ed0f12a50 100644 --- a/src/point-to-point/bindings/modulegen__gcc_LP64.py +++ b/src/point-to-point/bindings/modulegen__gcc_LP64.py @@ -5647,10 +5647,10 @@ def register_Ns3PointToPointChannel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## point-to-point-channel.h (module 'point-to-point'): bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] + ## point-to-point-channel.h (module 'point-to-point'): bool ns3::PointToPointChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] cls.add_method('TransmitStart', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], + [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], is_virtual=True) ## point-to-point-channel.h (module 'point-to-point'): ns3::Time ns3::PointToPointChannel::GetDelay() const [member function] cls.add_method('GetDelay', @@ -5863,10 +5863,10 @@ def register_Ns3PointToPointRemoteChannel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## point-to-point-remote-channel.h (module 'point-to-point'): bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] + ## point-to-point-remote-channel.h (module 'point-to-point'): bool ns3::PointToPointRemoteChannel::TransmitStart(ns3::Ptr p, ns3::Ptr src, ns3::Time txTime) [member function] cls.add_method('TransmitStart', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], + [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::PointToPointNetDevice >', 'src'), param('ns3::Time', 'txTime')], is_virtual=True) return From c4f5f2a2b68d7daf6939bfd3882eb68454f46c74 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Mon, 5 Jun 2017 12:55:23 -0700 Subject: [PATCH 106/551] fix formatting error leading to build error --- src/traffic-control/doc/red.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/traffic-control/doc/red.rst b/src/traffic-control/doc/red.rst index d066c937d49..1c41a0498fa 100644 --- a/src/traffic-control/doc/red.rst +++ b/src/traffic-control/doc/red.rst @@ -182,7 +182,7 @@ as shown below: .. sourcecode:: cpp -Config::SetDefault ("ns3::RedQueueDisc::NLRED", BooleanValue (true)); + Config::SetDefault ("ns3::RedQueueDisc::NLRED", BooleanValue (true)); Examples ======== From 30c922ba2c42cb975ba221f792c2935552db0a1d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Mon, 5 Jun 2017 12:58:57 -0700 Subject: [PATCH 107/551] documentation: Add missing ref to nix-vector-routing.rst --- doc/models/Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/models/Makefile b/doc/models/Makefile index 066bdf15b58..112d26c5027 100644 --- a/doc/models/Makefile +++ b/doc/models/Makefile @@ -58,6 +58,7 @@ SOURCES = \ $(SRC)/network/doc/simple.rst \ $(SRC)/network/doc/queue.rst \ $(SRC)/network/doc/queue-limits.rst \ + $(SRC)/nix-vector-routing/doc/nix-vector-routing.rst \ $(SRC)/internet/doc/internet-stack.rst \ $(SRC)/internet/doc/ipv4.rst \ $(SRC)/internet/doc/ipv6.rst \ From 3cab87c732a26d9e2e47dbd99ed0e6c50adac252 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Mon, 5 Jun 2017 23:24:03 +0200 Subject: [PATCH 108/551] wifi: Avoid calling WifiMacQueue::GetNPackets whenever possible --- src/wifi/model/mac-low.cc | 6 +++--- src/wifi/model/wifi-mac-queue.cc | 26 ++++++++++++++++---------- 2 files changed, 19 insertions(+), 13 deletions(-) diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 0bb590da419..73f2f374f5a 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -674,7 +674,7 @@ MacLow::StartTransmission (Ptr packet, //queue when previous RTS request has failed. m_ampdu = false; } - else if (m_currentHdr.IsQosData () && m_aggregateQueue[GetTid (packet, *hdr)]->GetNPackets () > 0) + else if (m_currentHdr.IsQosData () && !m_aggregateQueue[GetTid (packet, *hdr)]->IsEmpty ()) { //m_aggregateQueue > 0 occurs when a RTS/CTS exchange failed before an A-MPDU transmission. //In that case, we transmit the same A-MPDU as previously. @@ -2026,7 +2026,7 @@ MacLow::SendDataAfterCts (Mac48Address source, Time duration) if (m_currentHdr.IsQosData ()) { uint8_t tid = GetTid (m_currentPacket, m_currentHdr); - if (m_aggregateQueue[GetTid (m_currentPacket, m_currentHdr)]->GetNPackets () != 0) + if (!m_aggregateQueue[GetTid (m_currentPacket, m_currentHdr)]->IsEmpty ()) { for (std::vector::size_type i = 0; i != m_txPackets[tid].size (); i++) { @@ -3006,7 +3006,7 @@ MacLow::AggregateToAmpdu (Ptr packet, const WifiMacHeader hdr) void MacLow::FlushAggregateQueue (uint8_t tid) { - if (m_aggregateQueue[tid]->GetNPackets () > 0) + if (!m_aggregateQueue[tid]->IsEmpty ()) { NS_LOG_DEBUG ("Flush aggregate queue"); m_aggregateQueue[tid]->Flush (); diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index 28bd5ea6944..029cc83c8de 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -163,15 +163,18 @@ WifiMacQueue::Enqueue (Ptr item) NS_ASSERT_MSG (GetMode () == QueueBase::QUEUE_MODE_PACKETS, "WifiMacQueues must be in packet mode"); - // if the queue is full, check if the time-to-live of the oldest packet has - // expired. If so, it can be removed so as to make room for the new packet. - if (GetNPackets () == GetMaxPackets ()) + // if the queue is full, remove the first stale packet (if any) encountered + // starting from the head of the queue, in order to make room for the new packet. + if (QueueBase::GetNPackets () == GetMaxPackets ()) { auto it = Head (); - TtlExceeded (it); + while (it != Tail () && !TtlExceeded (it)) + { + it++; + } } - if (GetNPackets () == GetMaxPackets () && m_dropPolicy == DROP_OLDEST) + if (QueueBase::GetNPackets () == GetMaxPackets () && m_dropPolicy == DROP_OLDEST) { NS_LOG_DEBUG ("Remove the oldest item in the queue"); DoRemove (Head ()); @@ -188,15 +191,18 @@ WifiMacQueue::PushFront (Ptr item) NS_ASSERT_MSG (GetMode () == QueueBase::QUEUE_MODE_PACKETS, "WifiMacQueues must be in packet mode"); - // if the queue is full, check if the time-to-live of the oldest packet has - // expired. If so, it can be removed so as to make room for the new packet. - if (GetNPackets () == GetMaxPackets ()) + // if the queue is full, remove the first stale packet (if any) encountered + // starting from the head of the queue, in order to make room for the new packet. + if (QueueBase::GetNPackets () == GetMaxPackets ()) { auto it = Head (); - TtlExceeded (it); + while (it != Tail () && !TtlExceeded (it)) + { + it++; + } } - if (GetNPackets () == GetMaxPackets () && m_dropPolicy == DROP_OLDEST) + if (QueueBase::GetNPackets () == GetMaxPackets () && m_dropPolicy == DROP_OLDEST) { NS_LOG_DEBUG ("Remove the oldest item in the queue"); DoRemove (Head ()); From 543da6092aed6934afbe4cd759d2750e9602e1fd Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Tue, 6 Jun 2017 11:18:07 +0200 Subject: [PATCH 109/551] various: (fixes #2668) Make template classes use NS_LOG_* macros --- doc/manual/source/logging.rst | 54 +++++++++++++++++++ src/core/model/log.cc | 18 +++++++ src/core/model/log.h | 42 ++++++++++++++- src/network/utils/drop-tail-queue.cc | 2 + src/network/utils/drop-tail-queue.h | 21 ++++---- .../utils/net-device-queue-interface.cc | 6 --- .../utils/net-device-queue-interface.h | 39 +++++--------- src/network/utils/queue.cc | 6 --- src/network/utils/queue.h | 51 +++++++----------- src/wifi/model/wifi-mac-queue.cc | 1 + src/wifi/model/wifi-mac-queue.h | 2 + 11 files changed, 161 insertions(+), 81 deletions(-) diff --git a/doc/manual/source/logging.rst b/doc/manual/source/logging.rst index 1d37e3e365f..3a5a1afe2eb 100644 --- a/doc/manual/source/logging.rst +++ b/doc/manual/source/logging.rst @@ -342,6 +342,60 @@ Adding logging to your code is very simple: 2. Add logging statements (macro calls) to your functions and function bodies. +In case you want to add logging statements to the methods of your template class +(which are defined in an header file): + +1. Invoke the ``NS_LOG_TEMPLATE_DECLARE;`` macro in the private section of + your class declaration. For instance: + + :: + + template + class Queue : public QueueBase + { + ... + private: + std::list > m_packets; //!< the items in the queue + NS_LOG_TEMPLATE_DECLARE; //!< the log component + }; + + This requires you to perform these steps for all the subclasses of your class. + +2. Invoke the ``NS_LOG_TEMPLATE_DEFINE (...);`` macro in the constructor of + your class by providing the name of a log component registered by calling + the ``NS_LOG_COMPONENT_DEFINE (...);`` macro in some module. For instance: + + :: + + template + Queue::Queue () + : NS_LOG_TEMPLATE_DEFINE ("Queue") + { + } + +3. Add logging statements (macro calls) to the methods of your class. + +In case you want to add logging statements to a static member template +(which is defined in an header file): + +1. Invoke the ``NS_LOG_STATIC_TEMPLATE_DEFINE (...);`` macro in your static + method by providing the name of a log component registered by calling + the ``NS_LOG_COMPONENT_DEFINE (...);`` macro in some module. For instance: + + :: + + template + void + NetDeviceQueue::PacketEnqueued (Ptr > queue, + Ptr ndqi, + uint8_t txq, Ptr item) + { + + NS_LOG_STATIC_TEMPLATE_DEFINE ("NetDeviceQueueInterface"); + ... + +2. Add logging statements (macro calls) to your static method. + Controlling timestamp precision ******************************* diff --git a/src/core/model/log.cc b/src/core/model/log.cc index 299d1f9e33a..06a76f547db 100644 --- a/src/core/model/log.cc +++ b/src/core/model/log.cc @@ -23,6 +23,7 @@ #include #include #include "assert.h" +#include #include "ns3/core-config.h" #include "fatal-error.h" @@ -130,6 +131,23 @@ LogComponent::LogComponent (const std::string & name, components->insert (std::make_pair (name, this)); } +LogComponent & +GetLogComponent (const std::string name) +{ + LogComponent::ComponentList *components = LogComponent::GetComponentList (); + LogComponent* ret; + + try + { + ret = components->at (name); + } + catch (std::out_of_range&) + { + NS_FATAL_ERROR ("Log component \"" << name << "\" does not exist."); + } + return *ret; +} + void LogComponent::EnvVarCheck (void) { diff --git a/src/core/model/log.h b/src/core/model/log.h index b2b2de9bddf..cab4a8372c3 100644 --- a/src/core/model/log.h +++ b/src/core/model/log.h @@ -212,6 +212,39 @@ void LogComponentDisableAll (enum LogLevel level); #define NS_LOG_COMPONENT_DEFINE_MASK(name, mask) \ static ns3::LogComponent g_log = ns3::LogComponent (name, __FILE__, mask) +/** + * Declare a reference to a Log component. + * + * This macro should be used in the declaration of template classes + * to allow their methods (defined in an header file) to make use of + * the NS_LOG_* macros. This macro should be used in the private + * section to prevent subclasses from using the same log component + * as the base class. + */ +#define NS_LOG_TEMPLATE_DECLARE LogComponent & g_log + +/** + * Initialize a reference to a Log component. + * + * This macro should be used in the constructor of template classes + * to allow their methods (defined in an header file) to make use of + * the NS_LOG_* macros. + * + * \param [in] name The log component name. + */ +#define NS_LOG_TEMPLATE_DEFINE(name) g_log (GetLogComponent (name)) + +/** + * Declare and initialize a reference to a Log component. + * + * This macro should be used in static template methods to allow their + * methods (defined in an header file) to make use of the NS_LOG_* macros. + * + * \param [in] name The log component name. + */ +#define NS_LOG_STATIC_TEMPLATE_DEFINE(name) \ + static LogComponent & g_log = GetLogComponent (name) + /** * Use \ref NS_LOG to output a message of level LOG_ERROR. * @@ -409,7 +442,14 @@ class LogComponent }; // class LogComponent - +/** + * Get the LogComponent registered with the given name. + * + * \param [in] name The name of the LogComponent. + * \return a reference to the requested LogComponent + */ +LogComponent & GetLogComponent (const std::string name); + /** * Insert `, ` when streaming function arguments. */ diff --git a/src/network/utils/drop-tail-queue.cc b/src/network/utils/drop-tail-queue.cc index ef417e81acc..a5db143c2a6 100644 --- a/src/network/utils/drop-tail-queue.cc +++ b/src/network/utils/drop-tail-queue.cc @@ -20,6 +20,8 @@ namespace ns3 { +NS_LOG_COMPONENT_DEFINE ("DropTailQueue"); + NS_OBJECT_TEMPLATE_CLASS_DEFINE (DropTailQueue,Packet); } // namespace ns3 diff --git a/src/network/utils/drop-tail-queue.h b/src/network/utils/drop-tail-queue.h index 51d65a9ec3c..f2cee28e52f 100644 --- a/src/network/utils/drop-tail-queue.h +++ b/src/network/utils/drop-tail-queue.h @@ -58,6 +58,8 @@ class DropTailQueue : public Queue using Queue::DoDequeue; using Queue::DoRemove; using Queue::DoPeek; + + NS_LOG_TEMPLATE_DECLARE; //!< redefinition of the log component }; @@ -79,22 +81,23 @@ DropTailQueue::GetTypeId (void) template DropTailQueue::DropTailQueue () : - Queue () + Queue (), + NS_LOG_TEMPLATE_DEFINE ("DropTailQueue") { - QUEUE_LOG (LOG_LOGIC, "DropTailQueue(" << this << ")"); + NS_LOG_FUNCTION (this); } template DropTailQueue::~DropTailQueue () { - QUEUE_LOG (LOG_LOGIC, "~DropTailQueue(" << this << ")"); + NS_LOG_FUNCTION (this); } template bool DropTailQueue::Enqueue (Ptr item) { - QUEUE_LOG (LOG_LOGIC, "DropTailQueue:Enqueue(" << this << ", " << item << ")"); + NS_LOG_FUNCTION (this << item); return DoEnqueue (Tail (), item); } @@ -103,11 +106,11 @@ template Ptr DropTailQueue::Dequeue (void) { - QUEUE_LOG (LOG_LOGIC, "DropTailQueue:Dequeue(" << this << ")"); + NS_LOG_FUNCTION (this); Ptr item = DoDequeue (Head ()); - QUEUE_LOG (LOG_LOGIC, "Popped " << item); + NS_LOG_LOGIC ("Popped " << item); return item; } @@ -116,11 +119,11 @@ template Ptr DropTailQueue::Remove (void) { - QUEUE_LOG (LOG_LOGIC, "DropTailQueue:Remove(" << this << ")"); + NS_LOG_FUNCTION (this); Ptr item = DoRemove (Head ()); - QUEUE_LOG (LOG_LOGIC, "Removed " << item); + NS_LOG_LOGIC ("Removed " << item); return item; } @@ -129,7 +132,7 @@ template Ptr DropTailQueue::Peek (void) const { - QUEUE_LOG (LOG_LOGIC, "DropTailQueue:Peek(" << this << ")"); + NS_LOG_FUNCTION (this); return DoPeek (Head ()); } diff --git a/src/network/utils/net-device-queue-interface.cc b/src/network/utils/net-device-queue-interface.cc index 699021fa23c..2c09e12981a 100644 --- a/src/network/utils/net-device-queue-interface.cc +++ b/src/network/utils/net-device-queue-interface.cc @@ -145,12 +145,6 @@ NetDeviceQueue::GetQueueLimits () return m_queueLimits; } -void -NetDeviceQueue::DoNsLog (const enum LogLevel level, std::string str) -{ - NS_LOG (level, str); -} - NS_OBJECT_ENSURE_REGISTERED (NetDeviceQueueInterface); diff --git a/src/network/utils/net-device-queue-interface.h b/src/network/utils/net-device-queue-interface.h index 274ba2c715e..37258b0164c 100644 --- a/src/network/utils/net-device-queue-interface.h +++ b/src/network/utils/net-device-queue-interface.h @@ -193,14 +193,6 @@ class NetDeviceQueue : public SimpleRefCount uint8_t txq, Ptr item); private: - /** - * \brief Pass messages to the ns-3 logging system - * - * \param level the log level - * \param str the message to log - */ - static void DoNsLog (const enum LogLevel level, std::string str); - bool m_stoppedByDevice; //!< True if the queue has been stopped by the device bool m_stoppedByQueueLimits; //!< True if the queue has been stopped by a queue limits object Ptr m_queueLimits; //!< Queue limits object @@ -338,14 +330,6 @@ class NetDeviceQueueInterface : public Object }; -#define NDQI_LOG(level,params) \ - { \ - std::stringstream ss; \ - ss << params; \ - DoNsLog (level, ss.str ()); \ - } - - /** * Implementation of the templates declared above. */ @@ -374,8 +358,9 @@ NetDeviceQueue::PacketEnqueued (Ptr > queue, Ptr ndqi, uint8_t txq, Ptr item) { - NDQI_LOG (LOG_LOGIC, "NetDeviceQueue:PacketEnqueued(" << queue << ", " << ndqi - << ", " << txq << ", " << item << ")"); + NS_LOG_STATIC_TEMPLATE_DEFINE ("NetDeviceQueueInterface"); + + NS_LOG_FUNCTION (queue << ndqi << txq << item); // Inform BQL ndqi->GetTxQueue (txq)->NotifyQueuedBytes (item->GetSize ()); @@ -390,8 +375,8 @@ NetDeviceQueue::PacketEnqueued (Ptr > queue, (queue->GetMode () == QueueBase::QUEUE_MODE_BYTES && queue->GetNBytes () + mtu > queue->GetMaxBytes ())) { - NDQI_LOG (LOG_DEBUG, "The device queue is being stopped (" << queue->GetNPackets () - << " packets and " << queue->GetNBytes () << " bytes inside)"); + NS_LOG_DEBUG ("The device queue is being stopped (" << queue->GetNPackets () + << " packets and " << queue->GetNBytes () << " bytes inside)"); ndqi->GetTxQueue (txq)->Stop (); } } @@ -402,8 +387,9 @@ NetDeviceQueue::PacketDequeued (Ptr > queue, Ptr ndqi, uint8_t txq, Ptr item) { - NDQI_LOG (LOG_LOGIC, "NetDeviceQueue:PacketDequeued(" << queue << ", " << ndqi - << ", " << txq << ", " << item << ")"); + NS_LOG_STATIC_TEMPLATE_DEFINE ("NetDeviceQueueInterface"); + + NS_LOG_FUNCTION (queue << ndqi << txq << item); // Inform BQL ndqi->GetTxQueue (txq)->NotifyTransmittedBytes (item->GetSize ()); @@ -429,16 +415,17 @@ NetDeviceQueue::PacketDiscarded (Ptr > queue, Ptr ndqi, uint8_t txq, Ptr item) { - NDQI_LOG (LOG_LOGIC, "NetDeviceQueue:PacketDiscarded(" << queue << ", " << ndqi - << ", " << txq << ", " << item << ")"); + NS_LOG_STATIC_TEMPLATE_DEFINE ("NetDeviceQueueInterface"); + + NS_LOG_FUNCTION (queue << ndqi << txq << item); // This method is called when a packet is discarded before being enqueued in the // device queue, likely because the queue is full. This should not happen if the // device correctly stops the queue. Anyway, stop the tx queue, so that the upper // layers do not send packets until there is room in the queue again. - NDQI_LOG (LOG_ERROR, "BUG! No room in the device queue for the received packet! (" - << queue->GetNPackets () << " packets and " << queue->GetNBytes () << " bytes inside)"); + NS_LOG_ERROR ("BUG! No room in the device queue for the received packet! (" + << queue->GetNPackets () << " packets and " << queue->GetNBytes () << " bytes inside)"); ndqi->GetTxQueue (txq)->Stop (); } diff --git a/src/network/utils/queue.cc b/src/network/utils/queue.cc index b5d7f226b1d..e7e64c3a59e 100644 --- a/src/network/utils/queue.cc +++ b/src/network/utils/queue.cc @@ -266,10 +266,4 @@ QueueBase::GetMaxBytes (void) const return m_maxBytes; } -void -QueueBase::DoNsLog (const enum LogLevel level, std::string str) const -{ - NS_LOG (level, str); -} - } // namespace ns3 diff --git a/src/network/utils/queue.h b/src/network/utils/queue.h index 5eef2b952fe..6085f1fa97f 100644 --- a/src/network/utils/queue.h +++ b/src/network/utils/queue.h @@ -229,15 +229,6 @@ class QueueBase : public Object double GetDroppedPacketsPerSecondVariance (void); #endif -protected: - /** - * \brief Actually pass messages to the ns-3 logging system - * - * \param level the log level - * \param str the message to log - */ - void DoNsLog (const enum LogLevel level, std::string str) const; - private: TracedValue m_nBytes; //!< Number of bytes in the queue uint32_t m_nTotalReceivedBytes; //!< Total received bytes @@ -417,6 +408,7 @@ class Queue : public QueueBase private: std::list > m_packets; //!< the items in the queue + NS_LOG_TEMPLATE_DECLARE; //!< the log component /// Traced callback: fired when a packet is enqueued TracedCallback > m_traceEnqueue; @@ -431,14 +423,6 @@ class Queue : public QueueBase }; -#define QUEUE_LOG(level,params) \ - { \ - std::stringstream ss; \ - ss << params; \ - QueueBase::DoNsLog (level, ss.str ()); \ - } - - /** * Implementation of the templates declared above. */ @@ -472,6 +456,7 @@ Queue::GetTypeId (void) template Queue::Queue () + : NS_LOG_TEMPLATE_DEFINE ("Queue") { } @@ -484,18 +469,18 @@ template bool Queue::DoEnqueue (ConstIterator pos, Ptr item) { - QUEUE_LOG (LOG_LOGIC, "Queue:DoEnqueue(" << this << ", " << item << ")"); + NS_LOG_FUNCTION (this << item); if (m_mode == QUEUE_MODE_PACKETS && (m_nPackets.Get () >= m_maxPackets)) { - QUEUE_LOG (LOG_LOGIC, "Queue full (at max packets) -- dropping pkt"); + NS_LOG_LOGIC ("Queue full (at max packets) -- dropping pkt"); DropBeforeEnqueue (item); return false; } if (m_mode == QUEUE_MODE_BYTES && (m_nBytes.Get () + item->GetSize () > m_maxBytes)) { - QUEUE_LOG (LOG_LOGIC, "Queue full (packet would exceed max bytes) -- dropping pkt"); + NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- dropping pkt"); DropBeforeEnqueue (item); return false; } @@ -509,7 +494,7 @@ Queue::DoEnqueue (ConstIterator pos, Ptr item) m_nPackets++; m_nTotalReceivedPackets++; - QUEUE_LOG (LOG_LOGIC, "m_traceEnqueue (p)"); + NS_LOG_LOGIC ("m_traceEnqueue (p)"); m_traceEnqueue (item); return true; @@ -519,11 +504,11 @@ template Ptr Queue::DoDequeue (ConstIterator pos) { - QUEUE_LOG (LOG_LOGIC, "Queue:DoDequeue(" << this << ")"); + NS_LOG_FUNCTION (this); if (m_nPackets.Get () == 0) { - QUEUE_LOG (LOG_LOGIC, "Queue empty"); + NS_LOG_LOGIC ("Queue empty"); return 0; } @@ -538,7 +523,7 @@ Queue::DoDequeue (ConstIterator pos) m_nBytes -= item->GetSize (); m_nPackets--; - QUEUE_LOG (LOG_LOGIC, "m_traceDequeue (p)"); + NS_LOG_LOGIC ("m_traceDequeue (p)"); m_traceDequeue (item); } return item; @@ -548,11 +533,11 @@ template Ptr Queue::DoRemove (ConstIterator pos) { - QUEUE_LOG (LOG_LOGIC, "Queue:DoRemove(" << this << ")"); + NS_LOG_FUNCTION (this); if (m_nPackets.Get () == 0) { - QUEUE_LOG (LOG_LOGIC, "Queue empty"); + NS_LOG_LOGIC ("Queue empty"); return 0; } @@ -576,7 +561,7 @@ template void Queue::Flush (void) { - QUEUE_LOG (LOG_LOGIC, "Queue:Flush(" << this << ")"); + NS_LOG_FUNCTION (this); while (!IsEmpty ()) { Remove (); @@ -587,11 +572,11 @@ template Ptr Queue::DoPeek (ConstIterator pos) const { - QUEUE_LOG (LOG_LOGIC, "Queue:DoPeek(" << this << ")"); + NS_LOG_FUNCTION (this); if (m_nPackets.Get () == 0) { - QUEUE_LOG (LOG_LOGIC, "Queue empty"); + NS_LOG_LOGIC ("Queue empty"); return 0; } @@ -614,14 +599,14 @@ template void Queue::DropBeforeEnqueue (Ptr item) { - QUEUE_LOG (LOG_LOGIC, "Queue:DropBeforeEnqueue(" << this << ", " << item << ")"); + NS_LOG_FUNCTION (this << item); m_nTotalDroppedPackets++; m_nTotalDroppedPacketsBeforeEnqueue++; m_nTotalDroppedBytes += item->GetSize (); m_nTotalDroppedBytesBeforeEnqueue += item->GetSize (); - QUEUE_LOG (LOG_LOGIC, "m_traceDropBeforeEnqueue (p)"); + NS_LOG_LOGIC ("m_traceDropBeforeEnqueue (p)"); m_traceDrop (item); m_traceDropBeforeEnqueue (item); } @@ -630,14 +615,14 @@ template void Queue::DropAfterDequeue (Ptr item) { - QUEUE_LOG (LOG_LOGIC, "Queue:DropAfterDequeue(" << this << ", " << item << ")"); + NS_LOG_FUNCTION (this << item); m_nTotalDroppedPackets++; m_nTotalDroppedPacketsAfterDequeue++; m_nTotalDroppedBytes += item->GetSize (); m_nTotalDroppedBytesAfterDequeue += item->GetSize (); - QUEUE_LOG (LOG_LOGIC, "m_traceDropAfterDequeue (p)"); + NS_LOG_LOGIC ("m_traceDropAfterDequeue (p)"); m_traceDrop (item); m_traceDropAfterDequeue (item); } diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index 029cc83c8de..d0a1a195351 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -111,6 +111,7 @@ WifiMacQueue::GetTypeId (void) template<> WifiMacQueue::WifiQueue () + : NS_LOG_TEMPLATE_DEFINE ("WifiMacQueue") { } diff --git a/src/wifi/model/wifi-mac-queue.h b/src/wifi/model/wifi-mac-queue.h index 09e023c206c..3d7c7dd1a55 100644 --- a/src/wifi/model/wifi-mac-queue.h +++ b/src/wifi/model/wifi-mac-queue.h @@ -319,6 +319,8 @@ class WifiQueue : public Queue Time m_maxDelay; //!< Time to live for packets in the queue DropPolicy m_dropPolicy; //!< Drop behavior of queue + + NS_LOG_TEMPLATE_DECLARE; //!< redefinition of the log component }; /// Forward declare overridden methods to avoid specializing after instantiation From 625680c6633d79eb9fbd4c625343600f47922a15 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 6 Jun 2017 15:00:42 +0300 Subject: [PATCH 110/551] s/teh/the/ --- src/fd-net-device/helper/planetlab-fd-net-device-helper.cc | 2 +- src/fd-net-device/helper/tap-fd-net-device-helper.cc | 2 +- src/lte/model/fdmt-ff-mac-scheduler.h | 4 ++-- src/lte/model/fdtbfq-ff-mac-scheduler.h | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/fd-net-device/helper/planetlab-fd-net-device-helper.cc b/src/fd-net-device/helper/planetlab-fd-net-device-helper.cc index 9df3d6b7d65..2355967ad0c 100644 --- a/src/fd-net-device/helper/planetlab-fd-net-device-helper.cc +++ b/src/fd-net-device/helper/planetlab-fd-net-device-helper.cc @@ -175,7 +175,7 @@ PlanetLabFdNetDeviceHelper::CreateFileDescriptor (void) const // // -i The IP address to assign to the new tap device; // -n The network prefix to assign to the new tap device; - // -t Set teh IFF_TAP flag + // -t Set the IFF_TAP flag // -p the path to the unix socket described above. // // Example tap-creator -i1.2.3.1 -n24 -t -pblah diff --git a/src/fd-net-device/helper/tap-fd-net-device-helper.cc b/src/fd-net-device/helper/tap-fd-net-device-helper.cc index 67e61a0b516..ca48767b0c3 100644 --- a/src/fd-net-device/helper/tap-fd-net-device-helper.cc +++ b/src/fd-net-device/helper/tap-fd-net-device-helper.cc @@ -204,7 +204,7 @@ TapFdNetDeviceHelper::CreateFileDescriptor (void) const // -I The IP v6 address to assign to the new tap device; // -n The network IPv4 mask to assign to the new tap device; // -N The network IPv6 mask to assign to the new tap device; - // -t Set teh IFF_TAP flag + // -t Set the IFF_TAP flag // -h Set the IFF_NO_PI flag // -p the path to the unix socket described above. // diff --git a/src/lte/model/fdmt-ff-mac-scheduler.h b/src/lte/model/fdmt-ff-mac-scheduler.h index 8742540383a..bedac4e303e 100644 --- a/src/lte/model/fdmt-ff-mac-scheduler.h +++ b/src/lte/model/fdmt-ff-mac-scheduler.h @@ -196,13 +196,13 @@ class FdMtFfMacScheduler : public FfMacScheduler /** * Sched UL noise interference request function - * \param params teh Sched UL noise interference request parameters + * \param params the Sched UL noise interference request parameters */ void DoSchedUlNoiseInterferenceReq (const struct FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters& params); /** * Sched UL SR infor request function - * \param params teh Sched UL SR info request parameters + * \param params the Sched UL SR info request parameters */ void DoSchedUlSrInfoReq (const struct FfMacSchedSapProvider::SchedUlSrInfoReqParameters& params); diff --git a/src/lte/model/fdtbfq-ff-mac-scheduler.h b/src/lte/model/fdtbfq-ff-mac-scheduler.h index 8616aedf35b..3d83c38c1e8 100644 --- a/src/lte/model/fdtbfq-ff-mac-scheduler.h +++ b/src/lte/model/fdtbfq-ff-mac-scheduler.h @@ -223,7 +223,7 @@ class FdTbfqFfMacScheduler : public FfMacScheduler /** * Sched DL CQI info request function - * \param params teh Sched DL CQI info request parameters + * \param params the Sched DL CQI info request parameters */ void DoSchedDlCqiInfoReq (const struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters& params); @@ -247,7 +247,7 @@ class FdTbfqFfMacScheduler : public FfMacScheduler /** * Sched UL MAC control info request function - * \param params teh Sched UL MAC control info request parameters + * \param params the Sched UL MAC control info request parameters */ void DoSchedUlMacCtrlInfoReq (const struct FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters& params); From bf847b00dd76fcfce56550a30c1a68ef4fe5cd67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Tue, 6 Jun 2017 19:54:21 +0200 Subject: [PATCH 111/551] wifi: (fixes #2744) Fix issue with S-MPDU when CTS response is not received --- RELEASE_NOTES | 1 + src/wifi/model/mac-low.cc | 12 ++++++++---- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index fe9c72682ec..66ff9e7faa2 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -104,6 +104,7 @@ Bugs fixed - Bug 2717 - Fix mask generation for Ipv4RoutingTableEntry::CreateDefaultRoute - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. +- Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes Known issues ------------ diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 73f2f374f5a..92c7cb84f7e 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -1546,13 +1546,14 @@ MacLow::ForwardDown (Ptr packet, const WifiMacHeader* hdr, WifiTxV if (delay.IsZero ()) { - NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU"); if (!singleMpdu) { + NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU"); mpdutype = MPDU_IN_AGGREGATE; } else { + NS_LOG_DEBUG ("Sending S-MPDU"); mpdutype = NORMAL_MPDU; } } @@ -2757,7 +2758,7 @@ MacLow::AggregateToAmpdu (Ptr packet, const WifiMacHeader hdr) if (aggregated) { - NS_LOG_DEBUG ("Adding packet with Sequence number " << currentSequenceNumber << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); + NS_LOG_DEBUG ("Adding packet with sequence number " << currentSequenceNumber << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); i++; m_aggregateQueue[tid]->Enqueue (Create (aggPacket, peekedHdr)); } @@ -2842,7 +2843,7 @@ MacLow::AggregateToAmpdu (Ptr packet, const WifiMacHeader hdr) InsertInTxQueue (packet, hdr, tstamp, tid); } } - NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); + NS_LOG_DEBUG ("Adding packet with sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ()); i++; isAmpdu = true; if (!m_txParams.MustSendRts ()) @@ -2981,7 +2982,10 @@ MacLow::AggregateToAmpdu (Ptr packet, const WifiMacHeader hdr) currentAggregatedPacket = Create (); edcaIt->second->GetMpduAggregator ()->AggregateSingleMpdu (packet, currentAggregatedPacket); m_aggregateQueue[tid]->Enqueue (Create (packet, peekedHdr)); - + if (m_txParams.MustSendRts ()) + { + InsertInTxQueue (packet, peekedHdr, tstamp, tid); + } if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid)) { edcaIt->second->CompleteAmpduTransfer (peekedHdr.GetAddr1 (), tid); From 644b9a596fd3e109dc260146302fd31c1be687e8 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 12:14:28 +0300 Subject: [PATCH 112/551] lte: s/componentn/component/ --- src/lte/model/lte-rlc-um.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-rlc-um.h b/src/lte/model/lte-rlc-um.h index e947e262cd3..102a67d31aa 100644 --- a/src/lte/model/lte-rlc-um.h +++ b/src/lte/model/lte-rlc-um.h @@ -57,7 +57,7 @@ class LteRlcUm : public LteRlc * \param bytes the number of bytes * \param layer the layer * \param harqId the HARQ ID - * \param componentCarrierId componentn carrier ID + * \param componentCarrierId component carrier ID * \param rnti the RNTI * \param lcid the LCID */ From 10738e42d5ff2b0b3a90bbdfdf0e720f0f9b2eeb Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 18:12:10 +0300 Subject: [PATCH 113/551] lte: Fix fatal error message: "espected" -> "expected" --- src/lte/model/lte-enb-rrc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 8f2cfbef1f4..ea230f2c2de 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -135,7 +135,7 @@ NS_OBJECT_ENSURE_REGISTERED (UeManager); UeManager::UeManager () { - NS_FATAL_ERROR ("this constructor is not espected to be used"); + NS_FATAL_ERROR ("this constructor is not expected to be used"); } From f4c1543ac591fc27b16e14bbcf3de4d6ab1e0c58 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 8 Jun 2017 14:12:45 +0300 Subject: [PATCH 114/551] lte: Comment fix: "USer" -> "User" --- src/lte/model/lte-ccm-rrc-sap.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-ccm-rrc-sap.h b/src/lte/model/lte-ccm-rrc-sap.h index c2e4601a656..d6ea9cbe56b 100644 --- a/src/lte/model/lte-ccm-rrc-sap.h +++ b/src/lte/model/lte-ccm-rrc-sap.h @@ -106,7 +106,7 @@ friend class LteMacSapUser; * where the report originates from * \param lcid the Logical Channel id * \param lcGroup the Logical Channel group - * \param msu a pointer to the LteMacSapUSer, the LteEnbComponentCarrierManager + * \param msu a pointer to the LteMacSapUser, the LteEnbComponentCarrierManager * has to store a LteMacSapUser for each Rlc istance, in order to * properly redirect the packet * \return vector of LcsConfig contains the lc configuration for each Mac From 310b81cbe252aca29ff01129ac85c3d6bb030820 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 8 Jun 2017 19:26:39 +0300 Subject: [PATCH 115/551] lte: Fix a typo: "Bandwitdh" -> "Bandwidth" --- src/lte/examples/lena-cc-helper.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/examples/lena-cc-helper.cc b/src/lte/examples/lena-cc-helper.cc index d024a0f0c70..741c4788ad7 100644 --- a/src/lte/examples/lena-cc-helper.cc +++ b/src/lte/examples/lena-cc-helper.cc @@ -68,8 +68,8 @@ int main (int argc, char *argv[]) void Print ( ComponentCarrier cc) { - std::cout << " UlBandwitdh " << uint16_t (cc.GetUlBandwidth ()) - << " DlBandwitdh " << uint16_t (cc.GetDlBandwidth ()) + std::cout << " UlBandwidth " << uint16_t (cc.GetUlBandwidth ()) + << " DlBandwidth " << uint16_t (cc.GetDlBandwidth ()) << " Dl Earfcn " << cc.GetDlEarfcn () << " Ul Earfcn " << cc.GetUlEarfcn () << " - Is this the Primary Channel? " << cc.IsPrimary () From a0dd906c6dc2188d89124e8d15de4c6a06fa7b12 Mon Sep 17 00:00:00 2001 From: Ankit Deepak Date: Sun, 11 Jun 2017 13:36:31 -0700 Subject: [PATCH 116/551] bindings: Temporary update to 64-bit bindings to enable build --- src/core/bindings/callbacks_list.py | 5 +- src/core/bindings/modulegen__gcc_LP64.py | 1164 +++++---- src/network/bindings/callbacks_list.py | 19 +- src/network/bindings/modulegen__gcc_LP64.py | 2568 ++++++++++++------- 4 files changed, 2347 insertions(+), 1409 deletions(-) diff --git a/src/core/bindings/callbacks_list.py b/src/core/bindings/callbacks_list.py index 06db4d3ee3e..a767f742fa2 100644 --- a/src/core/bindings/callbacks_list.py +++ b/src/core/bindings/callbacks_list.py @@ -1,5 +1,6 @@ callback_classes = [ - ['void', 'unsigned char*', 'long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'std::basic_string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'std::string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned char *', 'long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ] diff --git a/src/core/bindings/modulegen__gcc_LP64.py b/src/core/bindings/modulegen__gcc_LP64.py index 78716df97af..392d4690fed 100644 --- a/src/core/bindings/modulegen__gcc_LP64.py +++ b/src/core/bindings/modulegen__gcc_LP64.py @@ -32,6 +32,22 @@ def register_types(module): module.add_class('CommandLine', allow_subclassing=True) ## system-mutex.h (module 'core'): ns3::CriticalSection [class] module.add_class('CriticalSection') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::SystemThread']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::TraceSourceAccessor']) ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector [class] module.add_class('EventGarbageCollector') ## event-id.h (module 'core'): ns3::EventId [class] @@ -130,9 +146,9 @@ def register_types(module): module.add_class('Watchdog') ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t']) ## des-metrics.h (module 'core'): ns3::DesMetrics [class] module.add_class('DesMetrics', parent=root_module['ns3::Singleton< ns3::DesMetrics >']) @@ -298,21 +314,15 @@ def register_types(module): module.add_class('Vector3DChecker', parent=root_module['ns3::AttributeChecker']) ## vector.h (module 'core'): ns3::Vector3DValue [class] module.add_class('Vector3DValue', parent=root_module['ns3::AttributeValue']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['bool', 'std::basic_string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned char *', 'long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) module.add_container('std::map< std::string, ns3::LogComponent * >', ('std::string', 'ns3::LogComponent *'), container_type=u'map') - typehandlers.add_type_alias(u'ns3::RngSeedManager', u'ns3::SeedManager') - typehandlers.add_type_alias(u'ns3::RngSeedManager*', u'ns3::SeedManager*') - typehandlers.add_type_alias(u'ns3::RngSeedManager&', u'ns3::SeedManager&') - module.add_typedef(root_module['ns3::RngSeedManager'], 'SeedManager') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectVectorValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectVectorValue*') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectVectorValue&') - module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectVectorValue') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') @@ -321,14 +331,28 @@ def register_types(module): typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectMapValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectMapValue*') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectMapValue&') - module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectMapValue') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') + typehandlers.add_type_alias(u'ns3::RngSeedManager', u'ns3::SeedManager') + typehandlers.add_type_alias(u'ns3::RngSeedManager*', u'ns3::SeedManager*') + typehandlers.add_type_alias(u'ns3::RngSeedManager&', u'ns3::SeedManager&') + module.add_typedef(root_module['ns3::RngSeedManager'], 'SeedManager') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectVectorValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectVectorValue*') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectVectorValue&') + module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectVectorValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectMapValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectMapValue*') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectMapValue&') + module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectMapValue') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') ## Register a nested module for the namespace CommandLineHelper @@ -393,12 +417,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -426,36 +450,36 @@ def register_types_ns3_SystemPath(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -467,6 +491,14 @@ def register_methods(root_module): register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine']) register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3SystemThread_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SystemThread >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3EventGarbageCollector_methods(root_module, root_module['ns3::EventGarbageCollector']) register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue']) @@ -584,6 +616,10 @@ def register_methods(root_module): register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue']) register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker']) register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue']) + register_Ns3CallbackImpl__Bool_StdBasic_string__lt__char__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, std::basic_string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_char___star___Long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned char *, long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer']) register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation']) register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a']) @@ -593,25 +629,25 @@ def register_methods(root_module): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -621,7 +657,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -632,7 +668,7 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -650,12 +686,12 @@ def register_Ns3CommandLine_methods(root_module, cls): cls.add_output_stream_operator() ## command-line.h (module 'core'): ns3::CommandLine::CommandLine() [constructor] cls.add_constructor([]) - ## command-line.h (module 'core'): ns3::CommandLine::CommandLine(ns3::CommandLine const & cmd) [copy constructor] + ## command-line.h (module 'core'): ns3::CommandLine::CommandLine(ns3::CommandLine const & cmd) [constructor] cls.add_constructor([param('ns3::CommandLine const &', 'cmd')]) - ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback callback) [member function] + ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] cls.add_method('AddValue', 'void', - [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::basic_string< char >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & attributePath) [member function] cls.add_method('AddValue', 'void', @@ -681,14 +717,110 @@ def register_Ns3CommandLine_methods(root_module, cls): return def register_Ns3CriticalSection_methods(root_module, cls): - ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor] - cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')]) ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor] cls.add_constructor([param('ns3::SystemMutex &', 'mutex')]) + ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [constructor] + cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')]) + return + +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SystemThread_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SystemThread > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SystemThread * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SystemThread *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) return def register_Ns3EventGarbageCollector_methods(root_module, cls): - ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [copy constructor] + ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [constructor] cls.add_constructor([param('ns3::EventGarbageCollector const &', 'arg0')]) ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector() [constructor] cls.add_constructor([]) @@ -699,9 +831,9 @@ def register_Ns3EventGarbageCollector_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -744,13 +876,13 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3GlobalValue_methods(root_module, cls): - ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor] + ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [constructor] cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')]) - ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr checker) [constructor] + ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr checker) [constructor] cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) - ## global-value.h (module 'core'): static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::Begin() [member function] + ## global-value.h (module 'core'): static ns3::GlobalValue::Iterator ns3::GlobalValue::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', + 'ns3::GlobalValue::Iterator', [], is_static=True) ## global-value.h (module 'core'): static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function] @@ -763,12 +895,12 @@ def register_Ns3GlobalValue_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], is_static=True) - ## global-value.h (module 'core'): static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::End() [member function] + ## global-value.h (module 'core'): static ns3::GlobalValue::Iterator ns3::GlobalValue::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', + 'ns3::GlobalValue::Iterator', [], is_static=True) - ## global-value.h (module 'core'): ns3::Ptr ns3::GlobalValue::GetChecker() const [member function] + ## global-value.h (module 'core'): ns3::Ptr ns3::GlobalValue::GetChecker() const [member function] cls.add_method('GetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [], @@ -809,7 +941,7 @@ def register_Ns3GlobalValue_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -840,57 +972,57 @@ def register_Ns3Hasher_methods(root_module, cls): def register_Ns3IntToType__0_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 0 > const &', 'arg0')]) return def register_Ns3IntToType__1_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 1 > const &', 'arg0')]) return def register_Ns3IntToType__2_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 2 > const &', 'arg0')]) return def register_Ns3IntToType__3_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 3 > const &', 'arg0')]) return def register_Ns3IntToType__4_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 4 > const &', 'arg0')]) return def register_Ns3IntToType__5_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 5 > const &', 'arg0')]) return def register_Ns3IntToType__6_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 6 > const &', 'arg0')]) return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -904,9 +1036,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -938,7 +1070,7 @@ def register_Ns3LogComponent_methods(root_module, cls): def register_Ns3Names_methods(root_module, cls): ## names.h (module 'core'): ns3::Names::Names() [constructor] cls.add_constructor([]) - ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [copy constructor] + ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [constructor] cls.add_constructor([param('ns3::Names const &', 'arg0')]) ## names.h (module 'core'): static void ns3::Names::Add(std::string name, ns3::Ptr object) [member function] cls.add_method('Add', @@ -996,7 +1128,7 @@ def register_Ns3NonCopyable_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -1057,7 +1189,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -1068,7 +1200,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -1103,7 +1235,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -1112,19 +1244,19 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3RandomVariableStreamHelper_methods(root_module, cls): ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper() [constructor] cls.add_constructor([]) - ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper(ns3::RandomVariableStreamHelper const & arg0) [copy constructor] + ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper(ns3::RandomVariableStreamHelper const & arg0) [constructor] cls.add_constructor([param('ns3::RandomVariableStreamHelper const &', 'arg0')]) ## random-variable-stream-helper.h (module 'core'): static int64_t ns3::RandomVariableStreamHelper::AssignStreams(std::string path, int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('std::string', 'path'), param('int64_t', 'stream')], + [param('std::string', 'path'), param('long int', 'stream')], is_static=True) return def register_Ns3RngSeedManager_methods(root_module, cls): ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager() [constructor] cls.add_constructor([]) - ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager(ns3::RngSeedManager const & arg0) [copy constructor] + ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager(ns3::RngSeedManager const & arg0) [constructor] cls.add_constructor([param('ns3::RngSeedManager const &', 'arg0')]) ## rng-seed-manager.h (module 'core'): static uint64_t ns3::RngSeedManager::GetNextStreamIndex() [member function] cls.add_method('GetNextStreamIndex', @@ -1144,19 +1276,19 @@ def register_Ns3RngSeedManager_methods(root_module, cls): ## rng-seed-manager.h (module 'core'): static void ns3::RngSeedManager::SetRun(uint64_t run) [member function] cls.add_method('SetRun', 'void', - [param('uint64_t', 'run')], + [param('long unsigned int', 'run')], is_static=True) ## rng-seed-manager.h (module 'core'): static void ns3::RngSeedManager::SetSeed(uint32_t seed) [member function] cls.add_method('SetSeed', 'void', - [param('uint32_t', 'seed')], + [param('unsigned int', 'seed')], is_static=True) return def register_Ns3RngStream_methods(root_module, cls): ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(uint32_t seed, uint64_t stream, uint64_t substream) [constructor] cls.add_constructor([param('uint32_t', 'seed'), param('uint64_t', 'stream'), param('uint64_t', 'substream')]) - ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(ns3::RngStream const & r) [copy constructor] + ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(ns3::RngStream const & r) [constructor] cls.add_constructor([param('ns3::RngStream const &', 'r')]) ## rng-stream.h (module 'core'): double ns3::RngStream::RandU01() [member function] cls.add_method('RandU01', @@ -1167,7 +1299,7 @@ def register_Ns3RngStream_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -1177,7 +1309,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -1257,17 +1389,17 @@ def register_Ns3Simulator_methods(root_module, cls): return def register_Ns3Singleton__Ns3DesMetrics_methods(root_module, cls): - ## singleton.h (module 'core'): ns3::Singleton::Singleton() [constructor] - cls.add_constructor([]) ## singleton.h (module 'core'): static ns3::DesMetrics * ns3::Singleton::Get() [member function] cls.add_method('Get', 'ns3::DesMetrics *', [], is_static=True) + ## singleton.h (module 'core'): ns3::Singleton::Singleton() [constructor] + cls.add_constructor([]) return def register_Ns3SystemCondition_methods(root_module, cls): - ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor] + ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [constructor] cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')]) ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition() [constructor] cls.add_constructor([]) @@ -1290,7 +1422,7 @@ def register_Ns3SystemCondition_methods(root_module, cls): ## system-condition.h (module 'core'): bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function] cls.add_method('TimedWait', 'bool', - [param('uint64_t', 'ns')]) + [param('long unsigned int', 'ns')]) ## system-condition.h (module 'core'): void ns3::SystemCondition::Wait() [member function] cls.add_method('Wait', 'void', @@ -1298,7 +1430,7 @@ def register_Ns3SystemCondition_methods(root_module, cls): return def register_Ns3SystemMutex_methods(root_module, cls): - ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor] + ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [constructor] cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')]) ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex() [constructor] cls.add_constructor([]) @@ -1313,7 +1445,7 @@ def register_Ns3SystemMutex_methods(root_module, cls): return def register_Ns3SystemWallClockMs_methods(root_module, cls): - ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor] + ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [constructor] cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')]) ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs() [constructor] cls.add_constructor([]) @@ -1344,14 +1476,14 @@ def register_Ns3SystemWallClockMs_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) return def register_Ns3Timer_methods(root_module, cls): - ## timer.h (module 'core'): ns3::Timer::Timer(ns3::Timer const & arg0) [copy constructor] + ## timer.h (module 'core'): ns3::Timer::Timer(ns3::Timer const & arg0) [constructor] cls.add_constructor([param('ns3::Timer const &', 'arg0')]) ## timer.h (module 'core'): ns3::Timer::Timer() [constructor] cls.add_constructor([]) @@ -1420,7 +1552,7 @@ def register_Ns3Timer_methods(root_module, cls): def register_Ns3TimerImpl_methods(root_module, cls): ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl() [constructor] cls.add_constructor([]) - ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [copy constructor] + ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [constructor] cls.add_constructor([param('ns3::TimerImpl const &', 'arg0')]) ## timer-impl.h (module 'core'): void ns3::TimerImpl::Invoke() [member function] cls.add_method('Invoke', @@ -1435,49 +1567,48 @@ def register_Ns3TimerImpl_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('unsigned int', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] cls.add_method('GetAttributeFullName', 'std::string', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function] cls.add_method('GetAttributeN', 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -1487,9 +1618,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -1505,7 +1636,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] cls.add_method('GetRegistered', 'ns3::TypeId', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_static=True) ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function] cls.add_method('GetRegisteredN', @@ -1520,7 +1651,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function] cls.add_method('GetTraceSource', 'ns3::TypeId::TraceSourceInformation', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function] cls.add_method('GetTraceSourceN', @@ -1556,12 +1687,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -1571,12 +1702,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -1586,10 +1717,10 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', - [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) + [param('unsigned int', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] cls.add_method('SetGroupName', 'ns3::TypeId', @@ -1601,23 +1732,22 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', - [param('std::size_t', 'size')]) + [param('long unsigned int', 'size')]) ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t uid) [member function] cls.add_method('SetUid', 'void', - [param('uint16_t', 'uid')]) + [param('short unsigned int', 'uid')]) return def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -1636,7 +1766,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -1653,14 +1783,21 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -1668,14 +1805,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -1685,7 +1829,7 @@ def register_Ns3Vector3D_methods(root_module, cls): return def register_Ns3Watchdog_methods(root_module, cls): - ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [copy constructor] + ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [constructor] cls.add_constructor([param('ns3::Watchdog const &', 'arg0')]) ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog() [constructor] cls.add_constructor([]) @@ -1698,80 +1842,78 @@ def register_Ns3Watchdog_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3DesMetrics_methods(root_module, cls): - ## des-metrics.h (module 'core'): ns3::DesMetrics::DesMetrics() [constructor] - cls.add_constructor([]) ## des-metrics.h (module 'core'): void ns3::DesMetrics::Initialize(int argc, char * * argv, std::string outDir="") [member function] cls.add_method('Initialize', 'void', @@ -1783,7 +1925,9 @@ def register_Ns3DesMetrics_methods(root_module, cls): ## des-metrics.h (module 'core'): void ns3::DesMetrics::TraceWithContext(uint32_t context, ns3::Time const & now, ns3::Time const & delay) [member function] cls.add_method('TraceWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::Time const &', 'now'), param('ns3::Time const &', 'delay')]) + [param('unsigned int', 'context'), param('ns3::Time const &', 'now'), param('ns3::Time const &', 'delay')]) + ## des-metrics.h (module 'core'): ns3::DesMetrics::DesMetrics() [constructor] + cls.add_constructor([]) return def register_Ns3Object_methods(root_module, cls): @@ -1811,7 +1955,7 @@ def register_Ns3Object_methods(root_module, cls): cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [param('ns3::TypeId', 'tid')], - is_const=True, template_parameters=['ns3::Object'], custom_template_method_name=u'GetObject') + is_const=True, template_parameters=[u'ns3::Object'], custom_template_method_name=u'GetObject') ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -1826,7 +1970,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -1847,7 +1991,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -1856,7 +2000,7 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) @@ -1873,7 +2017,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::RandomVariableStream::SetStream(int64_t stream) [member function] cls.add_method('SetStream', 'void', - [param('int64_t', 'stream')]) + [param('long int', 'stream')]) ## random-variable-stream.h (module 'core'): int64_t ns3::RandomVariableStream::GetStream() const [member function] cls.add_method('GetStream', 'int64_t', @@ -1908,7 +2052,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): def register_Ns3Scheduler_methods(root_module, cls): ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler const &', 'arg0')]) ## scheduler.h (module 'core'): static ns3::TypeId ns3::Scheduler::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -1946,7 +2090,7 @@ def register_Ns3SchedulerEvent_methods(root_module, cls): cls.add_binary_comparison_operator('<') ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event(ns3::Scheduler::Event const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event(ns3::Scheduler::Event const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler::Event const &', 'arg0')]) ## scheduler.h (module 'core'): ns3::Scheduler::Event::impl [variable] cls.add_instance_attribute('impl', 'ns3::EventImpl *', is_const=False) @@ -1956,11 +2100,11 @@ def register_Ns3SchedulerEvent_methods(root_module, cls): def register_Ns3SchedulerEventKey_methods(root_module, cls): cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('>') ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')]) ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::m_context [variable] cls.add_instance_attribute('m_context', 'uint32_t', is_const=False) @@ -2013,7 +2157,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2025,7 +2169,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2037,7 +2181,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2049,7 +2193,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2061,7 +2205,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2073,7 +2217,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3FdReader_Ns3Empty_Ns3DefaultDeleter__lt__ns3FdReader__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::FdReader, ns3::empty, ns3::DefaultDeleter< ns3::FdReader > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2085,7 +2229,7 @@ def register_Ns3SimpleRefCount__Ns3FdReader_Ns3Empty_Ns3DefaultDeleter__lt__ns3F def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2097,7 +2241,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3RefCountBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3RefCountBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::RefCountBase, ns3::empty, ns3::DefaultDeleter< ns3::RefCountBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2109,7 +2253,7 @@ def register_Ns3SimpleRefCount__Ns3RefCountBase_Ns3Empty_Ns3DefaultDeleter__lt__ def register_Ns3SimpleRefCount__Ns3SystemThread_Ns3Empty_Ns3DefaultDeleter__lt__ns3SystemThread__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SystemThread, ns3::empty, ns3::DefaultDeleter< ns3::SystemThread > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2121,7 +2265,7 @@ def register_Ns3SimpleRefCount__Ns3SystemThread_Ns3Empty_Ns3DefaultDeleter__lt__ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2133,7 +2277,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete def register_Ns3SimulatorImpl_methods(root_module, cls): ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl() [constructor] cls.add_constructor([]) - ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [copy constructor] + ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::SimulatorImpl const &', 'arg0')]) ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -2213,7 +2357,7 @@ def register_Ns3SimulatorImpl_methods(root_module, cls): ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_pure_virtual=True, is_virtual=True) ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function] cls.add_method('SetScheduler', @@ -2233,7 +2377,7 @@ def register_Ns3SimulatorImpl_methods(root_module, cls): return def register_Ns3Synchronizer_methods(root_module, cls): - ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [copy constructor] + ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [constructor] cls.add_constructor([param('ns3::Synchronizer const &', 'arg0')]) ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer() [constructor] cls.add_constructor([]) @@ -2252,7 +2396,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): int64_t ns3::Synchronizer::GetDrift(uint64_t ts) [member function] cls.add_method('GetDrift', 'int64_t', - [param('uint64_t', 'ts')]) + [param('long unsigned int', 'ts')]) ## synchronizer.h (module 'core'): uint64_t ns3::Synchronizer::GetOrigin() [member function] cls.add_method('GetOrigin', 'uint64_t', @@ -2273,7 +2417,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): void ns3::Synchronizer::SetOrigin(uint64_t ts) [member function] cls.add_method('SetOrigin', 'void', - [param('uint64_t', 'ts')]) + [param('long unsigned int', 'ts')]) ## synchronizer.h (module 'core'): void ns3::Synchronizer::Signal() [member function] cls.add_method('Signal', 'void', @@ -2281,7 +2425,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): bool ns3::Synchronizer::Synchronize(uint64_t tsCurrent, uint64_t tsDelay) [member function] cls.add_method('Synchronize', 'bool', - [param('uint64_t', 'tsCurrent'), param('uint64_t', 'tsDelay')]) + [param('long unsigned int', 'tsCurrent'), param('long unsigned int', 'tsDelay')]) ## synchronizer.h (module 'core'): uint64_t ns3::Synchronizer::DoEventEnd() [member function] cls.add_method('DoEventEnd', 'uint64_t', @@ -2300,7 +2444,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): int64_t ns3::Synchronizer::DoGetDrift(uint64_t ns) [member function] cls.add_method('DoGetDrift', 'int64_t', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], is_pure_virtual=True, visibility='protected', is_virtual=True) ## synchronizer.h (module 'core'): bool ns3::Synchronizer::DoRealtime() [member function] cls.add_method('DoRealtime', @@ -2315,7 +2459,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): void ns3::Synchronizer::DoSetOrigin(uint64_t ns) [member function] cls.add_method('DoSetOrigin', 'void', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], is_pure_virtual=True, visibility='protected', is_virtual=True) ## synchronizer.h (module 'core'): void ns3::Synchronizer::DoSignal() [member function] cls.add_method('DoSignal', @@ -2325,16 +2469,16 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): bool ns3::Synchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function] cls.add_method('DoSynchronize', 'bool', - [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], + [param('long unsigned int', 'nsCurrent'), param('long unsigned int', 'nsDelay')], is_pure_virtual=True, visibility='protected', is_virtual=True) return def register_Ns3SystemThread_methods(root_module, cls): - ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor] + ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [constructor] cls.add_constructor([param('ns3::SystemThread const &', 'arg0')]) ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::Callback callback) [constructor] cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## system-thread.h (module 'core'): static bool ns3::SystemThread::Equals(pthread_t id) [member function] + ## system-thread.h (module 'core'): static bool ns3::SystemThread::Equals(ns3::SystemThread::ThreadId id) [member function] cls.add_method('Equals', 'bool', [param('pthread_t', 'id')], @@ -2343,9 +2487,9 @@ def register_Ns3SystemThread_methods(root_module, cls): cls.add_method('Join', 'void', []) - ## system-thread.h (module 'core'): static pthread_t ns3::SystemThread::Self() [member function] + ## system-thread.h (module 'core'): static ns3::SystemThread::ThreadId ns3::SystemThread::Self() [member function] cls.add_method('Self', - 'pthread_t', + 'ns3::SystemThread::ThreadId', [], is_static=True) ## system-thread.h (module 'core'): void ns3::SystemThread::Start() [member function] @@ -2355,22 +2499,22 @@ def register_Ns3SystemThread_methods(root_module, cls): return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -2418,7 +2562,7 @@ def register_Ns3Time_methods(root_module, cls): ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit unit) [member function] cls.add_method('FromInteger', 'ns3::Time', - [param('uint64_t', 'value'), param('ns3::Time::Unit', 'unit')], + [param('long unsigned int', 'value'), param('ns3::Time::Unit', 'unit')], is_static=True) ## nstime.h (module 'core'): double ns3::Time::GetDays() const [member function] cls.add_method('GetDays', @@ -2553,7 +2697,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -2609,7 +2753,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::TriangularRandomVariable::GetInteger(uint32_t mean, uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'min'), param('uint32_t', 'max')]) + [param('unsigned int', 'mean'), param('unsigned int', 'min'), param('unsigned int', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::TriangularRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2647,7 +2791,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::UniformRandomVariable::GetInteger(uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'min'), param('uint32_t', 'max')]) + [param('unsigned int', 'min'), param('unsigned int', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::UniformRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2661,7 +2805,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): return def register_Ns3WallClockSynchronizer_methods(root_module, cls): - ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor] + ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [constructor] cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')]) ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer() [constructor] cls.add_constructor([]) @@ -2694,7 +2838,7 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): int64_t ns3::WallClockSynchronizer::DoGetDrift(uint64_t ns) [member function] cls.add_method('DoGetDrift', 'int64_t', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::DoRealtime() [member function] cls.add_method('DoRealtime', @@ -2709,7 +2853,7 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::DoSetOrigin(uint64_t ns) [member function] cls.add_method('DoSetOrigin', 'void', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::DoSignal() [member function] cls.add_method('DoSignal', @@ -2719,12 +2863,12 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function] cls.add_method('DoSynchronize', 'bool', - [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], + [param('long unsigned int', 'nsCurrent'), param('long unsigned int', 'nsDelay')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): uint64_t ns3::WallClockSynchronizer::DriftCorrect(uint64_t nsNow, uint64_t nsDelay) [member function] cls.add_method('DriftCorrect', 'uint64_t', - [param('uint64_t', 'nsNow'), param('uint64_t', 'nsDelay')], + [param('long unsigned int', 'nsNow'), param('long unsigned int', 'nsDelay')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): uint64_t ns3::WallClockSynchronizer::GetNormalizedRealtime() [member function] cls.add_method('GetNormalizedRealtime', @@ -2739,17 +2883,17 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::NsToTimeval(int64_t ns, timeval * tv) [member function] cls.add_method('NsToTimeval', 'void', - [param('int64_t', 'ns'), param('timeval *', 'tv')], + [param('long int', 'ns'), param('timeval *', 'tv')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::SleepWait(uint64_t ns) [member function] cls.add_method('SleepWait', 'bool', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::SpinWait(uint64_t ns) [member function] cls.add_method('SpinWait', 'bool', - [param('uint64_t', 'ns')], + [param('long unsigned int', 'ns')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::TimevalAdd(timeval * tv1, timeval * tv2, timeval * result) [member function] cls.add_method('TimevalAdd', @@ -2793,7 +2937,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::WeibullRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) + [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::WeibullRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2826,7 +2970,7 @@ def register_Ns3ZetaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ZetaRandomVariable::GetInteger(uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'alpha')]) + [param('unsigned int', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZetaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2860,11 +3004,11 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue(uint32_t n, double alpha) [member function] cls.add_method('GetValue', 'double', - [param('uint32_t', 'n'), param('double', 'alpha')]) + [param('unsigned int', 'n'), param('double', 'alpha')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ZipfRandomVariable::GetInteger(uint32_t n, uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'n'), param('uint32_t', 'alpha')]) + [param('unsigned int', 'n'), param('unsigned int', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2878,7 +3022,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -2905,7 +3049,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -2947,7 +3091,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -2956,12 +3100,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2971,13 +3115,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -2988,7 +3132,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2998,7 +3142,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3010,7 +3154,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): return def register_Ns3CalendarScheduler_methods(root_module, cls): - ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler(ns3::CalendarScheduler const & arg0) [copy constructor] + ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler(ns3::CalendarScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::CalendarScheduler const &', 'arg0')]) ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler() [constructor] cls.add_constructor([]) @@ -3049,21 +3193,21 @@ def register_Ns3CalendarScheduler_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -3073,10 +3217,40 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'std::string']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'long']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -3087,12 +3261,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3123,7 +3297,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ConstantRandomVariable::GetInteger(uint32_t constant) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'constant')]) + [param('unsigned int', 'constant')]) ## random-variable-stream.h (module 'core'): double ns3::ConstantRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3137,7 +3311,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DefaultSimulatorImpl_methods(root_module, cls): - ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [copy constructor] + ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::DefaultSimulatorImpl const &', 'arg0')]) ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl() [constructor] cls.add_constructor([]) @@ -3219,7 +3393,7 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls): ## default-simulator-impl.h (module 'core'): void ns3::DefaultSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_virtual=True) ## default-simulator-impl.h (module 'core'): void ns3::DefaultSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function] cls.add_method('SetScheduler', @@ -3254,7 +3428,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] cls.add_method('SetValueArray', 'void', - [param('double *', 'values'), param('uint64_t', 'length')]) + [param('double *', 'values'), param('long unsigned int', 'length')]) ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3270,16 +3444,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3289,7 +3463,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3335,7 +3509,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -3362,7 +3536,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -3399,7 +3573,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -3408,12 +3582,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3421,7 +3595,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -3466,7 +3640,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -3477,7 +3651,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3487,7 +3661,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3519,11 +3693,11 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue(uint32_t k, double lambda) [member function] cls.add_method('GetValue', 'double', - [param('uint32_t', 'k'), param('double', 'lambda')]) + [param('unsigned int', 'k'), param('double', 'lambda')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ErlangRandomVariable::GetInteger(uint32_t k, uint32_t lambda) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'k'), param('uint32_t', 'lambda')]) + [param('unsigned int', 'k'), param('unsigned int', 'lambda')]) ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3537,7 +3711,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -3585,7 +3759,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ExponentialRandomVariable::GetInteger(uint32_t mean, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'bound')]) + [param('unsigned int', 'mean'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ExponentialRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3599,11 +3773,11 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): return def register_Ns3FdReader_methods(root_module, cls): - ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader(ns3::FdReader const & arg0) [copy constructor] + ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader(ns3::FdReader const & arg0) [constructor] cls.add_constructor([param('ns3::FdReader const &', 'arg0')]) ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader() [constructor] cls.add_constructor([]) - ## unix-fd-reader.h (module 'core'): void ns3::FdReader::Start(int fd, ns3::Callback readCallback) [member function] + ## unix-fd-reader.h (module 'core'): void ns3::FdReader::Start(int fd, ns3::Callback readCallback) [member function] cls.add_method('Start', 'void', [param('int', 'fd'), param('ns3::Callback< void, unsigned char *, long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'readCallback')]) @@ -3643,7 +3817,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::GammaRandomVariable::GetInteger(uint32_t alpha, uint32_t beta) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'alpha'), param('uint32_t', 'beta')]) + [param('unsigned int', 'alpha'), param('unsigned int', 'beta')]) ## random-variable-stream.h (module 'core'): double ns3::GammaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3657,7 +3831,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): return def register_Ns3HeapScheduler_methods(root_module, cls): - ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [copy constructor] + ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::HeapScheduler const &', 'arg0')]) ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler() [constructor] cls.add_constructor([]) @@ -3696,16 +3870,16 @@ def register_Ns3HeapScheduler_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3715,7 +3889,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3727,7 +3901,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): return def register_Ns3ListScheduler_methods(root_module, cls): - ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [copy constructor] + ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::ListScheduler const &', 'arg0')]) ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler() [constructor] cls.add_constructor([]) @@ -3788,7 +3962,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::LogNormalRandomVariable::GetInteger(uint32_t mu, uint32_t sigma) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mu'), param('uint32_t', 'sigma')]) + [param('unsigned int', 'mu'), param('unsigned int', 'sigma')]) ## random-variable-stream.h (module 'core'): double ns3::LogNormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3802,7 +3976,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): return def register_Ns3MapScheduler_methods(root_module, cls): - ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [copy constructor] + ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::MapScheduler const &', 'arg0')]) ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler() [constructor] cls.add_constructor([]) @@ -3870,7 +4044,7 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::NormalRandomVariable::GetInteger(uint32_t mean, uint32_t variance, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'variance'), param('uint32_t', 'bound')]) + [param('unsigned int', 'mean'), param('unsigned int', 'variance'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::NormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3886,23 +4060,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3912,7 +4086,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3926,7 +4100,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor(ns3::ObjectPtrContainerAccessor const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor(ns3::ObjectPtrContainerAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerAccessor const &', 'arg0')]) ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function] cls.add_method('Get', @@ -3951,7 +4125,7 @@ def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i, uint32_t * index) const [member function] cls.add_method('DoGet', 'ns3::Ptr< ns3::Object >', - [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i'), param('uint32_t *', 'index')], + [param('ns3::ObjectBase const *', 'object'), param('unsigned int', 'i'), param('uint32_t *', 'index')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function] cls.add_method('DoGetN', @@ -3963,7 +4137,7 @@ def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): def register_Ns3ObjectPtrContainerChecker_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker(ns3::ObjectPtrContainerChecker const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker(ns3::ObjectPtrContainerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerChecker const &', 'arg0')]) ## object-ptr-container.h (module 'core'): ns3::TypeId ns3::ObjectPtrContainerChecker::GetItemTypeId() const [member function] cls.add_method('GetItemTypeId', @@ -3973,13 +4147,13 @@ def register_Ns3ObjectPtrContainerChecker_methods(root_module, cls): return def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue(ns3::ObjectPtrContainerValue const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue(ns3::ObjectPtrContainerValue const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerValue const &', 'arg0')]) ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): std::_Rb_tree_const_iterator > > ns3::ObjectPtrContainerValue::Begin() const [member function] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::Iterator ns3::ObjectPtrContainerValue::Begin() const [member function] cls.add_method('Begin', - 'std::_Rb_tree_const_iterator< std::pair< unsigned int const, ns3::Ptr< ns3::Object > > >', + 'ns3::ObjectPtrContainerValue::Iterator', [], is_const=True) ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerValue::Copy() const [member function] @@ -3987,27 +4161,27 @@ def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## object-ptr-container.h (module 'core'): std::_Rb_tree_const_iterator > > ns3::ObjectPtrContainerValue::End() const [member function] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::Iterator ns3::ObjectPtrContainerValue::End() const [member function] cls.add_method('End', - 'std::_Rb_tree_const_iterator< std::pair< unsigned int const, ns3::Ptr< ns3::Object > > >', + 'ns3::ObjectPtrContainerValue::Iterator', [], is_const=True) ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerValue::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Object >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## object-ptr-container.h (module 'core'): uint32_t ns3::ObjectPtrContainerValue::GetN() const [member function] cls.add_method('GetN', 'uint32_t', [], is_const=True) - ## object-ptr-container.h (module 'core'): std::string ns3::ObjectPtrContainerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-ptr-container.h (module 'core'): std::string ns3::ObjectPtrContainerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4026,7 +4200,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -4049,7 +4223,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ParetoRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) + [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -4065,7 +4239,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -4075,7 +4249,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -4086,7 +4260,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4096,7 +4270,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4108,7 +4282,7 @@ def register_Ns3PointerValue_methods(root_module, cls): return def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): - ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [copy constructor] + ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::RealtimeSimulatorImpl const &', 'arg0')]) ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl() [constructor] cls.add_constructor([]) @@ -4213,15 +4387,15 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleRealtimeNowWithContext(uint32_t context, ns3::EventImpl * event) [member function] cls.add_method('ScheduleRealtimeNowWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::EventImpl *', 'event')]) + [param('unsigned int', 'context'), param('ns3::EventImpl *', 'event')]) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleRealtimeWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleRealtimeWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')]) + [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')]) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_virtual=True) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function] cls.add_method('SetHardLimit', @@ -4256,30 +4430,30 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): def register_Ns3RefCountBase_methods(root_module, cls): ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase() [constructor] cls.add_constructor([]) - ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & arg0) [copy constructor] + ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & arg0) [constructor] cls.add_constructor([param('ns3::RefCountBase const &', 'arg0')]) return def register_Ns3StringChecker_methods(root_module, cls): ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [constructor] cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) return def register_Ns3StringValue_methods(root_module, cls): ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4289,7 +4463,7 @@ def register_Ns3StringValue_methods(root_module, cls): 'std::string', [], is_const=True) - ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4303,16 +4477,16 @@ def register_Ns3StringValue_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4322,7 +4496,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4336,23 +4510,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4362,7 +4536,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4376,16 +4550,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4395,7 +4569,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4409,23 +4583,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4435,7 +4609,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4449,23 +4623,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4475,7 +4649,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4486,16 +4660,104 @@ def register_Ns3Vector3DValue_methods(root_module, cls): [param('ns3::Vector3D const &', 'value')]) return +def register_Ns3CallbackImpl__Bool_StdBasic_string__lt__char__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, std::basic_string< char >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(std::basic_string, std::allocator > arg0) [member operator] + cls.add_method('operator()', + 'bool', + [param('std::string', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_char___star___Long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned char *, long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned char * arg0, long int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned char *', 'arg0'), param('long int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3ConfigMatchContainer_methods(root_module, cls): - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')]) ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer() [constructor] cls.add_constructor([]) - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector > const & contexts, std::string path) [constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector, std::allocator > > const & contexts, std::string path) [constructor] cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::Begin() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function] @@ -4514,20 +4776,20 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): cls.add_method('DisconnectWithoutContext', 'void', [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::End() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): ns3::Ptr ns3::Config::MatchContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Object >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## config.h (module 'core'): std::string ns3::Config::MatchContainer::GetMatchedPath(uint32_t i) const [member function] cls.add_method('GetMatchedPath', 'std::string', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## config.h (module 'core'): uint32_t ns3::Config::MatchContainer::GetN() const [member function] cls.add_method('GetN', @@ -4546,7 +4808,7 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -4568,7 +4830,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -4590,7 +4852,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -4607,7 +4869,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -4629,7 +4891,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -4660,28 +4922,28 @@ def register_functions(root_module): module.add_function('Abs', 'ns3::int64x64_t', [param('ns3::int64x64_t const &', 'value')]) - ## breakpoint.h (module 'core'): extern void ns3::BreakpointFallback() [free function] + ## breakpoint.h (module 'core'): void ns3::BreakpointFallback() [free function] module.add_function('BreakpointFallback', 'void', []) - ## vector.h (module 'core'): extern double ns3::CalculateDistance(ns3::Vector2D const & a, ns3::Vector2D const & b) [free function] + ## vector.h (module 'core'): double ns3::CalculateDistance(ns3::Vector2D const & a, ns3::Vector2D const & b) [free function] module.add_function('CalculateDistance', 'double', [param('ns3::Vector2D const &', 'a'), param('ns3::Vector2D const &', 'b')]) - ## vector.h (module 'core'): extern double ns3::CalculateDistance(ns3::Vector3D const & a, ns3::Vector3D const & b) [free function] + ## vector.h (module 'core'): double ns3::CalculateDistance(ns3::Vector3D const & a, ns3::Vector3D const & b) [free function] module.add_function('CalculateDistance', 'double', [param('ns3::Vector3D const &', 'a'), param('ns3::Vector3D const &', 'b')]) - ## ptr.h (module 'core'): extern ns3::Ptr ns3::Create() [free function] + ## ptr.h (module 'core'): ns3::Ptr ns3::Create() [free function] module.add_function('Create', 'ns3::Ptr< ns3::ObjectPtrContainerValue >', [], - template_parameters=['ns3::ObjectPtrContainerValue']) - ## ptr.h (module 'core'): extern ns3::Ptr ns3::Create() [free function] + template_parameters=[u'ns3::ObjectPtrContainerValue']) + ## ptr.h (module 'core'): ns3::Ptr ns3::Create() [free function] module.add_function('Create', 'ns3::Ptr< ns3::PointerValue >', [], - template_parameters=['ns3::PointerValue']) + template_parameters=[u'ns3::PointerValue']) ## nstime.h (module 'core'): ns3::Time ns3::Days(ns3::int64x64_t value) [free function] module.add_function('Days', 'ns3::Time', @@ -4698,6 +4960,10 @@ def register_functions(root_module): module.add_function('FemtoSeconds', 'ns3::Time', [param('uint64_t', 'value')]) + ## log.h (module 'core'): ns3::LogComponent & ns3::GetLogComponent(std::string const name) [free function] + module.add_function('GetLogComponent', + 'ns3::LogComponent &', + [param('std::string const', 'name')]) ## hash.h (module 'core'): uint32_t ns3::Hash32(std::string const s) [free function] module.add_function('Hash32', 'uint32_t', @@ -4722,51 +4988,51 @@ def register_functions(root_module): module.add_function('Hours', 'ns3::Time', [param('double', 'value')]) - ## log.h (module 'core'): extern void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function] module.add_function('LogComponentDisable', 'void', [param('char const *', 'name'), param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function] module.add_function('LogComponentDisableAll', 'void', [param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function] module.add_function('LogComponentEnable', 'void', [param('char const *', 'name'), param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function] module.add_function('LogComponentEnableAll', 'void', [param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentPrintList() [free function] + ## log.h (module 'core'): void ns3::LogComponentPrintList() [free function] module.add_function('LogComponentPrintList', 'void', []) - ## log.h (module 'core'): extern ns3::LogNodePrinter ns3::LogGetNodePrinter() [free function] + ## log.h (module 'core'): ns3::LogNodePrinter ns3::LogGetNodePrinter() [free function] module.add_function('LogGetNodePrinter', 'ns3::LogNodePrinter', []) - ## log.h (module 'core'): extern ns3::LogTimePrinter ns3::LogGetTimePrinter() [free function] + ## log.h (module 'core'): ns3::LogTimePrinter ns3::LogGetTimePrinter() [free function] module.add_function('LogGetTimePrinter', 'ns3::LogTimePrinter', []) - ## log.h (module 'core'): extern void ns3::LogSetNodePrinter(ns3::LogNodePrinter np) [free function] + ## log.h (module 'core'): void ns3::LogSetNodePrinter(ns3::LogNodePrinter np) [free function] module.add_function('LogSetNodePrinter', 'void', [param('ns3::LogNodePrinter', 'np')]) - ## log.h (module 'core'): extern void ns3::LogSetTimePrinter(ns3::LogTimePrinter lp) [free function] + ## log.h (module 'core'): void ns3::LogSetTimePrinter(ns3::LogTimePrinter lp) [free function] module.add_function('LogSetTimePrinter', 'void', [param('ns3::LogTimePrinter', 'lp')]) - ## boolean.h (module 'core'): extern ns3::Ptr ns3::MakeBooleanChecker() [free function] + ## boolean.h (module 'core'): ns3::Ptr ns3::MakeBooleanChecker() [free function] module.add_function('MakeBooleanChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## callback.h (module 'core'): extern ns3::Ptr ns3::MakeCallbackChecker() [free function] + ## callback.h (module 'core'): ns3::Ptr ns3::MakeCallbackChecker() [free function] module.add_function('MakeCallbackChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## attribute.h (module 'core'): ns3::Ptr ns3::MakeEmptyAttributeAccessor() [free function] + ## attribute.h (module 'core'): ns3::Ptr ns3::MakeEmptyAttributeAccessor() [free function] module.add_function('MakeEmptyAttributeAccessor', 'ns3::Ptr< ns3::AttributeAccessor const >', []) @@ -4774,51 +5040,51 @@ def register_functions(root_module): module.add_function('MakeEmptyAttributeChecker', 'ns3::Ptr< ns3::AttributeChecker >', []) - ## trace-source-accessor.h (module 'core'): ns3::Ptr ns3::MakeEmptyTraceSourceAccessor() [free function] + ## trace-source-accessor.h (module 'core'): ns3::Ptr ns3::MakeEmptyTraceSourceAccessor() [free function] module.add_function('MakeEmptyTraceSourceAccessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', []) - ## enum.h (module 'core'): extern ns3::Ptr ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="", int v13=0, std::string n13="", int v14=0, std::string n14="", int v15=0, std::string n15="", int v16=0, std::string n16="", int v17=0, std::string n17="", int v18=0, std::string n18="", int v19=0, std::string n19="", int v20=0, std::string n20="", int v21=0, std::string n21="", int v22=0, std::string n22="") [free function] + ## enum.h (module 'core'): ns3::Ptr ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="", int v13=0, std::string n13="", int v14=0, std::string n14="", int v15=0, std::string n15="", int v16=0, std::string n16="", int v17=0, std::string n17="", int v18=0, std::string n18="", int v19=0, std::string n19="", int v20=0, std::string n20="", int v21=0, std::string n21="", int v22=0, std::string n22="") [free function] module.add_function('MakeEnumChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""'), param('int', 'v13', default_value='0'), param('std::string', 'n13', default_value='""'), param('int', 'v14', default_value='0'), param('std::string', 'n14', default_value='""'), param('int', 'v15', default_value='0'), param('std::string', 'n15', default_value='""'), param('int', 'v16', default_value='0'), param('std::string', 'n16', default_value='""'), param('int', 'v17', default_value='0'), param('std::string', 'n17', default_value='""'), param('int', 'v18', default_value='0'), param('std::string', 'n18', default_value='""'), param('int', 'v19', default_value='0'), param('std::string', 'n19', default_value='""'), param('int', 'v20', default_value='0'), param('std::string', 'n20', default_value='""'), param('int', 'v21', default_value='0'), param('std::string', 'n21', default_value='""'), param('int', 'v22', default_value='0'), param('std::string', 'n22', default_value='""')]) - ## make-event.h (module 'core'): extern ns3::EventImpl * ns3::MakeEvent(void (*)( ) * f) [free function] + ## make-event.h (module 'core'): ns3::EventImpl * ns3::MakeEvent(void (*)( ) f) [free function] module.add_function('MakeEvent', 'ns3::EventImpl *', - [param('void ( * ) ( ) *', 'f')]) - ## object-factory.h (module 'core'): extern ns3::Ptr ns3::MakeObjectFactoryChecker() [free function] + [param('void ( * ) ( )', 'f')]) + ## object-factory.h (module 'core'): ns3::Ptr ns3::MakeObjectFactoryChecker() [free function] module.add_function('MakeObjectFactoryChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## string.h (module 'core'): extern ns3::Ptr ns3::MakeStringChecker() [free function] + ## string.h (module 'core'): ns3::Ptr ns3::MakeStringChecker() [free function] module.add_function('MakeStringChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker() [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker() [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min) [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min) [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('ns3::Time const', 'min')]) - ## nstime.h (module 'core'): extern ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min, ns3::Time const max) [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min, ns3::Time const max) [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('ns3::Time const', 'min'), param('ns3::Time const', 'max')]) - ## type-id.h (module 'core'): extern ns3::Ptr ns3::MakeTypeIdChecker() [free function] + ## type-id.h (module 'core'): ns3::Ptr ns3::MakeTypeIdChecker() [free function] module.add_function('MakeTypeIdChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVector2DChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVector2DChecker() [free function] module.add_function('MakeVector2DChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVector3DChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVector3DChecker() [free function] module.add_function('MakeVector3DChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVectorChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVectorChecker() [free function] module.add_function('MakeVectorChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) @@ -4870,7 +5136,7 @@ def register_functions(root_module): module.add_function('NanoSeconds', 'ns3::Time', [param('uint64_t', 'value')]) - ## simulator.h (module 'core'): extern ns3::Time ns3::Now() [free function] + ## simulator.h (module 'core'): ns3::Time ns3::Now() [free function] module.add_function('Now', 'ns3::Time', []) @@ -4890,7 +5156,7 @@ def register_functions(root_module): module.add_function('Seconds', 'ns3::Time', [param('double', 'value')]) - ## test.h (module 'core'): extern bool ns3::TestDoubleIsEqual(double const a, double const b, double const epsilon=std::numeric_limits::epsilon()) [free function] + ## test.h (module 'core'): bool ns3::TestDoubleIsEqual(double const a, double const b, double const epsilon=std::numeric_limits::epsilon()) [free function] module.add_function('TestDoubleIsEqual', 'bool', [param('double const', 'a'), param('double const', 'b'), param('double const', 'epsilon', default_value='std::numeric_limits::epsilon()')]) @@ -4898,56 +5164,56 @@ def register_functions(root_module): module.add_function('TimeStep', 'ns3::Time', [param('uint64_t', 'ts')]) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['double']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'signed char']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['float']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'short']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned long']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'int']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned int']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'long']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned short']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned char']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned char']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned short']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['long']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned int']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['int']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned long']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['short']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'float']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['signed char']) + template_parameters=[u'double']) ## nstime.h (module 'core'): ns3::Time ns3::Years(ns3::int64x64_t value) [free function] module.add_function('Years', 'ns3::Time', @@ -4966,91 +5232,91 @@ def register_functions(root_module): return def register_functions_ns3_CommandLineHelper(module, root_module): - ## command-line.h (module 'core'): extern std::string ns3::CommandLineHelper::GetDefault(bool const & val) [free function] + ## command-line.h (module 'core'): std::string ns3::CommandLineHelper::GetDefault(bool const & val) [free function] module.add_function('GetDefault', 'std::string', [param('bool const &', 'val')], - template_parameters=['bool']) - ## command-line.h (module 'core'): extern bool ns3::CommandLineHelper::UserItemParse(std::string const value, bool & val) [free function] + template_parameters=[u'bool']) + ## command-line.h (module 'core'): bool ns3::CommandLineHelper::UserItemParse(std::string const value, bool & val) [free function] module.add_function('UserItemParse', 'bool', [param('std::string const', 'value'), param('bool &', 'val')], - template_parameters=['bool']) + template_parameters=[u'bool']) return def register_functions_ns3_Config(module, root_module): - ## config.h (module 'core'): extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('Connect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('ConnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('Disconnect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('DisconnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern ns3::Ptr ns3::Config::GetRootNamespaceObject(uint32_t i) [free function] + ## config.h (module 'core'): ns3::Ptr ns3::Config::GetRootNamespaceObject(uint32_t i) [free function] module.add_function('GetRootNamespaceObject', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')]) - ## config.h (module 'core'): extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function] + ## config.h (module 'core'): uint32_t ns3::Config::GetRootNamespaceObjectN() [free function] module.add_function('GetRootNamespaceObjectN', 'uint32_t', []) - ## config.h (module 'core'): extern ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function] + ## config.h (module 'core'): ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function] module.add_function('LookupMatches', 'ns3::Config::MatchContainer', [param('std::string', 'path')]) - ## config.h (module 'core'): extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr obj) [free function] + ## config.h (module 'core'): void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr obj) [free function] module.add_function('RegisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) - ## config.h (module 'core'): extern void ns3::Config::Reset() [free function] + ## config.h (module 'core'): void ns3::Config::Reset() [free function] module.add_function('Reset', 'void', []) - ## config.h (module 'core'): extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function] module.add_function('Set', 'void', [param('std::string', 'path'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetDefault', 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetDefaultFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetGlobal', 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetGlobalFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr obj) [free function] + ## config.h (module 'core'): void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr obj) [free function] module.add_function('UnregisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) return def register_functions_ns3_FatalImpl(module, root_module): - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::FlushStreams() [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::FlushStreams() [free function] module.add_function('FlushStreams', 'void', []) - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::RegisterStream(std::ostream * stream) [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::RegisterStream(std::ostream * stream) [free function] module.add_function('RegisterStream', 'void', [param('std::ostream *', 'stream')]) - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::UnregisterStream(std::ostream * stream) [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::UnregisterStream(std::ostream * stream) [free function] module.add_function('UnregisterStream', 'void', [param('std::ostream *', 'stream')]) @@ -5064,31 +5330,31 @@ def register_functions_ns3_Hash_Function(module, root_module): return def register_functions_ns3_SystemPath(module, root_module): - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::Append(std::string left, std::string right) [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::Append(std::string left, std::string right) [free function] module.add_function('Append', 'std::string', [param('std::string', 'left'), param('std::string', 'right')]) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::FindSelfDirectory() [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::FindSelfDirectory() [free function] module.add_function('FindSelfDirectory', 'std::string', []) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::Join(std::_List_const_iterator, std::allocator > > begin, std::_List_const_iterator, std::allocator > > end) [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::Join(std::list, std::allocator > >::const_iterator begin, std::list, std::allocator > >::const_iterator end) [free function] module.add_function('Join', 'std::string', - [param('std::_List_const_iterator< std::basic_string< char, std::char_traits< char >, std::allocator< char > > >', 'begin'), param('std::_List_const_iterator< std::basic_string< char, std::char_traits< char >, std::allocator< char > > >', 'end')]) - ## system-path.h (module 'core'): extern void ns3::SystemPath::MakeDirectories(std::string path) [free function] + [param('std::list< std::string > const_iterator', 'begin'), param('std::list< std::string > const_iterator', 'end')]) + ## system-path.h (module 'core'): void ns3::SystemPath::MakeDirectories(std::string path) [free function] module.add_function('MakeDirectories', 'void', [param('std::string', 'path')]) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::MakeTemporaryDirectoryName() [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::MakeTemporaryDirectoryName() [free function] module.add_function('MakeTemporaryDirectoryName', 'std::string', []) - ## system-path.h (module 'core'): extern std::list > ns3::SystemPath::ReadFiles(std::string path) [free function] + ## system-path.h (module 'core'): std::list, std::allocator > > ns3::SystemPath::ReadFiles(std::string path) [free function] module.add_function('ReadFiles', 'std::list< std::string >', [param('std::string', 'path')]) - ## system-path.h (module 'core'): extern std::list > ns3::SystemPath::Split(std::string path) [free function] + ## system-path.h (module 'core'): std::list, std::allocator > > ns3::SystemPath::Split(std::string path) [free function] module.add_function('Split', 'std::list< std::string >', [param('std::string', 'path')]) @@ -5098,15 +5364,15 @@ def register_functions_ns3_TracedValueCallback(module, root_module): return def register_functions_ns3_internal(module, root_module): - ## double.h (module 'core'): extern ns3::Ptr ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function] + ## double.h (module 'core'): ns3::Ptr ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function] module.add_function('MakeDoubleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('double', 'min'), param('double', 'max'), param('std::string', 'name')]) - ## integer.h (module 'core'): extern ns3::Ptr ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function] + ## integer.h (module 'core'): ns3::Ptr ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function] module.add_function('MakeIntegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')]) - ## uinteger.h (module 'core'): extern ns3::Ptr ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function] + ## uinteger.h (module 'core'): ns3::Ptr ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function] module.add_function('MakeUintegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')]) diff --git a/src/network/bindings/callbacks_list.py b/src/network/bindings/callbacks_list.py index 85b87f4f768..2efdb8804b9 100644 --- a/src/network/bindings/callbacks_list.py +++ b/src/network/bindings/callbacks_list.py @@ -1,11 +1,18 @@ callback_classes = [ + ['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned int', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'std::basic_string', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ] diff --git a/src/network/bindings/modulegen__gcc_LP64.py b/src/network/bindings/modulegen__gcc_LP64.py index 1a8dbf9dff1..09e2152c211 100644 --- a/src/network/bindings/modulegen__gcc_LP64.py +++ b/src/network/bindings/modulegen__gcc_LP64.py @@ -22,10 +22,10 @@ def register_types(module): ## packetbb.h (module 'network'): ns3::PbbAddressLength [enumeration] module.add_enum('PbbAddressLength', ['IPV4', 'IPV6']) - ## log.h (module 'core'): ns3::LogLevel [enumeration] - module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') ## ethernet-header.h (module 'network'): ns3::ethernet_header_t [enumeration] module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ']) + ## log.h (module 'core'): ns3::LogLevel [enumeration] + module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') ## address.h (module 'network'): ns3::Address [class] module.add_class('Address') ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration] @@ -64,6 +64,36 @@ def register_types(module): module.add_class('DataOutputCallback', allow_subclassing=True, import_from_module='ns.stats') ## data-rate.h (module 'network'): ns3::DataRate [class] module.add_class('DataRate') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::NetDeviceQueue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::OutputStreamWrapper']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbAddressBlock']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbMessage']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbTlv']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::QueueItem']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation [class] module.add_class('DelayJitterEstimation') ## event-id.h (module 'core'): ns3::EventId [class] @@ -122,8 +152,8 @@ def register_types(module): module.add_class('PacketMetadata') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item']) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item']) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', outer_class=root_module['ns3::PacketMetadata']) ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress [class] @@ -190,9 +220,9 @@ def register_types(module): module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId']) ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## chunk.h (module 'network'): ns3::Chunk [class] module.add_class('Chunk', parent=root_module['ns3::ObjectBase']) @@ -472,9 +502,9 @@ def register_types(module): module.add_class('PbbTlv', parent=root_module['ns3::SimpleRefCount< ns3::PbbTlv, ns3::empty, ns3::DefaultDeleter >']) ## probe.h (module 'stats'): ns3::Probe [class] module.add_class('Probe', import_from_module='ns.stats', parent=root_module['ns3::DataCollectionObject']) - ## queue.h (module 'network'): ns3::Queue [class] + ## net-device-queue-interface.h (module 'network'): ns3::Queue [class] module.add_class('Queue', template_parameters=['ns3::Packet'], parent=root_module['ns3::QueueBase']) - ## queue.h (module 'network'): ns3::Queue [class] + ## net-device-queue-interface.h (module 'network'): ns3::Queue [class] module.add_class('Queue', template_parameters=['ns3::QueueDiscItem'], parent=root_module['ns3::QueueBase']) ## queue-item.h (module 'network'): ns3::QueueItem [class] module.add_class('QueueItem', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >']) @@ -506,6 +536,36 @@ def register_types(module): module.add_class('BinaryErrorModel', parent=root_module['ns3::ErrorModel']) ## error-model.h (module 'network'): ns3::BurstErrorModel [class] module.add_class('BurstErrorModel', parent=root_module['ns3::ErrorModel']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned int', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator [class] module.add_class('CounterCalculator', import_from_module='ns.stats', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator']) ## error-channel.h (module 'network'): ns3::ErrorChannel [class] @@ -522,36 +582,36 @@ def register_types(module): module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type=u'list') module.add_container('std::vector< ns3::Ipv6Address >', 'ns3::Ipv6Address', container_type=u'vector') module.add_container('std::list< unsigned int >', 'unsigned int', container_type=u'list') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >', u'ns3::SequenceNumber16') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >*', u'ns3::SequenceNumber16*') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >&', u'ns3::SequenceNumber16&') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >', u'ns3::SequenceNumber32') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >*', u'ns3::SequenceNumber32*') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >&', u'ns3::SequenceNumber32&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >', u'ns3::SequenceNumber16') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >*', u'ns3::SequenceNumber16*') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >&', u'ns3::SequenceNumber16&') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >', u'ns3::SequenceNumber8') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >*', u'ns3::SequenceNumber8*') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >&', u'ns3::SequenceNumber8&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') ## Register a nested module for the namespace FatalImpl @@ -592,12 +652,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -620,39 +680,39 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) *', u'ns3::TracedValueCallback::SequenceNumber32') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) **', u'ns3::TracedValueCallback::SequenceNumber32*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) *&', u'ns3::TracedValueCallback::SequenceNumber32&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )', u'ns3::TracedValueCallback::SequenceNumber32') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )*', u'ns3::TracedValueCallback::SequenceNumber32*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )&', u'ns3::TracedValueCallback::SequenceNumber32&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_addressUtils(module): root_module = module.get_root() @@ -681,6 +741,21 @@ def register_methods(root_module): register_Ns3ChannelList_methods(root_module, root_module['ns3::ChannelList']) register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback']) register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3NetDeviceQueue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NetDeviceQueue >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::DefaultDeleter< ns3::OutputStreamWrapper >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3PbbAddressBlock_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbAddressBlock >']) + register_Ns3DefaultDeleter__Ns3PbbMessage_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbMessage >']) + register_Ns3DefaultDeleter__Ns3PbbTlv_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbTlv >']) + register_Ns3DefaultDeleter__Ns3QueueItem_methods(root_module, root_module['ns3::DefaultDeleter< ns3::QueueItem >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3DelayJitterEstimation_methods(root_module, root_module['ns3::DelayJitterEstimation']) register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) register_Ns3Hasher_methods(root_module, root_module['ns3::Hasher']) @@ -870,6 +945,21 @@ def register_methods(root_module): register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) register_Ns3BinaryErrorModel_methods(root_module, root_module['ns3::BinaryErrorModel']) register_Ns3BurstErrorModel_methods(root_module, root_module['ns3::BurstErrorModel']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Unsigned_char_Ns3Ptr__lt__ns3QueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< unsigned char, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3QueueDiscItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >']) register_Ns3ErrorChannel_methods(root_module, root_module['ns3::ErrorChannel']) register_Ns3PacketCounterCalculator_methods(root_module, root_module['ns3::PacketCounterCalculator']) @@ -884,34 +974,34 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', 'bool', - [param('uint8_t', 'type'), param('uint8_t', 'len')], + [param('unsigned char', 'type'), param('unsigned char', 'len')], is_const=True) ## address.h (module 'network'): uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function] cls.add_method('CopyAllFrom', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) + [param('uint8_t const *', 'buffer'), param('unsigned char', 'len')]) ## address.h (module 'network'): uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function] cls.add_method('CopyAllTo', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], + [param('uint8_t *', 'buffer'), param('unsigned char', 'len')], is_const=True) ## address.h (module 'network'): uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function] cls.add_method('CopyFrom', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) + [param('uint8_t const *', 'buffer'), param('unsigned char', 'len')]) ## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function] cls.add_method('CopyTo', 'uint32_t', @@ -939,7 +1029,7 @@ def register_Ns3Address_methods(root_module, cls): ## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function] cls.add_method('IsMatchingType', 'bool', - [param('uint8_t', 'type')], + [param('unsigned char', 'type')], is_const=True) ## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function] cls.add_method('Register', @@ -954,7 +1044,7 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3ApplicationContainer_methods(root_module, cls): - ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor] + ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [constructor] cls.add_constructor([param('ns3::ApplicationContainer const &', 'arg0')]) ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer() [constructor] cls.add_constructor([]) @@ -974,20 +1064,20 @@ def register_Ns3ApplicationContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'name')]) - ## application-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::Begin() const [member function] + ## application-container.h (module 'network'): ns3::ApplicationContainer::Iterator ns3::ApplicationContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Application > const, std::vector< ns3::Ptr< ns3::Application > > >', + 'ns3::ApplicationContainer::Iterator', [], is_const=True) - ## application-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::End() const [member function] + ## application-container.h (module 'network'): ns3::ApplicationContainer::Iterator ns3::ApplicationContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Application > const, std::vector< ns3::Ptr< ns3::Application > > >', + 'ns3::ApplicationContainer::Iterator', [], is_const=True) ## application-container.h (module 'network'): ns3::Ptr ns3::ApplicationContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Application >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## application-container.h (module 'network'): uint32_t ns3::ApplicationContainer::GetN() const [member function] cls.add_method('GetN', @@ -1017,7 +1107,7 @@ def register_Ns3AsciiFile_methods(root_module, cls): 'bool', [], is_const=True) - ## ascii-file.h (module 'network'): void ns3::AsciiFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## ascii-file.h (module 'network'): void ns3::AsciiFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) @@ -1037,50 +1127,50 @@ def register_Ns3AsciiFile_methods(root_module, cls): return def register_Ns3AsciiTraceHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::_Ios_Openmode filemode=std::ios_base::out) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::ios_base::openmode filemode=std::ios_base::out) [member function] cls.add_method('CreateFileStream', 'ns3::Ptr< ns3::OutputStreamWrapper >', [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode', default_value='std::ios_base::out')]) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], @@ -1092,11 +1182,11 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls): ## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr object, uint32_t interface, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromInterfacePair', 'std::string', - [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')]) + [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('unsigned int', 'interface'), param('bool', 'useObjectNames', default_value='true')]) return def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice() [constructor] cls.add_constructor([]) @@ -1135,11 +1225,11 @@ def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool explicitFilename) [member function] cls.add_method('EnableAscii', 'void', - [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'explicitFilename')]) + [param('std::string', 'prefix'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid'), param('bool', 'explicitFilename')]) ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr stream, uint32_t nodeid, uint32_t deviceid) [member function] cls.add_method('EnableAscii', 'void', - [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')]) + [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid')]) ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(std::string prefix) [member function] cls.add_method('EnableAsciiAll', 'void', @@ -1156,25 +1246,25 @@ def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -1184,7 +1274,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -1195,18 +1285,18 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', - [param('uint32_t', 'end')]) + [param('unsigned int', 'end')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] cls.add_method('AddAtEnd', 'void', @@ -1214,7 +1304,7 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::AddAtStart(uint32_t start) [member function] cls.add_method('AddAtStart', 'void', - [param('uint32_t', 'start')]) + [param('unsigned int', 'start')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] cls.add_method('Begin', 'ns3::Buffer::Iterator', @@ -1223,22 +1313,22 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function] cls.add_method('CopyData', 'void', - [param('std::ostream *', 'os'), param('uint32_t', 'size')], + [param('std::ostream *', 'os'), param('unsigned int', 'size')], is_const=True) ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function] cls.add_method('CopyData', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], + [param('uint8_t *', 'buffer'), param('unsigned int', 'size')], is_const=True) ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] cls.add_method('CreateFragment', 'ns3::Buffer', - [param('uint32_t', 'start'), param('uint32_t', 'length')], + [param('unsigned int', 'start'), param('unsigned int', 'length')], is_const=True) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function] cls.add_method('End', 'ns3::Buffer::Iterator', @@ -1262,31 +1352,31 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('uint32_t', 'end')]) + [param('unsigned int', 'end')]) ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] cls.add_method('RemoveAtStart', 'void', - [param('uint32_t', 'start')]) + [param('unsigned int', 'start')]) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], + [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], is_const=True) return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function] cls.add_method('CalculateIpChecksum', 'uint16_t', - [param('uint16_t', 'size')]) + [param('short unsigned int', 'size')]) ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function] cls.add_method('CalculateIpChecksum', 'uint16_t', - [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')]) + [param('short unsigned int', 'size'), param('unsigned int', 'initialChecksum')]) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function] cls.add_method('GetDistanceFrom', 'uint32_t', @@ -1319,7 +1409,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function] cls.add_method('Next', 'void', - [param('uint32_t', 'delta')]) + [param('unsigned int', 'delta')]) ## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::PeekU8() [member function] cls.add_method('PeekU8', 'uint8_t', @@ -1331,15 +1421,15 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function] cls.add_method('Prev', 'void', - [param('uint32_t', 'delta')]) + [param('unsigned int', 'delta')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t *', 'buffer'), param('unsigned int', 'size')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(ns3::Buffer::Iterator start, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'size')]) + [param('ns3::Buffer::Iterator', 'start'), param('unsigned int', 'size')]) ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function] cls.add_method('ReadLsbtohU16', 'uint16_t', @@ -1383,7 +1473,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Write', 'void', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function] cls.add_method('Write', 'void', @@ -1391,51 +1481,51 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function] cls.add_method('WriteHtolsbU16', 'void', - [param('uint16_t', 'data')]) + [param('short unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function] cls.add_method('WriteHtolsbU32', 'void', - [param('uint32_t', 'data')]) + [param('unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function] cls.add_method('WriteHtolsbU64', 'void', - [param('uint64_t', 'data')]) + [param('long unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function] cls.add_method('WriteHtonU16', 'void', - [param('uint16_t', 'data')]) + [param('short unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function] cls.add_method('WriteHtonU32', 'void', - [param('uint32_t', 'data')]) + [param('unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function] cls.add_method('WriteHtonU64', 'void', - [param('uint64_t', 'data')]) + [param('long unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) + [param('short unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function] cls.add_method('WriteU64', 'void', - [param('uint64_t', 'data')]) + [param('long unsigned int', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function] cls.add_method('WriteU8', 'void', - [param('uint8_t', 'data')]) + [param('unsigned char', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function] cls.add_method('WriteU8', 'void', - [param('uint8_t', 'data'), param('uint32_t', 'len')]) + [param('unsigned char', 'data'), param('unsigned int', 'len')]) return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -1449,7 +1539,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -1476,12 +1566,12 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', 'ns3::TagBuffer', - [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')]) + [param('ns3::TypeId', 'tid'), param('unsigned int', 'bufferSize'), param('int', 'start'), param('int', 'end')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function] cls.add_method('Add', 'void', @@ -1489,19 +1579,19 @@ def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t appendOffset) [member function] cls.add_method('AddAtEnd', 'void', - [param('int32_t', 'appendOffset')]) + [param('int', 'appendOffset')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t prependOffset) [member function] cls.add_method('AddAtStart', 'void', - [param('int32_t', 'prependOffset')]) + [param('int', 'prependOffset')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Adjust(int32_t adjustment) [member function] cls.add_method('Adjust', 'void', - [param('int32_t', 'adjustment')]) + [param('int', 'adjustment')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator ns3::ByteTagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function] cls.add_method('Begin', 'ns3::ByteTagList::Iterator', - [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], + [param('int', 'offsetStart'), param('int', 'offsetEnd')], is_const=True) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function] cls.add_method('RemoveAll', @@ -1510,7 +1600,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -1529,7 +1619,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -1546,7 +1636,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -1563,27 +1653,27 @@ def register_Ns3CallbackBase_methods(root_module, cls): def register_Ns3ChannelList_methods(root_module, cls): ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList() [constructor] cls.add_constructor([]) - ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList(ns3::ChannelList const & arg0) [copy constructor] + ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList(ns3::ChannelList const & arg0) [constructor] cls.add_constructor([param('ns3::ChannelList const &', 'arg0')]) ## channel-list.h (module 'network'): static uint32_t ns3::ChannelList::Add(ns3::Ptr channel) [member function] cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Channel >', 'channel')], is_static=True) - ## channel-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ChannelList::Begin() [member function] + ## channel-list.h (module 'network'): static ns3::ChannelList::Iterator ns3::ChannelList::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', + 'ns3::ChannelList::Iterator', [], is_static=True) - ## channel-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ChannelList::End() [member function] + ## channel-list.h (module 'network'): static ns3::ChannelList::Iterator ns3::ChannelList::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', + 'ns3::ChannelList::Iterator', [], is_static=True) ## channel-list.h (module 'network'): static ns3::Ptr ns3::ChannelList::GetChannel(uint32_t n) [member function] cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', - [param('uint32_t', 'n')], + [param('unsigned int', 'n')], is_static=True) ## channel-list.h (module 'network'): static uint32_t ns3::ChannelList::GetNChannels() [member function] cls.add_method('GetNChannels', @@ -1595,7 +1685,7 @@ def register_Ns3ChannelList_methods(root_module, cls): def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback() [constructor] cls.add_constructor([]) - ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')]) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function] cls.add_method('OutputSingleton', @@ -1605,7 +1695,7 @@ def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, uint32_t val) [member function] cls.add_method('OutputSingleton', 'void', - [param('std::string', 'key'), param('std::string', 'variable'), param('uint32_t', 'val')], + [param('std::string', 'key'), param('std::string', 'variable'), param('unsigned int', 'val')], is_pure_virtual=True, is_virtual=True) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, double val) [member function] cls.add_method('OutputSingleton', @@ -1637,7 +1727,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('>=') - ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRate::DataRate() [constructor] cls.add_constructor([]) @@ -1648,18 +1738,18 @@ def register_Ns3DataRate_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::Time ns3::DataRate::CalculateBitsTxTime(uint32_t bits) const [member function] cls.add_method('CalculateBitsTxTime', 'ns3::Time', - [param('uint32_t', 'bits')], + [param('unsigned int', 'bits')], is_const=True) ## data-rate.h (module 'network'): ns3::Time ns3::DataRate::CalculateBytesTxTime(uint32_t bytes) const [member function] cls.add_method('CalculateBytesTxTime', 'ns3::Time', - [param('uint32_t', 'bytes')], + [param('unsigned int', 'bytes')], is_const=True) ## data-rate.h (module 'network'): double ns3::DataRate::CalculateTxTime(uint32_t bytes) const [member function] cls.add_method('CalculateTxTime', 'double', - [param('uint32_t', 'bytes')], - deprecated=True, is_const=True) + [param('unsigned int', 'bytes')], + is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', 'uint64_t', @@ -1667,8 +1757,188 @@ def register_Ns3DataRate_methods(root_module, cls): is_const=True) return +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NetDeviceQueue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NetDeviceQueue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NetDeviceQueue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NetDeviceQueue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::OutputStreamWrapper > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::OutputStreamWrapper * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::OutputStreamWrapper *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbAddressBlock_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbAddressBlock > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbAddressBlock * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbAddressBlock *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbMessage_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbMessage > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbMessage * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbMessage *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbTlv_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbTlv > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbTlv * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbTlv *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3QueueItem_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::QueueItem > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::QueueItem * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::QueueItem *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + def register_Ns3DelayJitterEstimation_methods(root_module, cls): - ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor] + ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [constructor] cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')]) ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor] cls.add_constructor([]) @@ -1682,21 +1952,21 @@ def register_Ns3DelayJitterEstimation_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## delay-jitter-estimation.h (module 'network'): static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr packet) [member function] + ## delay-jitter-estimation.h (module 'network'): static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr packet) [member function] cls.add_method('PrepareTx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')], is_static=True) - ## delay-jitter-estimation.h (module 'network'): void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr packet) [member function] + ## delay-jitter-estimation.h (module 'network'): void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr packet) [member function] cls.add_method('RecordRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -1739,7 +2009,7 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -1768,7 +2038,7 @@ def register_Ns3Hasher_methods(root_module, cls): return def register_Ns3Inet6SocketAddress_methods(root_module, cls): - ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor] + ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')]) ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')]) @@ -1807,11 +2077,11 @@ def register_Ns3Inet6SocketAddress_methods(root_module, cls): ## inet6-socket-address.h (module 'network'): void ns3::Inet6SocketAddress::SetPort(uint16_t port) [member function] cls.add_method('SetPort', 'void', - [param('uint16_t', 'port')]) + [param('short unsigned int', 'port')]) return def register_Ns3InetSocketAddress_methods(root_module, cls): - ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor] + ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')]) ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')]) @@ -1855,19 +2125,19 @@ def register_Ns3InetSocketAddress_methods(root_module, cls): ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetPort(uint16_t port) [member function] cls.add_method('SetPort', 'void', - [param('uint16_t', 'port')]) + [param('short unsigned int', 'port')]) ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function] cls.add_method('SetTos', 'void', - [param('uint8_t', 'tos')]) + [param('unsigned char', 'tos')]) return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -1973,7 +2243,7 @@ def register_Ns3Ipv4Address_methods(root_module, cls): ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function] cls.add_method('Set', 'void', - [param('uint32_t', 'address')]) + [param('unsigned int', 'address')]) ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function] cls.add_method('Set', 'void', @@ -1981,10 +2251,10 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -2040,21 +2310,21 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function] cls.add_method('Set', 'void', - [param('uint32_t', 'mask')]) + [param('unsigned int', 'mask')]) return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -2121,7 +2391,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -2243,9 +2513,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -2254,7 +2524,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -2301,10 +2571,10 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -2318,9 +2588,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -2350,11 +2620,11 @@ def register_Ns3LogComponent_methods(root_module, cls): return def register_Ns3Mac16Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address(ns3::Mac16Address const & arg0) [copy constructor] + ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address(ns3::Mac16Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac16Address const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address() [constructor] cls.add_constructor([]) @@ -2387,11 +2657,11 @@ def register_Ns3Mac16Address_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -2459,11 +2729,11 @@ def register_Ns3Mac48Address_methods(root_module, cls): return def register_Ns3Mac64Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor] + ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address() [constructor] cls.add_constructor([]) @@ -2496,7 +2766,7 @@ def register_Ns3Mac64Address_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -2518,20 +2788,20 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::NetDevice >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## net-device-container.h (module 'network'): uint32_t ns3::NetDeviceContainer::GetN() const [member function] cls.add_method('GetN', @@ -2541,7 +2811,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -2569,28 +2839,28 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] cls.add_method('Create', 'void', - [param('uint32_t', 'n')]) + [param('unsigned int', 'n')]) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n, uint32_t systemId) [member function] cls.add_method('Create', 'void', - [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + [param('unsigned int', 'n'), param('unsigned int', 'systemId')]) + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Node >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## node-container.h (module 'network'): static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function] cls.add_method('GetGlobal', @@ -2607,21 +2877,21 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3NodeList_methods(root_module, cls): ## node-list.h (module 'network'): ns3::NodeList::NodeList() [constructor] cls.add_constructor([]) - ## node-list.h (module 'network'): ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor] + ## node-list.h (module 'network'): ns3::NodeList::NodeList(ns3::NodeList const & arg0) [constructor] cls.add_constructor([param('ns3::NodeList const &', 'arg0')]) ## node-list.h (module 'network'): static uint32_t ns3::NodeList::Add(ns3::Ptr node) [member function] cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True) - ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::Begin() [member function] + ## node-list.h (module 'network'): static ns3::NodeList::Iterator ns3::NodeList::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeList::Iterator', [], is_static=True) - ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::End() [member function] + ## node-list.h (module 'network'): static ns3::NodeList::Iterator ns3::NodeList::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeList::Iterator', [], is_static=True) ## node-list.h (module 'network'): static uint32_t ns3::NodeList::GetNNodes() [member function] @@ -2632,7 +2902,7 @@ def register_Ns3NodeList_methods(root_module, cls): ## node-list.h (module 'network'): static ns3::Ptr ns3::NodeList::GetNode(uint32_t n) [member function] cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', - [param('uint32_t', 'n')], + [param('unsigned int', 'n')], is_static=True) return @@ -2645,7 +2915,7 @@ def register_Ns3NonCopyable_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -2706,7 +2976,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -2717,7 +2987,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -2754,7 +3024,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -2763,15 +3033,15 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddHeader(ns3::Header const & header, uint32_t size) [member function] cls.add_method('AddHeader', 'void', - [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) + [param('ns3::Header const &', 'header'), param('unsigned int', 'size')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function] cls.add_method('AddPaddingAtEnd', 'void', - [param('uint32_t', 'end')]) + [param('unsigned int', 'end')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] cls.add_method('AddTrailer', 'void', - [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) + [param('ns3::Trailer const &', 'trailer'), param('unsigned int', 'size')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::PacketMetadata::BeginItem(ns3::Buffer buffer) const [member function] cls.add_method('BeginItem', 'ns3::PacketMetadata::ItemIterator', @@ -2780,12 +3050,12 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata ns3::PacketMetadata::CreateFragment(uint32_t start, uint32_t end) const [member function] cls.add_method('CreateFragment', 'ns3::PacketMetadata', - [param('uint32_t', 'start'), param('uint32_t', 'end')], + [param('unsigned int', 'start'), param('unsigned int', 'end')], is_const=True) ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Deserialize(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function] cls.add_method('Enable', 'void', @@ -2809,30 +3079,30 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('uint32_t', 'end')]) + [param('unsigned int', 'end')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function] cls.add_method('RemoveAtStart', 'void', - [param('uint32_t', 'start')]) + [param('unsigned int', 'start')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveHeader(ns3::Header const & header, uint32_t size) [member function] cls.add_method('RemoveHeader', 'void', - [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) + [param('ns3::Header const &', 'header'), param('unsigned int', 'size')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] cls.add_method('RemoveTrailer', 'void', - [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) + [param('ns3::Trailer const &', 'trailer'), param('unsigned int', 'size')]) ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], + [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], is_const=True) return def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -2846,10 +3116,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -2865,7 +3137,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketSocketAddress_methods(root_module, cls): - ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor] + ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')]) ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress() [constructor] cls.add_constructor([]) @@ -2910,17 +3182,17 @@ def register_Ns3PacketSocketAddress_methods(root_module, cls): ## packet-socket-address.h (module 'network'): void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function] cls.add_method('SetProtocol', 'void', - [param('uint16_t', 'protocol')]) + [param('short unsigned int', 'protocol')]) ## packet-socket-address.h (module 'network'): void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function] cls.add_method('SetSingleDevice', 'void', - [param('uint32_t', 'device')]) + [param('unsigned int', 'device')]) return def register_Ns3PacketSocketHelper_methods(root_module, cls): ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper() [constructor] cls.add_constructor([]) - ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper(ns3::PacketSocketHelper const & arg0) [copy constructor] + ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper(ns3::PacketSocketHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketHelper const &', 'arg0')]) ## packet-socket-helper.h (module 'network'): void ns3::PacketSocketHelper::Install(ns3::Ptr node) const [member function] cls.add_method('Install', @@ -2940,7 +3212,7 @@ def register_Ns3PacketSocketHelper_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2954,7 +3226,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -2971,7 +3243,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -3005,7 +3277,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -3020,7 +3292,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -3029,7 +3301,7 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock(ns3::PbbAddressTlvBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock(ns3::PbbAddressTlvBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressTlvBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock() [constructor] cls.add_constructor([]) @@ -3038,13 +3310,13 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv >', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Begin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Begin() [member function] cls.add_method('Begin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressTlvBlock::Begin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::ConstIterator ns3::PbbAddressTlvBlock::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::ConstIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressTlvBlock::Clear() [member function] @@ -3060,23 +3332,23 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::End() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::End() [member function] cls.add_method('End', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressTlvBlock::End() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::ConstIterator ns3::PbbAddressTlvBlock::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::ConstIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Erase(ns3::PbbAddressTlvBlock::Iterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Erase(ns3::PbbAddressTlvBlock::Iterator first, ns3::PbbAddressTlvBlock::Iterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'last')]) + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbAddressTlvBlock::Front() const [member function] cls.add_method('Front', 'ns3::Ptr< ns3::PbbAddressTlv >', @@ -3087,10 +3359,10 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Insert(std::_List_iterator > position, ns3::Ptr const tlv) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Insert(ns3::PbbAddressTlvBlock::Iterator position, ns3::Ptr const tlv) [member function] cls.add_method('Insert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position'), param('ns3::Ptr< ns3::PbbAddressTlv > const', 'tlv')]) + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'position'), param('ns3::Ptr< ns3::PbbAddressTlv > const', 'tlv')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlvBlock::PopBack() [member function] cls.add_method('PopBack', 'void', @@ -3132,7 +3404,7 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): def register_Ns3PbbTlvBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock(ns3::PbbTlvBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock(ns3::PbbTlvBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbTlvBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock() [constructor] cls.add_constructor([]) @@ -3141,13 +3413,13 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv >', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Begin() [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Begin() [member function] cls.add_method('Begin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbTlvBlock::Begin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::ConstIterator ns3::PbbTlvBlock::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::ConstIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbTlvBlock::Clear() [member function] @@ -3163,23 +3435,23 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::End() [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::End() [member function] cls.add_method('End', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbTlvBlock::End() const [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::ConstIterator ns3::PbbTlvBlock::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::ConstIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Erase(ns3::PbbTlvBlock::Iterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Erase(ns3::PbbTlvBlock::Iterator first, ns3::PbbTlvBlock::Iterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbTlvBlock::Front() const [member function] cls.add_method('Front', 'ns3::Ptr< ns3::PbbTlv >', @@ -3190,10 +3462,10 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Insert(std::_List_iterator > position, ns3::Ptr const tlv) [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Insert(ns3::PbbTlvBlock::Iterator position, ns3::Ptr const tlv) [member function] cls.add_method('Insert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'tlv')]) + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'tlv')]) ## packetbb.h (module 'network'): void ns3::PbbTlvBlock::PopBack() [member function] cls.add_method('PopBack', 'void', @@ -3246,7 +3518,7 @@ def register_Ns3PcapFile_methods(root_module, cls): ## pcap-file.h (module 'network'): static bool ns3::PcapFile::Diff(std::string const & f1, std::string const & f2, uint32_t & sec, uint32_t & usec, uint32_t & packets, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT) [member function] cls.add_method('Diff', 'bool', - [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t &', 'packets'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], + [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t &', 'packets'), param('unsigned int', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], is_static=True) ## pcap-file.h (module 'network'): bool ns3::PcapFile::Eof() const [member function] cls.add_method('Eof', @@ -3293,31 +3565,31 @@ def register_Ns3PcapFile_methods(root_module, cls): ## pcap-file.h (module 'network'): void ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false, bool nanosecMode=false) [member function] cls.add_method('Init', 'void', - [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int32_t', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false'), param('bool', 'nanosecMode', default_value='false')]) + [param('unsigned int', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false'), param('bool', 'nanosecMode', default_value='false')]) ## pcap-file.h (module 'network'): bool ns3::PcapFile::IsNanoSecMode() [member function] cls.add_method('IsNanoSecMode', 'bool', []) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function] cls.add_method('Read', 'void', - [param('uint8_t * const', 'data'), param('uint32_t', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')]) + [param('uint8_t * const', 'data'), param('unsigned int', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function] cls.add_method('Write', 'void', - [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] + [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('uint8_t const * const', 'data'), param('unsigned int', 'totalLen')]) + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] cls.add_method('Write', 'void', - [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] + [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', - [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) + [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) ## pcap-file.h (module 'network'): ns3::PcapFile::SNAPLEN_DEFAULT [variable] cls.add_static_attribute('SNAPLEN_DEFAULT', 'uint32_t const', is_const=True) ## pcap-file.h (module 'network'): ns3::PcapFile::ZONE_DEFAULT [variable] @@ -3325,14 +3597,14 @@ def register_Ns3PcapFile_methods(root_module, cls): return def register_Ns3PcapHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::_Ios_Openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::ios_base::openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] cls.add_method('CreateFile', 'ns3::Ptr< ns3::PcapFileWrapper >', - [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='0')]) + [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='std::numeric_limits::max()'), param('int', 'tzCorrection', default_value='0')]) ## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr device, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromDevice', 'std::string', @@ -3340,11 +3612,11 @@ def register_Ns3PcapHelper_methods(root_module, cls): ## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr object, uint32_t interface, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromInterfacePair', 'std::string', - [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')]) + [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('unsigned int', 'interface'), param('bool', 'useObjectNames', default_value='true')]) return def register_Ns3PcapHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice() [constructor] cls.add_constructor([]) @@ -3367,7 +3639,7 @@ def register_Ns3PcapHelperForDevice_methods(root_module, cls): ## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function] cls.add_method('EnablePcap', 'void', - [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')]) + [param('std::string', 'prefix'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid'), param('bool', 'promiscuous', default_value='false')]) ## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function] cls.add_method('EnablePcapAll', 'void', @@ -3395,7 +3667,7 @@ def register_Ns3SequenceNumber32_methods(root_module, cls): cls.add_constructor([]) ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(unsigned int value) [constructor] cls.add_constructor([param('unsigned int', 'value')]) - ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [copy constructor] + ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber< unsigned int, int > const &', 'value')]) ## sequence-number.h (module 'network'): unsigned int ns3::SequenceNumber::GetValue() const [member function] cls.add_method('GetValue', @@ -3420,7 +3692,7 @@ def register_Ns3SequenceNumber16_methods(root_module, cls): cls.add_constructor([]) ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(short unsigned int value) [constructor] cls.add_constructor([param('short unsigned int', 'value')]) - ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [copy constructor] + ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber< unsigned short, short > const &', 'value')]) ## sequence-number.h (module 'network'): short unsigned int ns3::SequenceNumber::GetValue() const [member function] cls.add_method('GetValue', @@ -3430,7 +3702,7 @@ def register_Ns3SequenceNumber16_methods(root_module, cls): return def register_Ns3SimpleNetDeviceHelper_methods(root_module, cls): - ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper(ns3::SimpleNetDeviceHelper const & arg0) [copy constructor] + ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper(ns3::SimpleNetDeviceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleNetDeviceHelper const &', 'arg0')]) ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper() [constructor] cls.add_constructor([]) @@ -3479,7 +3751,7 @@ def register_Ns3SimpleNetDeviceHelper_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -3489,7 +3761,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -3571,7 +3843,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3StatisticalSummary_methods(root_module, cls): ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary() [constructor] cls.add_constructor([]) - ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [constructor] cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')]) ## data-calculator.h (module 'stats'): long int ns3::StatisticalSummary::getCount() const [member function] cls.add_method('getCount', @@ -3616,7 +3888,7 @@ def register_Ns3StatisticalSummary_methods(root_module, cls): return def register_Ns3SystemWallClockMs_methods(root_module, cls): - ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor] + ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [constructor] cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')]) ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs() [constructor] cls.add_constructor([]) @@ -3648,7 +3920,7 @@ def register_Ns3SystemWallClockMs_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -3678,7 +3950,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -3689,7 +3961,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t *', 'buffer'), param('unsigned int', 'size')]) ## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function] cls.add_method('ReadDouble', 'double', @@ -3713,36 +3985,36 @@ def register_Ns3TagBuffer_methods(root_module, cls): ## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function] cls.add_method('TrimAtEnd', 'void', - [param('uint32_t', 'trim')]) + [param('unsigned int', 'trim')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Write', 'void', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteDouble(double v) [member function] cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('short unsigned int', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('unsigned int', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', - [param('uint64_t', 'v')]) + [param('long unsigned int', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function] cls.add_method('WriteU8', 'void', - [param('uint8_t', 'v')]) + [param('unsigned char', 'v')]) return def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -3751,11 +4023,15 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(unsigned int const & v) [constructor] cls.add_constructor([param('unsigned int const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -3763,7 +4039,7 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -3783,49 +4059,48 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('unsigned int', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] cls.add_method('GetAttributeFullName', 'std::string', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function] cls.add_method('GetAttributeN', 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -3835,9 +4110,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -3853,7 +4128,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] cls.add_method('GetRegistered', 'ns3::TypeId', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_static=True) ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function] cls.add_method('GetRegisteredN', @@ -3868,7 +4143,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function] cls.add_method('GetTraceSource', 'ns3::TypeId::TraceSourceInformation', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function] cls.add_method('GetTraceSourceN', @@ -3904,12 +4179,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -3919,12 +4194,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -3934,10 +4209,10 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', - [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) + [param('unsigned int', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] cls.add_method('SetGroupName', 'ns3::TypeId', @@ -3950,32 +4225,31 @@ def register_Ns3TypeId_methods(root_module, cls): cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::Object']) + template_parameters=[u'ns3::QueueBase']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent() [member function] cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::QueueBase']) + template_parameters=[u'ns3::Object']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', - [param('std::size_t', 'size')]) + [param('long unsigned int', 'size')]) ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t uid) [member function] cls.add_method('SetUid', 'void', - [param('uint16_t', 'uid')]) + [param('short unsigned int', 'uid')]) return def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -3994,7 +4268,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -4013,81 +4287,81 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -4107,7 +4381,7 @@ def register_Ns3Chunk_methods(root_module, cls): return def register_Ns3DeviceNameTag_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag(ns3::DeviceNameTag const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag(ns3::DeviceNameTag const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceNameTag const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag() [constructor] cls.add_constructor([]) @@ -4153,7 +4427,7 @@ def register_Ns3DeviceNameTag_methods(root_module, cls): return def register_Ns3FlowIdTag_methods(root_module, cls): - ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag(ns3::FlowIdTag const & arg0) [copy constructor] + ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag(ns3::FlowIdTag const & arg0) [constructor] cls.add_constructor([param('ns3::FlowIdTag const &', 'arg0')]) ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag() [constructor] cls.add_constructor([]) @@ -4202,14 +4476,14 @@ def register_Ns3FlowIdTag_methods(root_module, cls): ## flow-id-tag.h (module 'network'): void ns3::FlowIdTag::SetFlowId(uint32_t flowId) [member function] cls.add_method('SetFlowId', 'void', - [param('uint32_t', 'flowId')]) + [param('unsigned int', 'flowId')]) return def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -4239,7 +4513,7 @@ def register_Ns3Header_methods(root_module, cls): return def register_Ns3LlcSnapHeader_methods(root_module, cls): - ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor] + ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')]) ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader() [constructor] cls.add_constructor([]) @@ -4280,7 +4554,7 @@ def register_Ns3LlcSnapHeader_methods(root_module, cls): ## llc-snap-header.h (module 'network'): void ns3::LlcSnapHeader::SetType(uint16_t type) [member function] cls.add_method('SetType', 'void', - [param('uint16_t', 'type')]) + [param('short unsigned int', 'type')]) return def register_Ns3Object_methods(root_module, cls): @@ -4308,7 +4582,7 @@ def register_Ns3Object_methods(root_module, cls): cls.add_method('GetObject', 'ns3::Ptr< ns3::NetDevice >', [], - is_const=True, template_parameters=['ns3::NetDevice']) + is_const=True, template_parameters=[u'ns3::NetDevice']) ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -4323,7 +4597,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -4344,7 +4618,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -4353,14 +4627,14 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) return def register_Ns3PacketBurst_methods(root_module, cls): - ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor] + ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [constructor] cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')]) ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor] cls.add_constructor([]) @@ -4368,9 +4642,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): cls.add_method('AddPacket', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')]) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::Begin() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): ns3::Ptr ns3::PacketBurst::Copy() const [member function] @@ -4378,9 +4652,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): 'ns3::Ptr< ns3::PacketBurst >', [], is_const=True) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::End() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function] @@ -4411,7 +4685,7 @@ def register_Ns3PacketBurst_methods(root_module, cls): return def register_Ns3PacketSocketTag_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag(ns3::PacketSocketTag const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag(ns3::PacketSocketTag const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketTag const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag() [constructor] cls.add_constructor([]) @@ -4487,7 +4761,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): cls.add_method('Clear', 'void', []) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) @@ -4498,19 +4772,19 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=ns3::PcapFile::ZONE_DEFAULT) [member function] cls.add_method('Init', 'void', - [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] + [param('unsigned int', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='std::numeric_limits::max()'), param('int', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, uint8_t const * buffer, uint32_t length) [member function] cls.add_method('Write', 'void', - [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('uint32_t', 'length')]) + [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('unsigned int', 'length')]) ## pcap-file-wrapper.h (module 'network'): ns3::Ptr ns3::PcapFileWrapper::Read(ns3::Time & t) [member function] cls.add_method('Read', 'ns3::Ptr< ns3::Packet >', @@ -4546,7 +4820,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): return def register_Ns3QueueBase_methods(root_module, cls): - ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [copy constructor] + ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [constructor] cls.add_constructor([param('ns3::QueueBase const &', 'arg0')]) ## queue.h (module 'network'): ns3::QueueBase::QueueBase() [constructor] cls.add_constructor([]) @@ -4637,26 +4911,21 @@ def register_Ns3QueueBase_methods(root_module, cls): ## queue.h (module 'network'): void ns3::QueueBase::SetMaxBytes(uint32_t maxBytes) [member function] cls.add_method('SetMaxBytes', 'void', - [param('uint32_t', 'maxBytes')]) + [param('unsigned int', 'maxBytes')]) ## queue.h (module 'network'): void ns3::QueueBase::SetMaxPackets(uint32_t maxPackets) [member function] cls.add_method('SetMaxPackets', 'void', - [param('uint32_t', 'maxPackets')]) + [param('unsigned int', 'maxPackets')]) ## queue.h (module 'network'): void ns3::QueueBase::SetMode(ns3::QueueBase::QueueMode mode) [member function] cls.add_method('SetMode', 'void', [param('ns3::QueueBase::QueueMode', 'mode')]) - ## queue.h (module 'network'): void ns3::QueueBase::DoNsLog(ns3::LogLevel const level, std::string str) const [member function] - cls.add_method('DoNsLog', - 'void', - [param('ns3::LogLevel const', 'level'), param('std::string', 'str')], - is_const=True, visibility='protected') return def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits() [constructor] cls.add_constructor([]) - ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits(ns3::QueueLimits const & arg0) [copy constructor] + ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits(ns3::QueueLimits const & arg0) [constructor] cls.add_constructor([param('ns3::QueueLimits const &', 'arg0')]) ## queue-limits.h (module 'network'): int32_t ns3::QueueLimits::Available() const [member function] cls.add_method('Available', @@ -4666,7 +4935,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): void ns3::QueueLimits::Completed(uint32_t count) [member function] cls.add_method('Completed', 'void', - [param('uint32_t', 'count')], + [param('unsigned int', 'count')], is_pure_virtual=True, is_virtual=True) ## queue-limits.h (module 'network'): static ns3::TypeId ns3::QueueLimits::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4676,7 +4945,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): void ns3::QueueLimits::Queued(uint32_t count) [member function] cls.add_method('Queued', 'void', - [param('uint32_t', 'count')], + [param('unsigned int', 'count')], is_pure_virtual=True, is_virtual=True) ## queue-limits.h (module 'network'): void ns3::QueueLimits::Reset() [member function] cls.add_method('Reset', @@ -4686,7 +4955,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): return def register_Ns3RadiotapHeader_methods(root_module, cls): - ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [copy constructor] + ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RadiotapHeader const &', 'arg0')]) ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader() [constructor] cls.add_constructor([]) @@ -4833,7 +5102,7 @@ def register_Ns3RadiotapHeader_methods(root_module, cls): ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetAmpduStatus(uint32_t referenceNumber, uint16_t flags, uint8_t crc) [member function] cls.add_method('SetAmpduStatus', 'void', - [param('uint32_t', 'referenceNumber'), param('uint16_t', 'flags'), param('uint8_t', 'crc')]) + [param('unsigned int', 'referenceNumber'), param('short unsigned int', 'flags'), param('unsigned char', 'crc')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetAntennaNoisePower(double noise) [member function] cls.add_method('SetAntennaNoisePower', 'void', @@ -4845,27 +5114,27 @@ def register_Ns3RadiotapHeader_methods(root_module, cls): ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetChannelFrequencyAndFlags(uint16_t frequency, uint16_t flags) [member function] cls.add_method('SetChannelFrequencyAndFlags', 'void', - [param('uint16_t', 'frequency'), param('uint16_t', 'flags')]) + [param('short unsigned int', 'frequency'), param('short unsigned int', 'flags')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetFrameFlags(uint8_t flags) [member function] cls.add_method('SetFrameFlags', 'void', - [param('uint8_t', 'flags')]) + [param('unsigned char', 'flags')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetMcsFields(uint8_t known, uint8_t flags, uint8_t mcs) [member function] cls.add_method('SetMcsFields', 'void', - [param('uint8_t', 'known'), param('uint8_t', 'flags'), param('uint8_t', 'mcs')]) + [param('unsigned char', 'known'), param('unsigned char', 'flags'), param('unsigned char', 'mcs')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetRate(uint8_t rate) [member function] cls.add_method('SetRate', 'void', - [param('uint8_t', 'rate')]) + [param('unsigned char', 'rate')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetTsft(uint64_t tsft) [member function] cls.add_method('SetTsft', 'void', - [param('uint64_t', 'tsft')]) + [param('long unsigned int', 'tsft')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetVhtFields(uint16_t known, uint8_t flags, uint8_t bandwidth, uint8_t * mcs_nss, uint8_t coding, uint8_t group_id, uint16_t partial_aid) [member function] cls.add_method('SetVhtFields', 'void', - [param('uint16_t', 'known'), param('uint8_t', 'flags'), param('uint8_t', 'bandwidth'), param('uint8_t *', 'mcs_nss'), param('uint8_t', 'coding'), param('uint8_t', 'group_id'), param('uint16_t', 'partial_aid')]) + [param('short unsigned int', 'known'), param('unsigned char', 'flags'), param('unsigned char', 'bandwidth'), param('uint8_t *', 'mcs_nss'), param('unsigned char', 'coding'), param('unsigned char', 'group_id'), param('short unsigned int', 'partial_aid')]) return def register_Ns3RandomVariableStream_methods(root_module, cls): @@ -4879,7 +5148,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::RandomVariableStream::SetStream(int64_t stream) [member function] cls.add_method('SetStream', 'void', - [param('int64_t', 'stream')]) + [param('long int', 'stream')]) ## random-variable-stream.h (module 'core'): int64_t ns3::RandomVariableStream::GetStream() const [member function] cls.add_method('GetStream', 'int64_t', @@ -4954,7 +5223,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4966,7 +5235,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4978,7 +5247,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4990,7 +5259,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5002,7 +5271,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5014,7 +5283,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5026,7 +5295,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3NetDeviceQueue_Ns3Empty_Ns3DefaultDeleter__lt__ns3NetDeviceQueue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NetDeviceQueue, ns3::empty, ns3::DefaultDeleter< ns3::NetDeviceQueue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5038,7 +5307,7 @@ def register_Ns3SimpleRefCount__Ns3NetDeviceQueue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5050,7 +5319,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter< ns3::OutputStreamWrapper > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5062,7 +5331,7 @@ def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5074,7 +5343,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbAddressBlock__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbAddressBlock, ns3::empty, ns3::DefaultDeleter< ns3::PbbAddressBlock > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5086,7 +5355,7 @@ def register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__l def register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbMessage__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbMessage, ns3::empty, ns3::DefaultDeleter< ns3::PbbMessage > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5098,7 +5367,7 @@ def register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3PbbPacket_Ns3Header_Ns3DefaultDeleter__lt__ns3PbbPacket__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbPacket, ns3::Header, ns3::DefaultDeleter< ns3::PbbPacket > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5110,7 +5379,7 @@ def register_Ns3SimpleRefCount__Ns3PbbPacket_Ns3Header_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3PbbTlv_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbTlv__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbTlv, ns3::empty, ns3::DefaultDeleter< ns3::PbbTlv > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5122,7 +5391,7 @@ def register_Ns3SimpleRefCount__Ns3PbbTlv_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pbb def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3QueueItem__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter< ns3::QueueItem > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5134,7 +5403,7 @@ def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5144,7 +5413,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete return def register_Ns3SllHeader_methods(root_module, cls): - ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader(ns3::SllHeader const & arg0) [copy constructor] + ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader(ns3::SllHeader const & arg0) [constructor] cls.add_constructor([param('ns3::SllHeader const &', 'arg0')]) ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader() [constructor] cls.add_constructor([]) @@ -5191,7 +5460,7 @@ def register_Ns3SllHeader_methods(root_module, cls): ## sll-header.h (module 'network'): void ns3::SllHeader::SetArpType(uint16_t arphdType) [member function] cls.add_method('SetArpType', 'void', - [param('uint16_t', 'arphdType')]) + [param('short unsigned int', 'arphdType')]) ## sll-header.h (module 'network'): void ns3::SllHeader::SetPacketType(ns3::SllHeader::PacketType type) [member function] cls.add_method('SetPacketType', 'void', @@ -5199,7 +5468,7 @@ def register_Ns3SllHeader_methods(root_module, cls): return def register_Ns3Socket_methods(root_module, cls): - ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [constructor] cls.add_constructor([param('ns3::Socket const &', 'arg0')]) ## socket.h (module 'network'): ns3::Socket::Socket() [constructor] cls.add_constructor([]) @@ -5315,9 +5584,9 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function] cls.add_method('IpTos2Priority', 'uint8_t', - [param('uint8_t', 'ipTos')], + [param('unsigned char', 'ipTos')], is_static=True) - ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] + ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] cls.add_method('Ipv6JoinGroup', 'void', [param('ns3::Ipv6Address', 'address'), param('ns3::Socket::Ipv6MulticastFilterMode', 'filterMode'), param('std::vector< ns3::Ipv6Address >', 'sourceAddresses')], @@ -5365,7 +5634,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): ns3::Ptr ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function] cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', - [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], + [param('unsigned int', 'maxSize'), param('unsigned int', 'flags')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::Recv() [member function] cls.add_method('Recv', @@ -5374,11 +5643,11 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function] cls.add_method('Recv', 'int', - [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')]) + [param('uint8_t *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags')]) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', - [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')], + [param('unsigned int', 'maxSize'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', @@ -5387,11 +5656,11 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'int', - [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')]) + [param('uint8_t *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')]) ## socket.h (module 'network'): int ns3::Socket::Send(ns3::Ptr p, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): int ns3::Socket::Send(ns3::Ptr p) [member function] cls.add_method('Send', @@ -5400,17 +5669,17 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')]) + [param('uint8_t const *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags')]) ## socket.h (module 'network'): int ns3::Socket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] cls.add_method('SendTo', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags'), param('ns3::Address const &', 'toAddress')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function] cls.add_method('SendTo', 'int', - [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')]) - ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] + [param('uint8_t const *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags'), param('ns3::Address const &', 'address')]) + ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] cls.add_method('SetAcceptCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')]) @@ -5442,16 +5711,16 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::SetIpTos(uint8_t ipTos) [member function] cls.add_method('SetIpTos', 'void', - [param('uint8_t', 'ipTos')]) + [param('unsigned char', 'ipTos')]) ## socket.h (module 'network'): void ns3::Socket::SetIpTtl(uint8_t ipTtl) [member function] cls.add_method('SetIpTtl', 'void', - [param('uint8_t', 'ipTtl')], + [param('unsigned char', 'ipTtl')], is_virtual=True) ## socket.h (module 'network'): void ns3::Socket::SetIpv6HopLimit(uint8_t ipHopLimit) [member function] cls.add_method('SetIpv6HopLimit', 'void', - [param('uint8_t', 'ipHopLimit')], + [param('unsigned char', 'ipHopLimit')], is_virtual=True) ## socket.h (module 'network'): void ns3::Socket::SetIpv6RecvHopLimit(bool ipv6RecvHopLimit) [member function] cls.add_method('SetIpv6RecvHopLimit', @@ -5468,7 +5737,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function] cls.add_method('SetPriority', 'void', - [param('uint8_t', 'priority')]) + [param('unsigned char', 'priority')]) ## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function] cls.add_method('SetRecvCallback', 'void', @@ -5534,7 +5803,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::NotifyDataSent(uint32_t size) [member function] cls.add_method('NotifyDataSent', 'void', - [param('uint32_t', 'size')], + [param('unsigned int', 'size')], visibility='protected') ## socket.h (module 'network'): void ns3::Socket::NotifyErrorClose() [member function] cls.add_method('NotifyErrorClose', @@ -5554,12 +5823,12 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function] cls.add_method('NotifySend', 'void', - [param('uint32_t', 'spaceAvailable')], + [param('unsigned int', 'spaceAvailable')], visibility='protected') return def register_Ns3SocketFactory_methods(root_module, cls): - ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor] + ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [constructor] cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')]) ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory() [constructor] cls.add_constructor([]) @@ -5576,7 +5845,7 @@ def register_Ns3SocketFactory_methods(root_module, cls): return def register_Ns3SocketIpTosTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTosTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag() [constructor] cls.add_constructor([]) @@ -5618,11 +5887,11 @@ def register_Ns3SocketIpTosTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpTosTag::SetTos(uint8_t tos) [member function] cls.add_method('SetTos', 'void', - [param('uint8_t', 'tos')]) + [param('unsigned char', 'tos')]) return def register_Ns3SocketIpTtlTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor] cls.add_constructor([]) @@ -5664,11 +5933,11 @@ def register_Ns3SocketIpTtlTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function] cls.add_method('SetTtl', 'void', - [param('uint8_t', 'ttl')]) + [param('unsigned char', 'ttl')]) return def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6HopLimitTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag() [constructor] cls.add_constructor([]) @@ -5710,11 +5979,11 @@ def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpv6HopLimitTag::SetHopLimit(uint8_t hopLimit) [member function] cls.add_method('SetHopLimit', 'void', - [param('uint8_t', 'hopLimit')]) + [param('unsigned char', 'hopLimit')]) return def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6TclassTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag() [constructor] cls.add_constructor([]) @@ -5756,11 +6025,11 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpv6TclassTag::SetTclass(uint8_t tclass) [member function] cls.add_method('SetTclass', 'void', - [param('uint8_t', 'tclass')]) + [param('unsigned char', 'tclass')]) return def register_Ns3SocketPriorityTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor] cls.add_constructor([]) @@ -5802,11 +6071,11 @@ def register_Ns3SocketPriorityTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function] cls.add_method('SetPriority', 'void', - [param('uint8_t', 'priority')]) + [param('unsigned char', 'priority')]) return def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor] cls.add_constructor([]) @@ -5856,22 +6125,22 @@ def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -5919,7 +6188,7 @@ def register_Ns3Time_methods(root_module, cls): ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit unit) [member function] cls.add_method('FromInteger', 'ns3::Time', - [param('uint64_t', 'value'), param('ns3::Time::Unit', 'unit')], + [param('long unsigned int', 'value'), param('ns3::Time::Unit', 'unit')], is_static=True) ## nstime.h (module 'core'): double ns3::Time::GetDays() const [member function] cls.add_method('GetDays', @@ -6054,7 +6323,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -6084,7 +6353,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -6143,7 +6412,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::TriangularRandomVariable::GetInteger(uint32_t mean, uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'min'), param('uint32_t', 'max')]) + [param('unsigned int', 'mean'), param('unsigned int', 'min'), param('unsigned int', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::TriangularRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6181,7 +6450,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::UniformRandomVariable::GetInteger(uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'min'), param('uint32_t', 'max')]) + [param('unsigned int', 'min'), param('unsigned int', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::UniformRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6224,7 +6493,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::WeibullRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) + [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::WeibullRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6257,7 +6526,7 @@ def register_Ns3ZetaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ZetaRandomVariable::GetInteger(uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'alpha')]) + [param('unsigned int', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZetaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6291,11 +6560,11 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue(uint32_t n, double alpha) [member function] cls.add_method('GetValue', 'double', - [param('uint32_t', 'n'), param('double', 'alpha')]) + [param('unsigned int', 'n'), param('double', 'alpha')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ZipfRandomVariable::GetInteger(uint32_t n, uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'n'), param('uint32_t', 'alpha')]) + [param('unsigned int', 'n'), param('unsigned int', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6309,7 +6578,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3Application_methods(root_module, cls): - ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [copy constructor] + ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [constructor] cls.add_constructor([param('ns3::Application const &', 'arg0')]) ## application.h (module 'network'): ns3::Application::Application() [constructor] cls.add_constructor([]) @@ -6358,7 +6627,7 @@ def register_Ns3Application_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -6385,7 +6654,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -6427,7 +6696,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -6436,12 +6705,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6451,13 +6720,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -6468,7 +6737,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6478,7 +6747,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6492,21 +6761,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -6516,10 +6785,75 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -6530,12 +6864,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6547,14 +6881,14 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) ## channel.h (module 'network'): ns3::Ptr ns3::Channel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) ## channel.h (module 'network'): uint32_t ns3::Channel::GetId() const [member function] cls.add_method('GetId', @@ -6593,7 +6927,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ConstantRandomVariable::GetInteger(uint32_t constant) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'constant')]) + [param('unsigned int', 'constant')]) ## random-variable-stream.h (module 'core'): double ns3::ConstantRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6607,7 +6941,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DataCalculator_methods(root_module, cls): - ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')]) ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator() [constructor] cls.add_constructor([]) @@ -6670,7 +7004,7 @@ def register_Ns3DataCalculator_methods(root_module, cls): return def register_Ns3DataCollectionObject_methods(root_module, cls): - ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject(ns3::DataCollectionObject const & arg0) [copy constructor] + ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject(ns3::DataCollectionObject const & arg0) [constructor] cls.add_constructor([param('ns3::DataCollectionObject const &', 'arg0')]) ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject() [constructor] cls.add_constructor([]) @@ -6704,7 +7038,7 @@ def register_Ns3DataCollectionObject_methods(root_module, cls): return def register_Ns3DataOutputInterface_methods(root_module, cls): - ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')]) ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface() [constructor] cls.add_constructor([]) @@ -6737,23 +7071,23 @@ def register_Ns3DataOutputInterface_methods(root_module, cls): def register_Ns3DataRateChecker_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')]) return def register_Ns3DataRateValue_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'value')]) + ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::Ptr ns3::DataRateValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6763,7 +7097,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): 'ns3::DataRate', [], is_const=True) - ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6785,7 +7119,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] cls.add_method('SetValueArray', 'void', - [param('double *', 'values'), param('uint64_t', 'length')]) + [param('double *', 'values'), param('long unsigned int', 'length')]) ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6801,16 +7135,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6820,7 +7154,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6832,7 +7166,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): return def register_Ns3DynamicQueueLimits_methods(root_module, cls): - ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits(ns3::DynamicQueueLimits const & arg0) [copy constructor] + ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits(ns3::DynamicQueueLimits const & arg0) [constructor] cls.add_constructor([param('ns3::DynamicQueueLimits const &', 'arg0')]) ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits() [constructor] cls.add_constructor([]) @@ -6844,7 +7178,7 @@ def register_Ns3DynamicQueueLimits_methods(root_module, cls): ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Completed(uint32_t count) [member function] cls.add_method('Completed', 'void', - [param('uint32_t', 'count')], + [param('unsigned int', 'count')], is_virtual=True) ## dynamic-queue-limits.h (module 'network'): static ns3::TypeId ns3::DynamicQueueLimits::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -6854,7 +7188,7 @@ def register_Ns3DynamicQueueLimits_methods(root_module, cls): ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Queued(uint32_t count) [member function] cls.add_method('Queued', 'void', - [param('uint32_t', 'count')], + [param('unsigned int', 'count')], is_virtual=True) ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Reset() [member function] cls.add_method('Reset', @@ -6898,7 +7232,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -6925,7 +7259,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -6962,7 +7296,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -6971,12 +7305,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6984,7 +7318,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -7029,7 +7363,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -7040,7 +7374,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7050,7 +7384,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7082,11 +7416,11 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue(uint32_t k, double lambda) [member function] cls.add_method('GetValue', 'double', - [param('uint32_t', 'k'), param('double', 'lambda')]) + [param('unsigned int', 'k'), param('double', 'lambda')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ErlangRandomVariable::GetInteger(uint32_t k, uint32_t lambda) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'k'), param('uint32_t', 'lambda')]) + [param('unsigned int', 'k'), param('unsigned int', 'lambda')]) ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7100,7 +7434,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3ErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel() [constructor] cls.add_constructor([]) @@ -7143,7 +7477,7 @@ def register_Ns3ErrorModel_methods(root_module, cls): return def register_Ns3EthernetHeader_methods(root_module, cls): - ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor] + ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')]) ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor] cls.add_constructor([param('bool', 'hasPreamble')]) @@ -7216,11 +7550,11 @@ def register_Ns3EthernetHeader_methods(root_module, cls): ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function] cls.add_method('SetLengthType', 'void', - [param('uint16_t', 'size')]) + [param('short unsigned int', 'size')]) ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function] cls.add_method('SetPreambleSfd', 'void', - [param('uint64_t', 'preambleSfd')]) + [param('long unsigned int', 'preambleSfd')]) ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function] cls.add_method('SetSource', 'void', @@ -7228,15 +7562,15 @@ def register_Ns3EthernetHeader_methods(root_module, cls): return def register_Ns3EthernetTrailer_methods(root_module, cls): - ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor] + ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [constructor] cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')]) ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer() [constructor] cls.add_constructor([]) - ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::CalcFcs(ns3::Ptr p) [member function] + ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::CalcFcs(ns3::Ptr p) [member function] cls.add_method('CalcFcs', 'void', [param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## ethernet-trailer.h (module 'network'): bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr p) const [member function] + ## ethernet-trailer.h (module 'network'): bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr p) const [member function] cls.add_method('CheckFcs', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'p')], @@ -7288,11 +7622,11 @@ def register_Ns3EthernetTrailer_methods(root_module, cls): ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function] cls.add_method('SetFcs', 'void', - [param('uint32_t', 'fcs')]) + [param('unsigned int', 'fcs')]) return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -7340,7 +7674,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ExponentialRandomVariable::GetInteger(uint32_t mean, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'bound')]) + [param('unsigned int', 'mean'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ExponentialRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7378,7 +7712,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::GammaRandomVariable::GetInteger(uint32_t alpha, uint32_t beta) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'alpha'), param('uint32_t', 'beta')]) + [param('unsigned int', 'alpha'), param('unsigned int', 'beta')]) ## random-variable-stream.h (module 'core'): double ns3::GammaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7394,16 +7728,16 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7413,7 +7747,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7427,23 +7761,23 @@ def register_Ns3IntegerValue_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7453,7 +7787,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7467,23 +7801,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7493,7 +7827,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7507,23 +7841,23 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7533,7 +7867,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7547,23 +7881,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7573,7 +7907,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7585,7 +7919,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): return def register_Ns3ListErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel() [constructor] cls.add_constructor([]) @@ -7640,7 +7974,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::LogNormalRandomVariable::GetInteger(uint32_t mu, uint32_t sigma) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mu'), param('uint32_t', 'sigma')]) + [param('unsigned int', 'mu'), param('unsigned int', 'sigma')]) ## random-variable-stream.h (module 'core'): double ns3::LogNormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7656,23 +7990,23 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): def register_Ns3Mac16AddressChecker_methods(root_module, cls): ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker() [constructor] cls.add_constructor([]) - ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker(ns3::Mac16AddressChecker const & arg0) [copy constructor] + ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker(ns3::Mac16AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac16AddressChecker const &', 'arg0')]) return def register_Ns3Mac16AddressValue_methods(root_module, cls): ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue() [constructor] cls.add_constructor([]) - ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac16AddressValue const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16Address const & value) [constructor] cls.add_constructor([param('ns3::Mac16Address const &', 'value')]) + ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac16AddressValue const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Ptr ns3::Mac16AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac16-address.h (module 'network'): bool ns3::Mac16AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac16-address.h (module 'network'): bool ns3::Mac16AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7682,7 +8016,7 @@ def register_Ns3Mac16AddressValue_methods(root_module, cls): 'ns3::Mac16Address', [], is_const=True) - ## mac16-address.h (module 'network'): std::string ns3::Mac16AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac16-address.h (module 'network'): std::string ns3::Mac16AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7696,23 +8030,23 @@ def register_Ns3Mac16AddressValue_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7722,7 +8056,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7736,23 +8070,23 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): def register_Ns3Mac64AddressChecker_methods(root_module, cls): ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker() [constructor] cls.add_constructor([]) - ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker(ns3::Mac64AddressChecker const & arg0) [copy constructor] + ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker(ns3::Mac64AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac64AddressChecker const &', 'arg0')]) return def register_Ns3Mac64AddressValue_methods(root_module, cls): ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue() [constructor] cls.add_constructor([]) - ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac64AddressValue const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64Address const & value) [constructor] cls.add_constructor([param('ns3::Mac64Address const &', 'value')]) + ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac64AddressValue const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Ptr ns3::Mac64AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac64-address.h (module 'network'): bool ns3::Mac64AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac64-address.h (module 'network'): bool ns3::Mac64AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7762,7 +8096,7 @@ def register_Ns3Mac64AddressValue_methods(root_module, cls): 'ns3::Mac64Address', [], is_const=True) - ## mac64-address.h (module 'network'): std::string ns3::Mac64AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac64-address.h (module 'network'): std::string ns3::Mac64AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7774,7 +8108,7 @@ def register_Ns3Mac64AddressValue_methods(root_module, cls): return def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls): - ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [copy constructor] + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')]) ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) @@ -7846,7 +8180,7 @@ def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls) def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -7931,12 +8265,12 @@ def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): bool ns3::NetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('Send', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], is_pure_virtual=True, is_virtual=True) ## net-device.h (module 'network'): bool ns3::NetDevice::SendFrom(ns3::Ptr packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('SendFrom', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], is_pure_virtual=True, is_virtual=True) ## net-device.h (module 'network'): void ns3::NetDevice::SetAddress(ns3::Address address) [member function] cls.add_method('SetAddress', @@ -7958,12 +8292,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -7976,7 +8310,7 @@ def register_Ns3NetDevice_methods(root_module, cls): return def register_Ns3NetDeviceQueue_methods(root_module, cls): - ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue(ns3::NetDeviceQueue const & arg0) [copy constructor] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue(ns3::NetDeviceQueue const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')]) ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor] cls.add_constructor([]) @@ -7992,11 +8326,11 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::NotifyQueuedBytes(uint32_t bytes) [member function] cls.add_method('NotifyQueuedBytes', 'void', - [param('uint32_t', 'bytes')]) + [param('unsigned int', 'bytes')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::NotifyTransmittedBytes(uint32_t bytes) [member function] cls.add_method('NotifyTransmittedBytes', 'void', - [param('uint32_t', 'bytes')]) + [param('unsigned int', 'bytes')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::ResetQueueLimits() [member function] cls.add_method('ResetQueueLimits', 'void', @@ -8005,7 +8339,7 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): cls.add_method('SetQueueLimits', 'void', [param('ns3::Ptr< ns3::QueueLimits >', 'ql')]) - ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::SetWakeCallback(ns3::Callback cb) [member function] + ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::SetWakeCallback(ns3::NetDeviceQueue::WakeCallback cb) [member function] cls.add_method('SetWakeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -8028,7 +8362,7 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): return def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): - ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface(ns3::NetDeviceQueueInterface const & arg0) [copy constructor] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface(ns3::NetDeviceQueueInterface const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')]) ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor] cls.add_constructor([]) @@ -8046,15 +8380,15 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): 'uint8_t', [], is_const=True) - ## net-device-queue-interface.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::SelectQueueCallback ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function] cls.add_method('GetSelectQueueCallback', - 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', + 'ns3::NetDeviceQueueInterface::SelectQueueCallback', [], is_const=True) ## net-device-queue-interface.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function] cls.add_method('GetTxQueue', 'ns3::Ptr< ns3::NetDeviceQueue >', - [param('uint8_t', 'i')], + [param('unsigned char', 'i')], is_const=True) ## net-device-queue-interface.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -8065,14 +8399,14 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): cls.add_method('SetLateTxQueuesCreation', 'void', [param('bool', 'value')]) - ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetSelectQueueCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetSelectQueueCallback(ns3::NetDeviceQueueInterface::SelectQueueCallback cb) [member function] cls.add_method('SetSelectQueueCallback', 'void', [param('ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetTxQueuesN(uint8_t numTxQueues) [member function] cls.add_method('SetTxQueuesN', 'void', - [param('uint8_t', 'numTxQueues')]) + [param('unsigned char', 'numTxQueues')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -8084,16 +8418,16 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', 'void', - [param('uint32_t', 'newBits'), param('uint32_t', 'numberOfBits')]) + [param('unsigned int', 'newBits'), param('unsigned int', 'numberOfBits')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::BitCount(uint32_t numberOfNeighbors) const [member function] cls.add_method('BitCount', 'uint32_t', - [param('uint32_t', 'numberOfNeighbors')], + [param('unsigned int', 'numberOfNeighbors')], is_const=True) ## nix-vector.h (module 'network'): ns3::Ptr ns3::NixVector::Copy() const [member function] cls.add_method('Copy', @@ -8103,11 +8437,11 @@ def register_Ns3NixVector_methods(root_module, cls): ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Deserialize(uint32_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint32_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint32_t const *', 'buffer'), param('unsigned int', 'size')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::ExtractNeighborIndex(uint32_t numberOfBits) [member function] cls.add_method('ExtractNeighborIndex', 'uint32_t', - [param('uint32_t', 'numberOfBits')]) + [param('unsigned int', 'numberOfBits')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetRemainingBits() [member function] cls.add_method('GetRemainingBits', 'uint32_t', @@ -8120,12 +8454,12 @@ def register_Ns3NixVector_methods(root_module, cls): ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Serialize(uint32_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint32_t *', 'buffer'), param('uint32_t', 'maxSize')], + [param('uint32_t *', 'buffer'), param('unsigned int', 'maxSize')], is_const=True) return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -8147,12 +8481,12 @@ def register_Ns3Node_methods(root_module, cls): ## node.h (module 'network'): ns3::Ptr ns3::Node::GetApplication(uint32_t index) const [member function] cls.add_method('GetApplication', 'ns3::Ptr< ns3::Application >', - [param('uint32_t', 'index')], + [param('unsigned int', 'index')], is_const=True) ## node.h (module 'network'): ns3::Ptr ns3::Node::GetDevice(uint32_t index) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('uint32_t', 'index')], + [param('unsigned int', 'index')], is_const=True) ## node.h (module 'network'): uint32_t ns3::Node::GetId() const [member function] cls.add_method('GetId', @@ -8184,19 +8518,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', - [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('short unsigned int', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -8244,7 +8578,7 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::NormalRandomVariable::GetInteger(uint32_t mean, uint32_t variance, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'mean'), param('uint32_t', 'variance'), param('uint32_t', 'bound')]) + [param('unsigned int', 'mean'), param('unsigned int', 'variance'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::NormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -8260,23 +8594,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8286,7 +8620,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8298,10 +8632,10 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): return def register_Ns3OutputStreamWrapper_methods(root_module, cls): - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy constructor] + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [constructor] cls.add_constructor([param('ns3::OutputStreamWrapper const &', 'arg0')]) - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::_Ios_Openmode filemode) [constructor] - cls.add_constructor([param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode')]) + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::ios_base::openmode filemode) [constructor] + cls.add_constructor([param('std::string', 'filename'), param('std::ios_base::openmode', 'filemode')]) ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::ostream * os) [constructor] cls.add_constructor([param('std::ostream *', 'os')]) ## output-stream-wrapper.h (module 'network'): std::ostream * ns3::OutputStreamWrapper::GetStream() [member function] @@ -8314,7 +8648,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -8322,7 +8656,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor] cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) - ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] + ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] cls.add_method('AddAtEnd', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -8343,7 +8677,7 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function] cls.add_method('AddPaddingAtEnd', 'void', - [param('uint32_t', 'size')]) + [param('unsigned int', 'size')]) ## packet.h (module 'network'): void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function] cls.add_method('AddTrailer', 'void', @@ -8361,17 +8695,17 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function] cls.add_method('CopyData', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], + [param('uint8_t *', 'buffer'), param('unsigned int', 'size')], is_const=True) ## packet.h (module 'network'): void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function] cls.add_method('CopyData', 'void', - [param('std::ostream *', 'os'), param('uint32_t', 'size')], + [param('std::ostream *', 'os'), param('unsigned int', 'size')], is_const=True) ## packet.h (module 'network'): ns3::Ptr ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function] cls.add_method('CreateFragment', 'ns3::Ptr< ns3::Packet >', - [param('uint32_t', 'start'), param('uint32_t', 'length')], + [param('unsigned int', 'start'), param('unsigned int', 'length')], is_const=True) ## packet.h (module 'network'): static void ns3::Packet::EnableChecking() [member function] cls.add_method('EnableChecking', @@ -8458,11 +8792,11 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): void ns3::Packet::RemoveAtEnd(uint32_t size) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('uint32_t', 'size')]) + [param('unsigned int', 'size')]) ## packet.h (module 'network'): void ns3::Packet::RemoveAtStart(uint32_t size) [member function] cls.add_method('RemoveAtStart', 'void', - [param('uint32_t', 'size')]) + [param('unsigned int', 'size')]) ## packet.h (module 'network'): uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function] cls.add_method('RemoveHeader', 'uint32_t', @@ -8482,7 +8816,7 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): uint32_t ns3::Packet::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], + [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], is_const=True) ## packet.h (module 'network'): void ns3::Packet::SetNixVector(ns3::Ptr nixVector) [member function] cls.add_method('SetNixVector', @@ -8496,11 +8830,11 @@ def register_Ns3Packet_methods(root_module, cls): return def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): - ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor] + ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')]) ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) - ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] cls.add_method('FrameUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')]) @@ -8509,7 +8843,7 @@ def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] cls.add_method('PacketUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -8521,7 +8855,7 @@ def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): return def register_Ns3PacketSocket_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket(ns3::PacketSocket const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket(ns3::PacketSocket const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocket const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket() [constructor] cls.add_constructor([]) @@ -8603,22 +8937,22 @@ def register_Ns3PacketSocket_methods(root_module, cls): ## packet-socket.h (module 'network'): ns3::Ptr ns3::PacketSocket::Recv(uint32_t maxSize, uint32_t flags) [member function] cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', - [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], + [param('unsigned int', 'maxSize'), param('unsigned int', 'flags')], is_virtual=True) ## packet-socket.h (module 'network'): ns3::Ptr ns3::PacketSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', - [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')], + [param('unsigned int', 'maxSize'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')], is_virtual=True) ## packet-socket.h (module 'network'): int ns3::PacketSocket::Send(ns3::Ptr p, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags')], is_virtual=True) ## packet-socket.h (module 'network'): int ns3::PacketSocket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] cls.add_method('SendTo', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags'), param('ns3::Address const &', 'toAddress')], is_virtual=True) ## packet-socket.h (module 'network'): bool ns3::PacketSocket::SetAllowBroadcast(bool allowBroadcast) [member function] cls.add_method('SetAllowBroadcast', @@ -8647,7 +8981,7 @@ def register_Ns3PacketSocket_methods(root_module, cls): return def register_Ns3PacketSocketClient_methods(root_module, cls): - ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient(ns3::PacketSocketClient const & arg0) [copy constructor] + ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient(ns3::PacketSocketClient const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketClient const &', 'arg0')]) ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient() [constructor] cls.add_constructor([]) @@ -8683,7 +9017,7 @@ def register_Ns3PacketSocketClient_methods(root_module, cls): return def register_Ns3PacketSocketFactory_methods(root_module, cls): - ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor] + ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')]) ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory() [constructor] cls.add_constructor([]) @@ -8700,7 +9034,7 @@ def register_Ns3PacketSocketFactory_methods(root_module, cls): return def register_Ns3PacketSocketServer_methods(root_module, cls): - ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer(ns3::PacketSocketServer const & arg0) [copy constructor] + ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer(ns3::PacketSocketServer const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketServer const &', 'arg0')]) ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer() [constructor] cls.add_constructor([]) @@ -8742,7 +9076,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -8765,7 +9099,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ParetoRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) + [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -8781,7 +9115,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PbbAddressBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock(ns3::PbbAddressBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock(ns3::PbbAddressBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock() [constructor] cls.add_constructor([]) @@ -8790,13 +9124,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressBegin() [member function] cls.add_method('AddressBegin', - 'std::_List_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::AddressIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::AddressBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstAddressIterator ns3::PbbAddressBlock::AddressBegin() const [member function] cls.add_method('AddressBegin', - 'std::_List_const_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::ConstAddressIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::AddressClear() [member function] @@ -8808,32 +9142,32 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressEnd() [member function] cls.add_method('AddressEnd', - 'std::_List_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::AddressIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::AddressEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstAddressIterator ns3::PbbAddressBlock::AddressEnd() const [member function] cls.add_method('AddressEnd', - 'std::_List_const_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::ConstAddressIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressErase(std::_List_iterator position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressErase(ns3::PbbAddressBlock::AddressIterator position) [member function] cls.add_method('AddressErase', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressErase(std::_List_iterator first, std::_List_iterator last) [member function] + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressErase(ns3::PbbAddressBlock::AddressIterator first, ns3::PbbAddressBlock::AddressIterator last) [member function] cls.add_method('AddressErase', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'first'), param('std::_List_iterator< ns3::Address >', 'last')]) + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'first'), param('std::list< ns3::Address > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Address ns3::PbbAddressBlock::AddressFront() const [member function] cls.add_method('AddressFront', 'ns3::Address', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressInsert(std::_List_iterator position, ns3::Address const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressInsert(ns3::PbbAddressBlock::AddressIterator position, ns3::Address const value) [member function] cls.add_method('AddressInsert', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'position'), param('ns3::Address const', 'value')]) + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'position'), param('ns3::Address const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::AddressPopBack() [member function] cls.add_method('AddressPopBack', 'void', @@ -8869,13 +9203,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'uint8_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixBegin() [member function] cls.add_method('PrefixBegin', - 'std::_List_iterator< unsigned char >', + 'ns3::PbbAddressBlock::PrefixIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::PrefixBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstPrefixIterator ns3::PbbAddressBlock::PrefixBegin() const [member function] cls.add_method('PrefixBegin', - 'std::_List_const_iterator< unsigned char >', + 'ns3::PbbAddressBlock::ConstPrefixIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixClear() [member function] @@ -8887,32 +9221,32 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixEnd() [member function] cls.add_method('PrefixEnd', - 'std::_List_iterator< unsigned char >', + 'ns3::PbbAddressBlock::PrefixIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::PrefixEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstPrefixIterator ns3::PbbAddressBlock::PrefixEnd() const [member function] cls.add_method('PrefixEnd', - 'std::_List_const_iterator< unsigned char >', + 'ns3::PbbAddressBlock::ConstPrefixIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixErase(std::_List_iterator position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixErase(ns3::PbbAddressBlock::PrefixIterator position) [member function] cls.add_method('PrefixErase', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixErase(std::_List_iterator first, std::_List_iterator last) [member function] + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixErase(ns3::PbbAddressBlock::PrefixIterator first, ns3::PbbAddressBlock::PrefixIterator last) [member function] cls.add_method('PrefixErase', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'first'), param('std::_List_iterator< unsigned char >', 'last')]) + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'first'), param('std::list< unsigned char > iterator', 'last')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbAddressBlock::PrefixFront() const [member function] cls.add_method('PrefixFront', 'uint8_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixInsert(std::_List_iterator position, uint8_t const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixInsert(ns3::PbbAddressBlock::PrefixIterator position, uint8_t const value) [member function] cls.add_method('PrefixInsert', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'position'), param('uint8_t const', 'value')]) + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'position'), param('uint8_t const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPopBack() [member function] cls.add_method('PrefixPopBack', 'void', @@ -8924,11 +9258,11 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPushBack(uint8_t prefix) [member function] cls.add_method('PrefixPushBack', 'void', - [param('uint8_t', 'prefix')]) + [param('unsigned char', 'prefix')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPushFront(uint8_t prefix) [member function] cls.add_method('PrefixPushFront', 'void', - [param('uint8_t', 'prefix')]) + [param('unsigned char', 'prefix')]) ## packetbb.h (module 'network'): int ns3::PbbAddressBlock::PrefixSize() const [member function] cls.add_method('PrefixSize', 'int', @@ -8958,13 +9292,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressBlock::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstTlvIterator ns3::PbbAddressBlock::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::TlvClear() [member function] @@ -8976,23 +9310,23 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressBlock::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstTlvIterator ns3::PbbAddressBlock::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::ConstTlvIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvErase(ns3::PbbAddressBlock::TlvIterator position) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvErase(ns3::PbbAddressBlock::TlvIterator first, ns3::PbbAddressBlock::TlvIterator last) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'last')]) + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'first'), param('ns3::PbbAddressTlvBlock::Iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbAddressBlock::TlvFront() [member function] cls.add_method('TlvFront', 'ns3::Ptr< ns3::PbbAddressTlv >', @@ -9002,10 +9336,10 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvInsert(std::_List_iterator > position, ns3::Ptr const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvInsert(ns3::PbbAddressBlock::TlvIterator position, ns3::Ptr const value) [member function] cls.add_method('TlvInsert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'value')]) + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::TlvPopBack() [member function] cls.add_method('TlvPopBack', 'void', @@ -9037,20 +9371,20 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'uint8_t', [], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbAddressBlockIpv4_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4(ns3::PbbAddressBlockIpv4 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4(ns3::PbbAddressBlockIpv4 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlockIpv4 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4() [constructor] cls.add_constructor([]) @@ -9064,20 +9398,20 @@ def register_Ns3PbbAddressBlockIpv4_methods(root_module, cls): 'uint8_t', [], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbAddressBlockIpv6_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6(ns3::PbbAddressBlockIpv6 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6(ns3::PbbAddressBlockIpv6 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlockIpv6 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6() [constructor] cls.add_constructor([]) @@ -9091,22 +9425,22 @@ def register_Ns3PbbAddressBlockIpv6_methods(root_module, cls): 'uint8_t', [], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbMessage_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage(ns3::PbbMessage const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage(ns3::PbbMessage const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessage const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage() [constructor] cls.add_constructor([]) @@ -9119,13 +9453,13 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressBlock > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockBegin() [member function] cls.add_method('AddressBlockBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::AddressBlockIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::AddressBlockBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstAddressBlockIterator ns3::PbbMessage::AddressBlockBegin() const [member function] cls.add_method('AddressBlockBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::ConstAddressBlockIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbMessage::AddressBlockClear() [member function] @@ -9137,23 +9471,23 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockEnd() [member function] cls.add_method('AddressBlockEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::AddressBlockIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::AddressBlockEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstAddressBlockIterator ns3::PbbMessage::AddressBlockEnd() const [member function] cls.add_method('AddressBlockEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::ConstAddressBlockIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockErase(ns3::PbbMessage::AddressBlockIterator position) [member function] cls.add_method('AddressBlockErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbMessage::AddressBlockIterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockErase(ns3::PbbMessage::AddressBlockIterator first, ns3::PbbMessage::AddressBlockIterator last) [member function] cls.add_method('AddressBlockErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'last')]) + 'ns3::PbbMessage::AddressBlockIterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::AddressBlockFront() [member function] cls.add_method('AddressBlockFront', 'ns3::Ptr< ns3::PbbAddressBlock >', @@ -9261,11 +9595,11 @@ def register_Ns3PbbMessage_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbMessage::SetHopCount(uint8_t hopcount) [member function] cls.add_method('SetHopCount', 'void', - [param('uint8_t', 'hopcount')]) + [param('unsigned char', 'hopcount')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetHopLimit(uint8_t hoplimit) [member function] cls.add_method('SetHopLimit', 'void', - [param('uint8_t', 'hoplimit')]) + [param('unsigned char', 'hoplimit')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetOriginatorAddress(ns3::Address address) [member function] cls.add_method('SetOriginatorAddress', 'void', @@ -9273,11 +9607,11 @@ def register_Ns3PbbMessage_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbMessage::SetSequenceNumber(uint16_t seqnum) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('uint16_t', 'seqnum')]) + [param('short unsigned int', 'seqnum')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetType(uint8_t type) [member function] cls.add_method('SetType', 'void', - [param('uint8_t', 'type')]) + [param('unsigned char', 'type')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::TlvBack() [member function] cls.add_method('TlvBack', 'ns3::Ptr< ns3::PbbTlv >', @@ -9287,13 +9621,13 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstTlvIterator ns3::PbbMessage::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbMessage::TlvClear() [member function] @@ -9305,23 +9639,23 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstTlvIterator ns3::PbbMessage::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::ConstTlvIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvErase(ns3::PbbMessage::TlvIterator position) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbMessage::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvErase(ns3::PbbMessage::TlvIterator first, ns3::PbbMessage::TlvIterator last) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) + 'ns3::PbbMessage::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::TlvFront() [member function] cls.add_method('TlvFront', 'ns3::Ptr< ns3::PbbTlv >', @@ -9380,7 +9714,7 @@ def register_Ns3PbbMessage_methods(root_module, cls): return def register_Ns3PbbMessageIpv4_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4(ns3::PbbMessageIpv4 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4(ns3::PbbMessageIpv4 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessageIpv4 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4() [constructor] cls.add_constructor([]) @@ -9412,7 +9746,7 @@ def register_Ns3PbbMessageIpv4_methods(root_module, cls): return def register_Ns3PbbMessageIpv6_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6(ns3::PbbMessageIpv6 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6(ns3::PbbMessageIpv6 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessageIpv6 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6() [constructor] cls.add_constructor([]) @@ -9446,7 +9780,7 @@ def register_Ns3PbbMessageIpv6_methods(root_module, cls): def register_Ns3PbbPacket_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket(ns3::PbbPacket const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket(ns3::PbbPacket const & arg0) [constructor] cls.add_constructor([param('ns3::PbbPacket const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket() [constructor] cls.add_constructor([]) @@ -9455,22 +9789,22 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::Erase(ns3::PbbPacket::TlvIterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbPacket::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::Erase(ns3::PbbPacket::TlvIterator first, ns3::PbbPacket::TlvIterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > position) [member function] + 'ns3::PbbPacket::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::Erase(ns3::PbbPacket::MessageIterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbPacket::MessageIterator', + [param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::Erase(ns3::PbbPacket::MessageIterator first, ns3::PbbPacket::MessageIterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'last')]) + 'ns3::PbbPacket::MessageIterator', + [param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::TypeId ns3::PbbPacket::GetInstanceTypeId() const [member function] cls.add_method('GetInstanceTypeId', 'ns3::TypeId', @@ -9510,13 +9844,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'ns3::Ptr< ns3::PbbMessage > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::MessageBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::MessageBegin() [member function] cls.add_method('MessageBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::MessageIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::MessageBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstMessageIterator ns3::PbbPacket::MessageBegin() const [member function] cls.add_method('MessageBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::ConstMessageIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbPacket::MessageClear() [member function] @@ -9528,13 +9862,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::MessageEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::MessageEnd() [member function] cls.add_method('MessageEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::MessageIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::MessageEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstMessageIterator ns3::PbbPacket::MessageEnd() const [member function] cls.add_method('MessageEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::ConstMessageIterator', [], is_const=True) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::MessageFront() [member function] @@ -9580,7 +9914,7 @@ def register_Ns3PbbPacket_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbPacket::SetSequenceNumber(uint16_t number) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('uint16_t', 'number')]) + [param('short unsigned int', 'number')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::TlvBack() [member function] cls.add_method('TlvBack', 'ns3::Ptr< ns3::PbbTlv >', @@ -9590,13 +9924,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstTlvIterator ns3::PbbPacket::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbPacket::TlvClear() [member function] @@ -9608,13 +9942,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstTlvIterator ns3::PbbPacket::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::TlvFront() [member function] @@ -9652,7 +9986,7 @@ def register_Ns3PbbPacket_methods(root_module, cls): def register_Ns3PbbTlv_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv(ns3::PbbTlv const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv(ns3::PbbTlv const & arg0) [constructor] cls.add_constructor([param('ns3::PbbTlv const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv() [constructor] cls.add_constructor([]) @@ -9708,11 +10042,11 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetType(uint8_t type) [member function] cls.add_method('SetType', 'void', - [param('uint8_t', 'type')]) + [param('unsigned char', 'type')]) ## packetbb.h (module 'network'): void ns3::PbbTlv::SetTypeExt(uint8_t type) [member function] cls.add_method('SetTypeExt', 'void', - [param('uint8_t', 'type')]) + [param('unsigned char', 'type')]) ## packetbb.h (module 'network'): void ns3::PbbTlv::SetValue(ns3::Buffer start) [member function] cls.add_method('SetValue', 'void', @@ -9720,7 +10054,7 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetValue(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('SetValue', 'void', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbTlv::GetIndexStart() const [member function] cls.add_method('GetIndexStart', 'uint8_t', @@ -9749,12 +10083,12 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetIndexStart(uint8_t index) [member function] cls.add_method('SetIndexStart', 'void', - [param('uint8_t', 'index')], + [param('unsigned char', 'index')], visibility='protected') ## packetbb.h (module 'network'): void ns3::PbbTlv::SetIndexStop(uint8_t index) [member function] cls.add_method('SetIndexStop', 'void', - [param('uint8_t', 'index')], + [param('unsigned char', 'index')], visibility='protected') ## packetbb.h (module 'network'): void ns3::PbbTlv::SetMultivalue(bool isMultivalue) [member function] cls.add_method('SetMultivalue', @@ -9764,7 +10098,7 @@ def register_Ns3PbbTlv_methods(root_module, cls): return def register_Ns3Probe_methods(root_module, cls): - ## probe.h (module 'stats'): ns3::Probe::Probe(ns3::Probe const & arg0) [copy constructor] + ## probe.h (module 'stats'): ns3::Probe::Probe(ns3::Probe const & arg0) [constructor] cls.add_constructor([param('ns3::Probe const &', 'arg0')]) ## probe.h (module 'stats'): ns3::Probe::Probe() [constructor] cls.add_constructor([]) @@ -9791,155 +10125,155 @@ def register_Ns3Probe_methods(root_module, cls): return def register_Ns3Queue__Ns3Packet_methods(root_module, cls): - ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Queue< ns3::Packet > const &', 'arg0')]) + ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) ## queue.h (module 'network'): ns3::Queue::Queue() [constructor] cls.add_constructor([]) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] - cls.add_method('Dequeue', - 'ns3::Ptr< ns3::Packet >', - [], - is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): bool ns3::Queue::Enqueue(ns3::Ptr item) [member function] cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'item')], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] - cls.add_method('Flush', - 'void', - []) - ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', - [], - is_static=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] - cls.add_method('Peek', - 'ns3::Ptr< ns3::Packet const >', + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::Packet >', [], - is_pure_virtual=True, is_const=True, is_virtual=True) + is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] cls.add_method('Remove', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(std::_List_const_iterator > pos) [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] + cls.add_method('Peek', + 'ns3::Ptr< ns3::Packet const >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] + cls.add_method('Flush', + 'void', + []) + ## net-device-queue-interface.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + cls.add_constructor([param('ns3::Queue< ns3::Packet > const &', 'arg0')]) + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] + cls.add_method('Head', + 'ns3::Queue< ns3::Packet > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Tail() const [member function] + cls.add_method('Tail', + 'ns3::Queue< ns3::Packet > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(ns3::Queue::ConstIterator pos, ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos'), param('ns3::Ptr< ns3::Packet >', 'item')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(ns3::Queue::ConstIterator pos) [member function] cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(std::_List_const_iterator > pos, ns3::Ptr item) [member function] - cls.add_method('DoEnqueue', - 'bool', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos'), param('ns3::Ptr< ns3::Packet >', 'item')], + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoRemove', + 'ns3::Ptr< ns3::Packet >', + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(std::_List_const_iterator > pos) const [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(ns3::Queue::ConstIterator pos) const [member function] cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet const >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], is_const=True, visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(std::_List_const_iterator > pos) [member function] - cls.add_method('DoRemove', - 'ns3::Ptr< ns3::Packet >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], - visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] - cls.add_method('DropAfterDequeue', + ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] + cls.add_method('DropBeforeEnqueue', 'void', [param('ns3::Ptr< ns3::Packet >', 'item')], visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] - cls.add_method('DropBeforeEnqueue', + ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] + cls.add_method('DropAfterDequeue', 'void', [param('ns3::Ptr< ns3::Packet >', 'item')], visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Head() const [member function] - cls.add_method('Head', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', - [], - is_const=True, visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Tail() const [member function] - cls.add_method('Tail', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', - [], - is_const=True, visibility='protected') return def register_Ns3Queue__Ns3QueueDiscItem_methods(root_module, cls): - ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Queue< ns3::QueueDiscItem > const &', 'arg0')]) + ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) ## queue.h (module 'network'): ns3::Queue::Queue() [constructor] cls.add_constructor([]) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] - cls.add_method('Dequeue', - 'ns3::Ptr< ns3::QueueDiscItem >', - [], - is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): bool ns3::Queue::Enqueue(ns3::Ptr item) [member function] cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] - cls.add_method('Flush', - 'void', - []) - ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::QueueDiscItem >', [], - is_static=True) + is_pure_virtual=True, is_virtual=True) + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] + cls.add_method('Remove', + 'ns3::Ptr< ns3::QueueDiscItem >', + [], + is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] cls.add_method('Peek', 'ns3::Ptr< ns3::QueueDiscItem const >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] - cls.add_method('Remove', - 'ns3::Ptr< ns3::QueueDiscItem >', + ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] + cls.add_method('Flush', + 'void', + []) + ## net-device-queue-interface.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + cls.add_constructor([param('ns3::Queue< ns3::QueueDiscItem > const &', 'arg0')]) + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] + cls.add_method('Head', + 'ns3::Queue< ns3::QueueDiscItem > ConstIterator', [], - is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(std::_List_const_iterator > pos) [member function] + is_const=True, visibility='protected') + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Tail() const [member function] + cls.add_method('Tail', + 'ns3::Queue< ns3::QueueDiscItem > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(ns3::Queue::ConstIterator pos, ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos'), param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(ns3::Queue::ConstIterator pos) [member function] cls.add_method('DoDequeue', 'ns3::Ptr< ns3::QueueDiscItem >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(std::_List_const_iterator > pos, ns3::Ptr item) [member function] - cls.add_method('DoEnqueue', - 'bool', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos'), param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoRemove', + 'ns3::Ptr< ns3::QueueDiscItem >', + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(std::_List_const_iterator > pos) const [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(ns3::Queue::ConstIterator pos) const [member function] cls.add_method('DoPeek', 'ns3::Ptr< ns3::QueueDiscItem const >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], is_const=True, visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(std::_List_const_iterator > pos) [member function] - cls.add_method('DoRemove', - 'ns3::Ptr< ns3::QueueDiscItem >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], - visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] - cls.add_method('DropAfterDequeue', + ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] + cls.add_method('DropBeforeEnqueue', 'void', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] - cls.add_method('DropBeforeEnqueue', + ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] + cls.add_method('DropAfterDequeue', 'void', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Head() const [member function] - cls.add_method('Head', - 'std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', - [], - is_const=True, visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Tail() const [member function] - cls.add_method('Tail', - 'std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', - [], - is_const=True, visibility='protected') return def register_Ns3QueueItem_methods(root_module, cls): @@ -9969,14 +10303,14 @@ def register_Ns3QueueItem_methods(root_module, cls): return def register_Ns3RateErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel() [constructor] cls.add_constructor([]) ## error-model.h (module 'network'): int64_t ns3::RateErrorModel::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('int64_t', 'stream')]) + [param('long int', 'stream')]) ## error-model.h (module 'network'): double ns3::RateErrorModel::GetRate() const [member function] cls.add_method('GetRate', 'double', @@ -10032,7 +10366,7 @@ def register_Ns3RateErrorModel_methods(root_module, cls): return def register_Ns3ReceiveListErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel(ns3::ReceiveListErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel(ns3::ReceiveListErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ReceiveListErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel() [constructor] cls.add_constructor([]) @@ -10063,7 +10397,7 @@ def register_Ns3ReceiveListErrorModel_methods(root_module, cls): return def register_Ns3SimpleChannel_methods(root_module, cls): - ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor] + ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleChannel const &', 'arg0')]) ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel() [constructor] cls.add_constructor([]) @@ -10080,7 +10414,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): ## simple-channel.h (module 'network'): ns3::Ptr ns3::SimpleChannel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True, is_virtual=True) ## simple-channel.h (module 'network'): uint32_t ns3::SimpleChannel::GetNDevices() const [member function] cls.add_method('GetNDevices', @@ -10095,7 +10429,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): ## simple-channel.h (module 'network'): void ns3::SimpleChannel::Send(ns3::Ptr p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr sender) [member function] cls.add_method('Send', 'void', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], is_virtual=True) ## simple-channel.h (module 'network'): void ns3::SimpleChannel::UnBlackList(ns3::Ptr from, ns3::Ptr to) [member function] cls.add_method('UnBlackList', @@ -10105,7 +10439,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): return def register_Ns3SimpleNetDevice_methods(root_module, cls): - ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor] + ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')]) ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice() [constructor] cls.add_constructor([]) @@ -10197,16 +10531,16 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::Receive(ns3::Ptr packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function] cls.add_method('Receive', 'void', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')]) + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')]) ## simple-net-device.h (module 'network'): bool ns3::SimpleNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('Send', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], is_virtual=True) ## simple-net-device.h (module 'network'): bool ns3::SimpleNetDevice::SendFrom(ns3::Ptr packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('SendFrom', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], is_virtual=True) ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetAddress(ns3::Address address) [member function] cls.add_method('SetAddress', @@ -10232,7 +10566,7 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) - ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -10241,7 +10575,7 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): cls.add_method('SetQueue', 'void', [param('ns3::Ptr< ns3::Queue< ns3::Packet > >', 'queue')]) - ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -10275,16 +10609,16 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10294,7 +10628,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10308,23 +10642,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10334,7 +10668,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10348,16 +10682,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10367,7 +10701,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10381,23 +10715,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10407,7 +10741,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10419,7 +10753,7 @@ def register_Ns3AddressValue_methods(root_module, cls): return def register_Ns3BinaryErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel(ns3::BinaryErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel(ns3::BinaryErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::BinaryErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel() [constructor] cls.add_constructor([]) @@ -10441,14 +10775,14 @@ def register_Ns3BinaryErrorModel_methods(root_module, cls): return def register_Ns3BurstErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel(ns3::BurstErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel(ns3::BurstErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::BurstErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel() [constructor] cls.add_constructor([]) ## error-model.h (module 'network'): int64_t ns3::BurstErrorModel::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('int64_t', 'stream')]) + [param('long int', 'stream')]) ## error-model.h (module 'network'): double ns3::BurstErrorModel::GetBurstRate() const [member function] cls.add_method('GetBurstRate', 'double', @@ -10483,8 +10817,338 @@ def register_Ns3BurstErrorModel_methods(root_module, cls): visibility='private', is_virtual=True) return +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Unsigned_char_Ns3Ptr__lt__ns3QueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): unsigned char ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'unsigned char', + [param('ns3::Ptr< ns3::QueueItem >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3QueueDiscItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::QueueDiscItem const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::QueueDiscItem const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned int arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned int', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls): - ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator(ns3::CounterCalculator const & arg0) [copy constructor] + ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator(ns3::CounterCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::CounterCalculator< unsigned int > const &', 'arg0')]) ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator() [constructor] cls.add_constructor([]) @@ -10519,7 +11183,7 @@ def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls): return def register_Ns3ErrorChannel_methods(root_module, cls): - ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel(ns3::ErrorChannel const & arg0) [copy constructor] + ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel(ns3::ErrorChannel const & arg0) [constructor] cls.add_constructor([param('ns3::ErrorChannel const &', 'arg0')]) ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel() [constructor] cls.add_constructor([]) @@ -10531,7 +11195,7 @@ def register_Ns3ErrorChannel_methods(root_module, cls): ## error-channel.h (module 'network'): ns3::Ptr ns3::ErrorChannel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('uint32_t', 'i')], + [param('unsigned int', 'i')], is_const=True, is_virtual=True) ## error-channel.h (module 'network'): uint32_t ns3::ErrorChannel::GetNDevices() const [member function] cls.add_method('GetNDevices', @@ -10546,7 +11210,7 @@ def register_Ns3ErrorChannel_methods(root_module, cls): ## error-channel.h (module 'network'): void ns3::ErrorChannel::Send(ns3::Ptr p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr sender) [member function] cls.add_method('Send', 'void', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], is_virtual=True) ## error-channel.h (module 'network'): void ns3::ErrorChannel::SetDuplicateMode(bool mode) [member function] cls.add_method('SetDuplicateMode', @@ -10567,11 +11231,11 @@ def register_Ns3ErrorChannel_methods(root_module, cls): return def register_Ns3PacketCounterCalculator_methods(root_module, cls): - ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [copy constructor] + ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketCounterCalculator const &', 'arg0')]) ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator() [constructor] cls.add_constructor([]) - ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] cls.add_method('FrameUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')]) @@ -10580,7 +11244,7 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] cls.add_method('PacketUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10592,7 +11256,7 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls): return def register_Ns3PacketProbe_methods(root_module, cls): - ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe(ns3::PacketProbe const & arg0) [copy constructor] + ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe(ns3::PacketProbe const & arg0) [constructor] cls.add_constructor([param('ns3::PacketProbe const &', 'arg0')]) ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe() [constructor] cls.add_constructor([]) @@ -10611,11 +11275,11 @@ def register_Ns3PacketProbe_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-probe.h (module 'network'): void ns3::PacketProbe::SetValue(ns3::Ptr packet) [member function] + ## packet-probe.h (module 'network'): void ns3::PacketProbe::SetValue(ns3::Ptr packet) [member function] cls.add_method('SetValue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## packet-probe.h (module 'network'): static void ns3::PacketProbe::SetValueByPath(std::string path, ns3::Ptr packet) [member function] + ## packet-probe.h (module 'network'): static void ns3::PacketProbe::SetValueByPath(std::string path, ns3::Ptr packet) [member function] cls.add_method('SetValueByPath', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')], @@ -10625,7 +11289,7 @@ def register_Ns3PacketProbe_methods(root_module, cls): def register_Ns3PbbAddressTlv_methods(root_module, cls): ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv() [constructor] cls.add_constructor([]) - ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv(ns3::PbbAddressTlv const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv(ns3::PbbAddressTlv const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressTlv const &', 'arg0')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbAddressTlv::GetIndexStart() const [member function] cls.add_method('GetIndexStart', @@ -10655,11 +11319,11 @@ def register_Ns3PbbAddressTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetIndexStart(uint8_t index) [member function] cls.add_method('SetIndexStart', 'void', - [param('uint8_t', 'index')]) + [param('unsigned char', 'index')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetIndexStop(uint8_t index) [member function] cls.add_method('SetIndexStop', 'void', - [param('uint8_t', 'index')]) + [param('unsigned char', 'index')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetMultivalue(bool isMultivalue) [member function] cls.add_method('SetMultivalue', 'void', @@ -10687,7 +11351,7 @@ def register_Ns3QueueDiscItem_methods(root_module, cls): ## queue-item.h (module 'network'): void ns3::QueueDiscItem::SetTxQueueIndex(uint8_t txq) [member function] cls.add_method('SetTxQueueIndex', 'void', - [param('uint8_t', 'txq')]) + [param('unsigned char', 'txq')]) ## queue-item.h (module 'network'): void ns3::QueueDiscItem::AddHeader() [member function] cls.add_method('AddHeader', 'void', @@ -10706,7 +11370,7 @@ def register_Ns3QueueDiscItem_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -10728,7 +11392,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -10750,7 +11414,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -10767,7 +11431,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -10789,7 +11453,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -10812,91 +11476,91 @@ def register_Ns3HashFunctionMurmur3_methods(root_module, cls): def register_functions(root_module): module = root_module - ## crc32.h (module 'network'): extern uint32_t ns3::CRC32Calculate(uint8_t const * data, int length) [free function] + ## crc32.h (module 'network'): uint32_t ns3::CRC32Calculate(uint8_t const * data, int length) [free function] module.add_function('CRC32Calculate', 'uint32_t', [param('uint8_t const *', 'data'), param('int', 'length')]) - ## address.h (module 'network'): extern ns3::Ptr ns3::MakeAddressChecker() [free function] + ## address.h (module 'network'): ns3::Ptr ns3::MakeAddressChecker() [free function] module.add_function('MakeAddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## data-rate.h (module 'network'): extern ns3::Ptr ns3::MakeDataRateChecker() [free function] + ## data-rate.h (module 'network'): ns3::Ptr ns3::MakeDataRateChecker() [free function] module.add_function('MakeDataRateChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv4-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv4AddressChecker() [free function] + ## ipv4-address.h (module 'network'): ns3::Ptr ns3::MakeIpv4AddressChecker() [free function] module.add_function('MakeIpv4AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv4-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv4MaskChecker() [free function] + ## ipv4-address.h (module 'network'): ns3::Ptr ns3::MakeIpv4MaskChecker() [free function] module.add_function('MakeIpv4MaskChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv6-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv6AddressChecker() [free function] + ## ipv6-address.h (module 'network'): ns3::Ptr ns3::MakeIpv6AddressChecker() [free function] module.add_function('MakeIpv6AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv6-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv6PrefixChecker() [free function] + ## ipv6-address.h (module 'network'): ns3::Ptr ns3::MakeIpv6PrefixChecker() [free function] module.add_function('MakeIpv6PrefixChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac16-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac16AddressChecker() [free function] + ## mac16-address.h (module 'network'): ns3::Ptr ns3::MakeMac16AddressChecker() [free function] module.add_function('MakeMac16AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac48-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac48AddressChecker() [free function] + ## mac48-address.h (module 'network'): ns3::Ptr ns3::MakeMac48AddressChecker() [free function] module.add_function('MakeMac48AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac64-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac64AddressChecker() [free function] + ## mac64-address.h (module 'network'): ns3::Ptr ns3::MakeMac64AddressChecker() [free function] module.add_function('MakeMac64AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address &', 'ad'), param('uint32_t', 'len')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv6Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv6Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac16Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac16Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac16Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac64Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac64Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac64Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address const &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv6Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv6Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac16Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac16Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac16Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac64Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac64Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac64Address', 'ad')]) @@ -10921,7 +11585,7 @@ def register_functions_ns3_TracedValueCallback(module, root_module): return def register_functions_ns3_addressUtils(module, root_module): - ## address-utils.h (module 'network'): extern bool ns3::addressUtils::IsMulticast(ns3::Address const & ad) [free function] + ## address-utils.h (module 'network'): bool ns3::addressUtils::IsMulticast(ns3::Address const & ad) [free function] module.add_function('IsMulticast', 'bool', [param('ns3::Address const &', 'ad')]) From d99d3907dfb95ccce17b2d477d7488ddd98d990a Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 12 Jun 2017 17:03:08 +0100 Subject: [PATCH 117/551] core: fix optimized build broken in changeset 12922:d5736db31887 --- src/core/model/log.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/model/log.h b/src/core/model/log.h index cab4a8372c3..62ebbc16649 100644 --- a/src/core/model/log.h +++ b/src/core/model/log.h @@ -243,7 +243,7 @@ void LogComponentDisableAll (enum LogLevel level); * \param [in] name The log component name. */ #define NS_LOG_STATIC_TEMPLATE_DEFINE(name) \ - static LogComponent & g_log = GetLogComponent (name) + static LogComponent & NS_UNUSED_GLOBAL (g_log) = GetLogComponent (name) /** * Use \ref NS_LOG to output a message of level LOG_ERROR. From b4e34135e96e804c468ec7c59ccad5e45f065d2c Mon Sep 17 00:00:00 2001 From: Getachew Redieteab Date: Wed, 14 Jun 2017 22:49:53 +0200 Subject: [PATCH 118/551] wifi: HtCapabilities/VhtCapabilities/HeCapabilities subfield binary coding changes --- src/wifi/model/ht-capabilities.cc | 10 ++++++++-- src/wifi/model/ht-capabilities.h | 6 ++++++ src/wifi/model/regular-wifi-mac.cc | 32 ++++++++++++++++++++++++------ src/wifi/model/vht-capabilities.cc | 5 +++++ 4 files changed, 45 insertions(+), 8 deletions(-) diff --git a/src/wifi/model/ht-capabilities.cc b/src/wifi/model/ht-capabilities.cc index ff983544dfd..1c3fab7e961 100644 --- a/src/wifi/model/ht-capabilities.cc +++ b/src/wifi/model/ht-capabilities.cc @@ -179,7 +179,7 @@ HtCapabilities::SetTxRxMcsSetUnequal (uint8_t txrxmcssetunequal) void HtCapabilities::SetTxMaxNSpatialStreams (uint8_t maxtxspatialstreams) { - m_txMaxNSpatialStreams = maxtxspatialstreams; + m_txMaxNSpatialStreams = maxtxspatialstreams - 1; //0 for 1 SS, 1 for 2 SSs, etc } void @@ -236,6 +236,12 @@ HtCapabilities::GetMaxAmpduLength (void) const return m_maxAmpduLength; } +uint8_t +HtCapabilities::GetMinMpduStartSpace (void) const +{ + return m_minMpduStartSpace; +} + uint8_t* HtCapabilities::GetRxMcsBitmask () { @@ -292,7 +298,7 @@ HtCapabilities::GetTxRxMcsSetUnequal (void) const uint8_t HtCapabilities::GetTxMaxNSpatialStreams (void) const { - return m_txMaxNSpatialStreams; + return m_txMaxNSpatialStreams; //0 for 1 SS, 1 for 2 SSs, etc } uint8_t diff --git a/src/wifi/model/ht-capabilities.h b/src/wifi/model/ht-capabilities.h index ebd7a8f92b7..c4649039dde 100644 --- a/src/wifi/model/ht-capabilities.h +++ b/src/wifi/model/ht-capabilities.h @@ -268,6 +268,12 @@ class HtCapabilities : public WifiInformationElement * \return the maximum AMPDU length */ uint8_t GetMaxAmpduLength (void) const; + /** + * Return the minimum MPDU start space. + * + * \return the minimum MPDU start space + */ + uint8_t GetMinMpduStartSpace (void) const; /** * Return the receive MCS bitmask. diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index c1753d5023d..eb28e62c2e6 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -111,7 +111,7 @@ RegularWifiMac::DoDispose () i->second->Dispose (); i->second = 0; } - + delete m_dcfManager; m_dcfManager = 0; } @@ -154,9 +154,16 @@ RegularWifiMac::GetHtCapabilities (void) const capabilities.SetShortGuardInterval20 (m_phy->GetShortGuardInterval ()); capabilities.SetShortGuardInterval40 (m_phy->GetChannelWidth () >= 40 && m_phy->GetShortGuardInterval ()); capabilities.SetGreenfield (m_phy->GetGreenfield ()); - capabilities.SetMaxAmsduLength (1); //hardcoded for now (TBD) + uint32_t maxAmsduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize)); + capabilities.SetMaxAmsduLength (maxAmsduLength > 3839); //0 if 3839 and 1 if 7935 capabilities.SetLSigProtectionSupport (!m_phy->GetGreenfield ()); - capabilities.SetMaxAmpduLength (3); //hardcoded for now (TBD) + double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + + 1.0) + / std::log (2.0)) + - 13.0), + 0.0); + NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255); + capabilities.SetMaxAmpduLength (std::max (3, static_cast (maxAmpduLengthExponent))); //0 to 3 for HT uint64_t maxSupportedRate = 0; //in bit/s for (uint8_t i = 0; i < m_phy->GetNMcs (); i++) { @@ -198,11 +205,18 @@ RegularWifiMac::GetVhtCapabilities (void) const { capabilities.SetSupportedChannelWidthSet (0); } - capabilities.SetMaxMpduLength (2); //hardcoded for now (TBD) + uint32_t maxMpduLength = std::max (std::max (m_beMaxAmsduSize, m_bkMaxAmsduSize), std::max (m_voMaxAmsduSize, m_viMaxAmsduSize)) + 56; //see section 9.11 of 11ac standard + capabilities.SetMaxMpduLength (uint8_t (maxMpduLength > 3895) + uint8_t (maxMpduLength > 7991)); //0 if 3895, 1 if 7991, 2 for 11454 capabilities.SetRxLdpc (m_phy->GetLdpc ()); capabilities.SetShortGuardIntervalFor80Mhz ((m_phy->GetChannelWidth () == 80) && m_phy->GetShortGuardInterval ()); capabilities.SetShortGuardIntervalFor160Mhz ((m_phy->GetChannelWidth () == 160) && m_phy->GetShortGuardInterval ()); - capabilities.SetMaxAmpduLengthExponent (7); //hardcoded for now (TBD) + double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + + 1.0) + / std::log (2.0)) + - 13.0), + 0.0); + NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255); + capabilities.SetMaxAmpduLengthExponent (std::max (7, static_cast (maxAmpduLengthExponent))); //0 to 7 for VHT uint8_t maxMcs = 0; for (uint8_t i = 0; i < m_phy->GetNMcs (); i++) { @@ -274,7 +288,13 @@ RegularWifiMac::GetHeCapabilities (void) const gi |= 0x02; } capabilities.SetHeLtfAndGiForHePpdus (gi); - capabilities.SetMaxAmpduLengthExponent (7); //hardcoded for now (TBD) + double maxAmpduLengthExponent = std::max (std::ceil ((std::log (std::max (std::max (m_beMaxAmpduSize, m_bkMaxAmpduSize), std::max (m_voMaxAmpduSize, m_viMaxAmpduSize)) + + 1.0) + / std::log (2.0)) + - 13.0), + 0.0); + NS_ASSERT (maxAmpduLengthExponent >= 0 && maxAmpduLengthExponent <= 255); + capabilities.SetMaxAmpduLengthExponent (std::max (7, static_cast (maxAmpduLengthExponent))); //assume 0 to 7 for HE uint8_t maxMcs = 0; for (uint8_t i = 0; i < m_phy->GetNMcs (); i++) { diff --git a/src/wifi/model/vht-capabilities.cc b/src/wifi/model/vht-capabilities.cc index e09edc319e7..0574862a18c 100644 --- a/src/wifi/model/vht-capabilities.cc +++ b/src/wifi/model/vht-capabilities.cc @@ -49,6 +49,11 @@ VhtCapabilities::VhtCapabilities () { m_rxMcsMap.resize (8,0); m_txMcsMap.resize (8,0); + for (uint8_t i = 0; i < 8; i++) //set to 3 by default, i.e. #spatial streams not supported. 0 means supported up to MCS 7, not what we want to imply at this stage. + { + m_rxMcsMap[i] = 3; + m_txMcsMap[i] = 3; + } } WifiInformationElementId From 5bced11831f1873df975ead4a56f05e5332800cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Wed, 14 Jun 2017 22:51:30 +0200 Subject: [PATCH 119/551] update AUTHORS list --- AUTHORS | 1 + 1 file changed, 1 insertion(+) diff --git a/AUTHORS b/AUTHORS index 260b87efdf0..1b840c8f451 100644 --- a/AUTHORS +++ b/AUTHORS @@ -196,4 +196,5 @@ He Wu (mdzz@u.washington.edu) Yoshihiko Yazawa (yoshiyaz@gmail.com) Dizhi Zhou (dizhi.zhou@gmail.com) Gaurav Sathe (gaurav.sathe@tcs.com) +Getachew Redieteab (redieteab.orange@gmail.com) Ali Rostami (a.rostami@rutgers.edu) From 10c7ca459b63c9617956a1484fec08910a08b4cf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Sat, 17 Jun 2017 13:15:25 +0200 Subject: [PATCH 120/551] wifi: use const_iterator whenever possible --- src/wifi/model/ap-wifi-mac.cc | 6 +++--- src/wifi/model/block-ack-manager.cc | 16 ++++++++-------- src/wifi/model/dcf-manager.cc | 6 +++--- src/wifi/model/interference-helper.cc | 10 +++++----- src/wifi/model/interference-helper.h | 4 ++-- src/wifi/model/mac-tx-middle.cc | 8 ++++---- src/wifi/model/regular-wifi-mac.cc | 12 ++++++------ 7 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index e3f467bbe95..1c506aeaf17 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -1061,7 +1061,7 @@ ApWifiMac::Receive (Ptr packet, const WifiMacHeader *hdr) else if (hdr->IsDisassociation ()) { m_stationManager->RecordDisassociated (from); - for (std::list::iterator i = m_staList.begin (); i != m_staList.end (); i++) + for (std::list::const_iterator i = m_staList.begin (); i != m_staList.end (); i++) { if ((*i) == from) { @@ -1069,7 +1069,7 @@ ApWifiMac::Receive (Ptr packet, const WifiMacHeader *hdr) break; } } - for (std::list::iterator j = m_nonErpStations.begin (); j != m_nonErpStations.end (); j++) + for (std::list::const_iterator j = m_nonErpStations.begin (); j != m_nonErpStations.end (); j++) { if ((*j) == from) { @@ -1077,7 +1077,7 @@ ApWifiMac::Receive (Ptr packet, const WifiMacHeader *hdr) break; } } - for (std::list::iterator j = m_nonHtStations.begin (); j != m_nonHtStations.end (); j++) + for (std::list::const_iterator j = m_nonHtStations.begin (); j != m_nonHtStations.end (); j++) { if ((*j) == from) { diff --git a/src/wifi/model/block-ack-manager.cc b/src/wifi/model/block-ack-manager.cc index 111b3adeb01..5193bb0b22e 100644 --- a/src/wifi/model/block-ack-manager.cc +++ b/src/wifi/model/block-ack-manager.cc @@ -138,7 +138,7 @@ BlockAckManager::DestroyAgreement (Mac48Address recipient, uint8_t tid) AgreementsI it = m_agreements.find (std::make_pair (recipient, tid)); if (it != m_agreements.end ()) { - for (std::list::iterator i = m_retryPackets.begin (); i != m_retryPackets.end (); ) + for (std::list::const_iterator i = m_retryPackets.begin (); i != m_retryPackets.end (); ) { if ((*i)->hdr.GetAddr1 () == recipient && (*i)->hdr.GetQosTid () == tid) { @@ -151,7 +151,7 @@ BlockAckManager::DestroyAgreement (Mac48Address recipient, uint8_t tid) } m_agreements.erase (it); //remove scheduled bar - for (std::list::iterator i = m_bars.begin (); i != m_bars.end (); ) + for (std::list::const_iterator i = m_bars.begin (); i != m_bars.end (); ) { if (i->recipient == recipient && i->tid == tid) { @@ -249,7 +249,7 @@ BlockAckManager::GetNextPacket (WifiMacHeader &hdr) if (!m_retryPackets.empty ()) { NS_LOG_DEBUG ("Retry buffer size is " << m_retryPackets.size ()); - std::list::iterator it = m_retryPackets.begin (); + std::list::const_iterator it = m_retryPackets.begin (); while (it != m_retryPackets.end ()) { if ((*it)->hdr.IsQosData ()) @@ -326,7 +326,7 @@ BlockAckManager::PeekNextPacket (WifiMacHeader &hdr) if (!m_retryPackets.empty ()) { NS_LOG_DEBUG ("Retry buffer size is " << m_retryPackets.size ()); - std::list::iterator it = m_retryPackets.begin (); + std::list::const_iterator it = m_retryPackets.begin (); while (it != m_retryPackets.end ()) { if ((*it)->hdr.IsQosData ()) @@ -383,7 +383,7 @@ BlockAckManager::PeekNextPacketByTidAndAddress (WifiMacHeader &hdr, Mac48Address CleanupBuffers (); AgreementsI agreement = m_agreements.find (std::make_pair (recipient, tid)); NS_ASSERT (agreement != m_agreements.end ()); - std::list::iterator it = m_retryPackets.begin (); + std::list::const_iterator it = m_retryPackets.begin (); for (; it != m_retryPackets.end (); it++) { if (!(*it)->hdr.IsQosData ()) @@ -439,7 +439,7 @@ bool BlockAckManager::RemovePacket (uint8_t tid, Mac48Address recipient, uint16_t seqnumber) { - std::list::iterator it = m_retryPackets.begin (); + std::list::const_iterator it = m_retryPackets.begin (); for (; it != m_retryPackets.end (); it++) { if (!(*it)->hdr.IsQosData ()) @@ -877,7 +877,7 @@ void BlockAckManager::RemoveFromRetryQueue (Mac48Address address, uint8_t tid, uint16_t seq) { /* remove retry packet iterator if it's present in retry queue */ - std::list::iterator it = m_retryPackets.begin (); + std::list::const_iterator it = m_retryPackets.begin (); while (it != m_retryPackets.end ()) { if ((*it)->hdr.GetAddr1 () == address @@ -1001,7 +1001,7 @@ BlockAckManager::InsertInRetryQueue (PacketQueueI item) } else { - for (std::list::iterator it = m_retryPackets.begin (); it != m_retryPackets.end (); ) + for (std::list::const_iterator it = m_retryPackets.begin (); it != m_retryPackets.end (); ) { if (((item->hdr.GetSequenceNumber () - (*it)->hdr.GetSequenceNumber () + 4096) % 4096) > 2047) { diff --git a/src/wifi/model/dcf-manager.cc b/src/wifi/model/dcf-manager.cc index 8f1c9284a93..4a55cbaec2f 100644 --- a/src/wifi/model/dcf-manager.cc +++ b/src/wifi/model/dcf-manager.cc @@ -627,7 +627,7 @@ DcfManager::NotifySwitchingStartNow (Time duration) } //Reset backoffs - for (States::iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) { DcfState *state = *i; uint32_t remainingSlots = state->GetBackoffSlots (); @@ -659,7 +659,7 @@ DcfManager::NotifySleepNow (void) } //Reset backoffs - for (States::iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) { DcfState *state = *i; state->NotifySleep (); @@ -671,7 +671,7 @@ DcfManager::NotifyWakeupNow (void) { NS_LOG_FUNCTION (this); m_sleeping = false; - for (States::iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) { DcfState *state = *i; uint32_t remainingSlots = state->GetBackoffSlots (); diff --git a/src/wifi/model/interference-helper.cc b/src/wifi/model/interference-helper.cc index 4f5139780aa..7100c0b9559 100644 --- a/src/wifi/model/interference-helper.cc +++ b/src/wifi/model/interference-helper.cc @@ -222,8 +222,8 @@ InterferenceHelper::AppendEvent (Ptr event) Time now = Simulator::Now (); if (!m_rxing) { - NiChanges::iterator nowIterator = GetPosition (now); - for (NiChanges::iterator i = m_niChanges.begin (); i != nowIterator; i++) + NiChanges::const_iterator nowIterator = GetPosition (now); + for (NiChanges::const_iterator i = m_niChanges.begin (); i != nowIterator; i++) { m_firstPower += i->GetDelta (); } @@ -322,7 +322,7 @@ InterferenceHelper::CalculatePlcpPayloadPer (PtrGetTxVector (); double psr = 1.0; /* Packet Success Rate */ - NiChanges::iterator j = ni->begin (); + NiChanges::const_iterator j = ni->begin (); Time previous = (*j).GetTime (); WifiMode payloadMode = event->GetPayloadMode (); WifiPreamble preamble = txVector.GetPreambleType (); @@ -375,7 +375,7 @@ InterferenceHelper::CalculatePlcpHeaderPer (Ptr NS_LOG_FUNCTION (this); const WifiTxVector txVector = event->GetTxVector (); double psr = 1.0; /* Packet Success Rate */ - NiChanges::iterator j = ni->begin (); + NiChanges::const_iterator j = ni->begin (); Time previous = (*j).GetTime (); WifiPreamble preamble = txVector.GetPreambleType (); WifiMode mcsHeaderMode; @@ -875,7 +875,7 @@ InterferenceHelper::EraseEvents (void) m_firstPower = 0.0; } -InterferenceHelper::NiChanges::iterator +InterferenceHelper::NiChanges::const_iterator InterferenceHelper::GetPosition (Time moment) { return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0, NULL)); diff --git a/src/wifi/model/interference-helper.h b/src/wifi/model/interference-helper.h index 319f0e267ab..8f739d36ffa 100644 --- a/src/wifi/model/interference-helper.h +++ b/src/wifi/model/interference-helper.h @@ -327,8 +327,8 @@ class InterferenceHelper double m_firstPower; ///< first power bool m_rxing; ///< flag whether it is in receiving state - /// Returns an iterator to the first nichange, which is later than moment - NiChanges::iterator GetPosition (Time moment); + /// Returns a const_iterator to the first nichange, which is later than moment + NiChanges::const_iterator GetPosition (Time moment); /** * Add NiChange to the list at the appropriate position. * diff --git a/src/wifi/model/mac-tx-middle.cc b/src/wifi/model/mac-tx-middle.cc index ce032bd90d3..1e177125ddd 100644 --- a/src/wifi/model/mac-tx-middle.cc +++ b/src/wifi/model/mac-tx-middle.cc @@ -38,7 +38,7 @@ MacTxMiddle::MacTxMiddle () MacTxMiddle::~MacTxMiddle () { NS_LOG_FUNCTION (this); - for (std::map::iterator i = m_qosSequences.begin (); i != m_qosSequences.end (); i++) + for (std::map::const_iterator i = m_qosSequences.begin (); i != m_qosSequences.end (); i++) { delete [] i->second; } @@ -54,7 +54,7 @@ MacTxMiddle::GetNextSequenceNumberFor (const WifiMacHeader *hdr) { uint8_t tid = hdr->GetQosTid (); NS_ASSERT (tid < 16); - std::map::iterator it = m_qosSequences.find (hdr->GetAddr1 ()); + std::map::const_iterator it = m_qosSequences.find (hdr->GetAddr1 ()); if (it != m_qosSequences.end ()) { retval = it->second[tid]; @@ -65,7 +65,7 @@ MacTxMiddle::GetNextSequenceNumberFor (const WifiMacHeader *hdr) { retval = 0; std::pair newSeq (hdr->GetAddr1 (), new uint16_t[16]); - std::pair ::iterator,bool> newIns = m_qosSequences.insert (newSeq); + std::pair ::const_iterator,bool> newIns = m_qosSequences.insert (newSeq); NS_ASSERT (newIns.second == true); for (uint8_t i = 0; i < 16; i++) { @@ -93,7 +93,7 @@ MacTxMiddle::PeekNextSequenceNumberFor (const WifiMacHeader *hdr) { uint8_t tid = hdr->GetQosTid (); NS_ASSERT (tid < 16); - std::map::iterator it = m_qosSequences.find (hdr->GetAddr1 ()); + std::map::const_iterator it = m_qosSequences.find (hdr->GetAddr1 ()); if (it != m_qosSequences.end ()) { retval = it->second[tid]; diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index eb28e62c2e6..a38d8cc46e8 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -81,7 +81,7 @@ RegularWifiMac::DoInitialize () NS_LOG_FUNCTION (this); m_dca->Initialize (); - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { i->second->Initialize (); } @@ -128,7 +128,7 @@ RegularWifiMac::SetWifiRemoteStationManager (Ptr stati m_dca->SetWifiRemoteStationManager (stationManager); - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { i->second->SetWifiRemoteStationManager (stationManager); } @@ -457,7 +457,7 @@ void RegularWifiMac::SetTypeOfStation (TypeOfStation type) { NS_LOG_FUNCTION (this << type); - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { i->second->SetTypeOfStation (type); } @@ -1300,7 +1300,7 @@ RegularWifiMac::ConfigureContentionWindow (uint32_t cwMin, uint32_t cwMax) ConfigureDcf (m_dca, cwMin, cwMax, isDsssOnly, AC_BE_NQOS); //Now we configure the EDCA functions - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { ConfigureDcf (i->second, cwMin, cwMax, isDsssOnly, i->first); } @@ -1362,7 +1362,7 @@ void RegularWifiMac::EnableAggregation (void) { NS_LOG_FUNCTION (this); - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { if (i->second->GetMsduAggregator () == 0) { @@ -1382,7 +1382,7 @@ void RegularWifiMac::DisableAggregation (void) { NS_LOG_FUNCTION (this); - for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i) + for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i) { i->second->SetMsduAggregator (0); i->second->SetMpduAggregator (0); From 4c860590a27b60f05e2f78b575e88086aee4eb2f Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sun, 18 Jun 2017 01:07:41 +0200 Subject: [PATCH 121/551] internet: (fixes #2756) Ipv4AddressGenerator underestimates the number of available addresses in a network --- src/internet/model/ipv4-address-generator.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/internet/model/ipv4-address-generator.cc b/src/internet/model/ipv4-address-generator.cc index 67d81a2c118..ab01abec1c5 100644 --- a/src/internet/model/ipv4-address-generator.cc +++ b/src/internet/model/ipv4-address-generator.cc @@ -209,7 +209,7 @@ Ipv4AddressGeneratorImpl::Reset (void) mask |= MOST_SIGNIFICANT_BIT; m_netTable[i].network = 1; m_netTable[i].addr = 1; - m_netTable[i].addrMax = ~mask; + m_netTable[i].addrMax = ~m_netTable[i].mask; m_netTable[i].shift = N_BITS - i; } m_entries.clear (); @@ -250,6 +250,7 @@ Ipv4AddressGeneratorImpl::Init ( uint32_t index = MaskToIndex (mask); m_netTable[index].network = netBits >> m_netTable[index].shift; + NS_ABORT_MSG_UNLESS (addrBits <= m_netTable[index].addrMax, "Ipv4AddressGeneratorImpl::Init(): Address overflow"); m_netTable[index].addr = addrBits; return; From cc93ca801ff667eae39c1aaa6aaa9cc250776812 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 21 Jun 2017 11:55:57 +0300 Subject: [PATCH 122/551] lte: Comment fixes: "downlind" -> "downlink" --- src/lte/test/lte-test-cqa-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-pss-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc b/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc index f4107db411b..0b49bc98da7 100644 --- a/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc @@ -386,7 +386,7 @@ LenaCqaFfMacSchedulerTestCase1::DoRun (void) lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ()); } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); @@ -624,7 +624,7 @@ LenaCqaFfMacSchedulerTestCase2::DoRun (void) } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); diff --git a/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc b/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc index dfd7addd083..501b7f14841 100644 --- a/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc @@ -382,7 +382,7 @@ LenaFdTbfqFfMacSchedulerTestCase1::DoRun (void) lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ()); } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); @@ -630,7 +630,7 @@ LenaFdTbfqFfMacSchedulerTestCase2::DoRun (void) } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); diff --git a/src/lte/test/lte-test-pss-ff-mac-scheduler.cc b/src/lte/test/lte-test-pss-ff-mac-scheduler.cc index 270a5fc9fa3..6871384c8b8 100644 --- a/src/lte/test/lte-test-pss-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-pss-ff-mac-scheduler.cc @@ -383,7 +383,7 @@ LenaPssFfMacSchedulerTestCase1::DoRun (void) lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ()); } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); @@ -624,7 +624,7 @@ LenaPssFfMacSchedulerTestCase2::DoRun (void) } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); diff --git a/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc b/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc index 63ea68d35df..bb84dfccb4b 100644 --- a/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc @@ -382,7 +382,7 @@ LenaTdTbfqFfMacSchedulerTestCase1::DoRun (void) lteHelper->ActivateDedicatedEpsBearer (ueDevice, bearer, EpcTft::Default ()); } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); @@ -630,7 +630,7 @@ LenaTdTbfqFfMacSchedulerTestCase2::DoRun (void) } - // Install downlind and uplink applications + // Install downlink and uplink applications uint16_t dlPort = 1234; uint16_t ulPort = 2000; PacketSinkHelper dlPacketSinkHelper ("ns3::UdpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dlPort)); From 8e9c0f6b14c7a4920a49094568831ac35d05c526 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 26 Jun 2017 19:52:31 +0200 Subject: [PATCH 123/551] internet: (fixes #2758) IPv4 sockets bound to unicast receive also subnet-directed broadcasts --- CHANGES.html | 11 ++ RELEASE_NOTES | 1 + src/internet/model/ipv4-end-point-demux.cc | 115 +++++++++++---------- 3 files changed, 75 insertions(+), 52 deletions(-) diff --git a/CHANGES.html b/CHANGES.html index b2e1000d53f..46127524837 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -119,6 +119,17 @@

      Changes to existing API:

      and WifiPhy::MaxSupportedRxSpatialStreams. A new attribute WifiPhy::Antennas was added to allow users to define the number of physical antennas on the device. +
    • Sockets do not receive anymore broadcast packets, unless they are bound to an "Any" address (0.0.0.0) + or to a subnet-directed broadcast packet (e.g., x.y.z.0 for a /24 noterok). + As in Linux, the following rules are now enforced: +
        +
      • A socket bound to 0.0.0.0 will receive everything.
        • +
      • A socket bound to x.y.z.0/24 will receive subnet-directed broadcast (x.y.z.255) and unicast packets.
        • +
      • A socket bound to x.y.z.w will only receive unicast packets.
        • +
      + Previously, a socket bound to an unicast address received also subnet-directed broadcast packets. + This is not anymore possible. +

      • Changes to build system:

        diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 66ff9e7faa2..8a8222b3814 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -105,6 +105,7 @@ Bugs fixed - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes +- Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts Known issues ------------ diff --git a/src/internet/model/ipv4-end-point-demux.cc b/src/internet/model/ipv4-end-point-demux.cc index ef4d1c506d5..aa61197021e 100644 --- a/src/internet/model/ipv4-end-point-demux.cc +++ b/src/internet/model/ipv4-end-point-demux.cc @@ -205,7 +205,7 @@ Ipv4EndPointDemux::Lookup (Ipv4Address daddr, uint16_t dport, EndPoints retval3; // Matches all but local address EndPoints retval4; // Exact match on all 4 - NS_LOG_DEBUG ("Looking up endpoint for destination address " << daddr); + NS_LOG_DEBUG ("Looking up endpoint for destination address " << daddr << ":" << dport); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { Ipv4EndPoint* endP = *i; @@ -241,73 +241,84 @@ Ipv4EndPointDemux::Lookup (Ipv4Address daddr, uint16_t dport, continue; } } - bool subnetDirected = false; - Ipv4Address incomingInterfaceAddr = daddr; // may be a broadcast - for (uint32_t i = 0; i < incomingInterface->GetNAddresses (); i++) + + bool localAddressMatchesExact = false; + bool localAddressIsAny = false; + bool localAddressIsSubnetAny = false; + + // We have 3 cases: + // 1) Exact local / destination address match + // 2) Local endpoint bound to Any -> matches anything + // 3) Local endpoint bound to x.y.z.0 -> matches Subnet-directed broadcast packet (e.g., x.y.z.255 in a /24 net) and direct destination match. + + if (endP->GetLocalAddress () == daddr) { - Ipv4InterfaceAddress addr = incomingInterface->GetAddress (i); - if (addr.GetLocal ().CombineMask (addr.GetMask ()) == daddr.CombineMask (addr.GetMask ()) && - daddr.IsSubnetDirectedBroadcast (addr.GetMask ())) - { - subnetDirected = true; - incomingInterfaceAddr = addr.GetLocal (); - } + // Case 1: + localAddressMatchesExact = true; } - bool isBroadcast = (daddr.IsBroadcast () || subnetDirected == true); - NS_LOG_DEBUG ("dest addr " << daddr << " broadcast? " << isBroadcast); - bool localAddressMatchesWildCard = - endP->GetLocalAddress () == Ipv4Address::GetAny (); - bool localAddressMatchesExact = endP->GetLocalAddress () == daddr; - - if (isBroadcast) + else if (endP->GetLocalAddress () == Ipv4Address::GetAny ()) { - NS_LOG_DEBUG ("Found bcast, localaddr " << endP->GetLocalAddress ()); + // Case 2: + localAddressIsAny = true; } - - if (isBroadcast && (endP->GetLocalAddress () != Ipv4Address::GetAny ())) + else { - localAddressMatchesExact = (endP->GetLocalAddress () == - incomingInterfaceAddr); + // Case 3: + for (uint32_t i = 0; i < incomingInterface->GetNAddresses (); i++) + { + Ipv4InterfaceAddress addr = incomingInterface->GetAddress (i); + + Ipv4Address addrNetpart = addr.GetLocal ().CombineMask (addr.GetMask ()); + if (endP->GetLocalAddress () == addrNetpart) + { + NS_LOG_LOGIC ("Endpoint is SubnetDirectedAny " << endP->GetLocalAddress () << "/" << addr.GetMask ().GetPrefixLength ()); + + Ipv4Address daddrNetPart = daddr.CombineMask (addr.GetMask ()); + if (addrNetpart == daddrNetPart) + { + localAddressIsSubnetAny = true; + } + } + } + + // if no match here, keep looking + if (!localAddressIsSubnetAny) + continue; } - // if no match here, keep looking - if (!(localAddressMatchesExact || localAddressMatchesWildCard)) - continue; - bool remotePeerMatchesExact = endP->GetPeerPort () == sport; - bool remotePeerMatchesWildCard = endP->GetPeerPort () == 0; + + bool remotePortMatchesExact = endP->GetPeerPort () == sport; + bool remotePortMatchesWildCard = endP->GetPeerPort () == 0; bool remoteAddressMatchesExact = endP->GetPeerAddress () == saddr; - bool remoteAddressMatchesWildCard = endP->GetPeerAddress () == - Ipv4Address::GetAny (); + bool remoteAddressMatchesWildCard = endP->GetPeerAddress () == Ipv4Address::GetAny (); + // If remote does not match either with exact or wildcard, // skip this one - if (!(remotePeerMatchesExact || remotePeerMatchesWildCard)) + if (!(remotePortMatchesExact || remotePortMatchesWildCard)) continue; if (!(remoteAddressMatchesExact || remoteAddressMatchesWildCard)) continue; - // Now figure out which return list to add this one to - if (localAddressMatchesWildCard && - remotePeerMatchesWildCard && - remoteAddressMatchesWildCard) - { // Only local port matches exactly - retval1.push_back (endP); - } - if ((localAddressMatchesExact || (isBroadcast && localAddressMatchesWildCard))&& - remotePeerMatchesWildCard && - remoteAddressMatchesWildCard) - { // Only local port and local address matches exactly - retval2.push_back (endP); + bool localAddressMatchesWildCard = localAddressIsAny || localAddressIsSubnetAny; + + if (localAddressMatchesExact && remoteAddressMatchesExact && remotePortMatchesExact) + { // All 4 match - this is the case of an open TCP connection, for example. + NS_LOG_LOGIC ("Found an endpoint for case 4, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ()); + retval4.push_back (endP); } - if (localAddressMatchesWildCard && - remotePeerMatchesExact && - remoteAddressMatchesExact) - { // All but local address + if (localAddressMatchesWildCard && remoteAddressMatchesExact && remotePortMatchesExact) + { // All but local address - no idea what this case could be. + NS_LOG_LOGIC ("Found an endpoint for case 3, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ()); retval3.push_back (endP); } - if (localAddressMatchesExact && - remotePeerMatchesExact && - remoteAddressMatchesExact) - { // All 4 match - retval4.push_back (endP); + if (localAddressMatchesExact && remoteAddressMatchesWildCard && remotePortMatchesWildCard) + { // Only local port and local address matches exactly - Not yet opened connection + NS_LOG_LOGIC ("Found an endpoint for case 2, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ()); + retval2.push_back (endP); + } + if (localAddressMatchesWildCard && remoteAddressMatchesWildCard && remotePortMatchesWildCard) + { // Only local port matches exactly - Endpoint open to "any" connection + NS_LOG_LOGIC ("Found an endpoint for case 1, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ()); + retval1.push_back (endP); } } From acb364c2999f1a3ed7c3d3319f5e01be5e239ca6 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 26 Jun 2017 19:51:45 +0200 Subject: [PATCH 124/551] internet: (fixes #2759) Packets sent to broadcast address are converted to subnet-directed broadcast --- RELEASE_NOTES | 1 + src/internet/model/udp-socket-impl.cc | 27 +++++---------------------- src/internet/test/udp-test.cc | 19 ++++++++++--------- 3 files changed, 16 insertions(+), 31 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 8a8222b3814..5eae4950690 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -106,6 +106,7 @@ Bugs fixed - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes - Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts +- Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast Known issues ------------ diff --git a/src/internet/model/udp-socket-impl.cc b/src/internet/model/udp-socket-impl.cc index c9c9d294433..ced2901c14b 100644 --- a/src/internet/model/udp-socket-impl.cc +++ b/src/internet/model/udp-socket-impl.cc @@ -572,28 +572,11 @@ UdpSocketImpl::DoSendTo (Ptr p, Ipv4Address dest, uint16_t port, uint8_t if (ipv4->GetNetDevice (i) != m_boundnetdevice) continue; } - Ipv4Mask maski = iaddr.GetMask (); - if (maski == Ipv4Mask::GetOnes ()) - { - // if the network mask is 255.255.255.255, do not convert dest - NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest - << " (mask is " << maski << ")"); - m_udp->Send (p->Copy (), addri, dest, - m_endPoint->GetLocalPort (), port); - NotifyDataSent (p->GetSize ()); - NotifySend (GetTxAvailable ()); - } - else - { - // Convert to subnet-directed broadcast - Ipv4Address bcast = addri.GetSubnetDirectedBroadcast (maski); - NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << bcast - << " (mask is " << maski << ")"); - m_udp->Send (p->Copy (), addri, bcast, - m_endPoint->GetLocalPort (), port); - NotifyDataSent (p->GetSize ()); - NotifySend (GetTxAvailable ()); - } + NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest); + m_udp->Send (p->Copy (), addri, dest, + m_endPoint->GetLocalPort (), port); + NotifyDataSent (p->GetSize ()); + NotifySend (GetTxAvailable ()); } NS_LOG_LOGIC ("Limited broadcast end."); return p->GetSize (); diff --git a/src/internet/test/udp-test.cc b/src/internet/test/udp-test.cc index 70765100a8c..1bec1b0e8a8 100644 --- a/src/internet/test/udp-test.cc +++ b/src/internet/test/udp-test.cc @@ -342,36 +342,37 @@ UdpSocketImplTest::DoRun (void) // Receiver Node ipv4 = rxNode->GetObject (); netdev_idx = ipv4->AddInterface (net1.Get (0)); - ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.1"), Ipv4Mask (0xffff0000U)); + ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.1"), Ipv4Mask ("/24")); ipv4->AddAddress (netdev_idx, ipv4Addr); ipv4->SetUp (netdev_idx); netdev_idx = ipv4->AddInterface (net2.Get (0)); - ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.1"), Ipv4Mask (0xffff0000U)); + ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.1"), Ipv4Mask ("/24")); ipv4->AddAddress (netdev_idx, ipv4Addr); ipv4->SetUp (netdev_idx); // Sender Node ipv4 = txNode->GetObject (); netdev_idx = ipv4->AddInterface (net1.Get (1)); - ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.2"), Ipv4Mask (0xffff0000U)); + ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.2"), Ipv4Mask ("/24")); ipv4->AddAddress (netdev_idx, ipv4Addr); ipv4->SetUp (netdev_idx); netdev_idx = ipv4->AddInterface (net2.Get (1)); - ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.2"), Ipv4Mask (0xffff0000U)); + ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.2"), Ipv4Mask ("/24")); ipv4->AddAddress (netdev_idx, ipv4Addr); ipv4->SetUp (netdev_idx); // Create the UDP sockets Ptr rxSocketFactory = rxNode->GetObject (); + Ptr rxSocket = rxSocketFactory->CreateSocket (); NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.1"), 1234)), 0, "trivial"); rxSocket->SetRecvCallback (MakeCallback (&UdpSocketImplTest::ReceivePkt, this)); Ptr rxSocket2 = rxSocketFactory->CreateSocket (); - rxSocket2->SetRecvCallback (MakeCallback (&UdpSocketImplTest::ReceivePkt2, this)); NS_TEST_EXPECT_MSG_EQ (rxSocket2->Bind (InetSocketAddress (Ipv4Address ("10.0.1.1"), 1234)), 0, "trivial"); + rxSocket2->SetRecvCallback (MakeCallback (&UdpSocketImplTest::ReceivePkt2, this)); Ptr txSocketFactory = txNode->GetObject (); Ptr txSocket = txSocketFactory->CreateSocket (); @@ -382,7 +383,7 @@ UdpSocketImplTest::DoRun (void) // Unicast test SendDataTo (txSocket, "10.0.0.1"); NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "trivial"); - NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 0, "second interface should receive it"); + NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 0, "second interface should not receive it"); m_receivedPacket->RemoveAllByteTags (); m_receivedPacket2->RemoveAllByteTags (); @@ -390,7 +391,7 @@ UdpSocketImplTest::DoRun (void) // Simple broadcast test SendDataTo (txSocket, "255.255.255.255"); - NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "trivial"); + NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address"); NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 0, "second socket should not receive it (it is bound specifically to the second interface's address"); m_receivedPacket->RemoveAllByteTags (); @@ -407,7 +408,7 @@ UdpSocketImplTest::DoRun (void) NS_TEST_EXPECT_MSG_EQ (rxSocket2->Bind (InetSocketAddress (Ipv4Address ("0.0.0.0"), 1234)), 0, "trivial"); SendDataTo (txSocket, "255.255.255.255"); - NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "trivial"); + NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address"); NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 123, "trivial"); m_receivedPacket = 0; @@ -417,7 +418,7 @@ UdpSocketImplTest::DoRun (void) txSocket->BindToNetDevice (net1.Get (1)); SendDataTo (txSocket, "224.0.0.9"); - NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the second interface's address"); + NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address"); NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 123, "recv2: 224.0.0.9"); m_receivedPacket->RemoveAllByteTags (); From 11f470b1ff9d9492bdeee51b576bbf81c2c15100 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 26 Jun 2017 19:53:09 +0200 Subject: [PATCH 125/551] olsr: (fixes #2760) do not use unicast-bound sockets to receive broadcasts --- RELEASE_NOTES | 1 + src/olsr/model/olsr-routing-protocol.cc | 68 +++++++++++++++++++++---- src/olsr/model/olsr-routing-protocol.h | 4 +- 3 files changed, 62 insertions(+), 11 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 5eae4950690..74b8741e623 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -107,6 +107,7 @@ Bugs fixed - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes - Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts - Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast +- Bug 2760 - OLSR uses unicast-bound sockets to receive broadcasts Known issues ------------ diff --git a/src/olsr/model/olsr-routing-protocol.cc b/src/olsr/model/olsr-routing-protocol.cc index 817c417d954..768df682c73 100644 --- a/src/olsr/model/olsr-routing-protocol.cc +++ b/src/olsr/model/olsr-routing-protocol.cc @@ -47,6 +47,7 @@ #include "ns3/enum.h" #include "ns3/trace-source-accessor.h" #include "ns3/ipv4-header.h" +#include "ns3/ipv4-packet-info-tag.h" /********** Useful macros **********/ @@ -240,12 +241,17 @@ void RoutingProtocol::DoDispose () m_hnaRoutingTable = 0; m_routingTableAssociation = 0; - for (std::map< Ptr, Ipv4InterfaceAddress >::iterator iter = m_socketAddresses.begin (); - iter != m_socketAddresses.end (); iter++) + if (m_recvSocket) + { + m_recvSocket->Close (); + } + + for (std::map< Ptr, Ipv4InterfaceAddress >::iterator iter = m_sendSockets.begin (); + iter != m_sendSockets.end (); iter++) { iter->first->Close (); } - m_socketAddresses.clear (); + m_sendSockets.clear (); Ipv4RoutingProtocol::DoDispose (); } @@ -340,7 +346,23 @@ void RoutingProtocol::DoInitialize () continue; } - // Create a socket to listen only on this interface + // Create a socket to listen on all the interfaces + if (m_recvSocket == 0) + { + m_recvSocket = Socket::CreateSocket (GetObject (), + UdpSocketFactory::GetTypeId ()); + m_recvSocket->SetAllowBroadcast (true); + InetSocketAddress inetAddr (Ipv4Address::GetAny (), OLSR_PORT_NUMBER); + m_recvSocket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvOlsr, this)); + if (m_recvSocket->Bind (inetAddr)) + { + NS_FATAL_ERROR ("Failed to bind() OLSR socket"); + } + m_recvSocket->SetRecvPktInfo (true); + m_recvSocket->ShutdownSend (); + } + + // Create a socket to send packets from this specific interfaces Ptr socket = Socket::CreateSocket (GetObject (), UdpSocketFactory::GetTypeId ()); socket->SetAllowBroadcast (true); @@ -351,7 +373,8 @@ void RoutingProtocol::DoInitialize () NS_FATAL_ERROR ("Failed to bind() OLSR socket"); } socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); - m_socketAddresses[socket] = m_ipv4->GetAddress (i, 0); + socket->SetRecvPktInfo (true); + m_sendSockets[socket] = m_ipv4->GetAddress (i, 0); canRunOlsr = true; } @@ -386,9 +409,33 @@ RoutingProtocol::RecvOlsr (Ptr socket) Address sourceAddress; receivedPacket = socket->RecvFrom (sourceAddress); + Ipv4PacketInfoTag interfaceInfo; + if (!receivedPacket->RemovePacketTag (interfaceInfo)) + { + NS_ABORT_MSG ("No incoming interface on OLSR message, aborting."); + } + uint32_t incomingIf = interfaceInfo.GetRecvIf (); + Ptr node = this->GetObject (); + Ptr dev = node->GetDevice (incomingIf); + uint32_t recvInterfaceIndex = m_ipv4->GetInterfaceForDevice (dev); + + if (m_interfaceExclusions.find (recvInterfaceIndex) != m_interfaceExclusions.end ()) + { + return; + } + + InetSocketAddress inetSourceAddr = InetSocketAddress::ConvertFrom (sourceAddress); Ipv4Address senderIfaceAddr = inetSourceAddr.GetIpv4 (); - Ipv4Address receiverIfaceAddr = m_socketAddresses[socket].GetLocal (); + + int32_t interfaceForAddress = m_ipv4->GetInterfaceForAddress (senderIfaceAddr); + if (interfaceForAddress != -1) + { + NS_LOG_LOGIC ("Ignoring a packet sent by myself."); + return; + } + + Ipv4Address receiverIfaceAddr = m_ipv4->GetAddress (recvInterfaceIndex, 0).GetLocal (); NS_ASSERT (receiverIfaceAddr != Ipv4Address ()); NS_LOG_DEBUG ("OLSR node " << m_mainAddress << " received a OLSR packet from " << senderIfaceAddr << " to " << receiverIfaceAddr); @@ -1588,10 +1635,11 @@ RoutingProtocol::SendPacket (Ptr packet, // Send it for (std::map, Ipv4InterfaceAddress>::const_iterator i = - m_socketAddresses.begin (); i != m_socketAddresses.end (); i++) + m_sendSockets.begin (); i != m_sendSockets.end (); i++) { + Ptr pkt = packet->Copy (); Ipv4Address bcast = i->second.GetLocal ().GetSubnetDirectedBroadcast (i->second.GetMask ()); - i->first->SendTo (packet, 0, InetSocketAddress (bcast, OLSR_PORT_NUMBER)); + i->first->SendTo (pkt, 0, InetSocketAddress (bcast, OLSR_PORT_NUMBER)); } } @@ -3082,8 +3130,8 @@ RoutingProtocol::AssignStreams (int64_t stream) bool RoutingProtocol::IsMyOwnAddress (const Ipv4Address & a) const { - for (std::map, Ipv4InterfaceAddress>::const_iterator j = - m_socketAddresses.begin (); j != m_socketAddresses.end (); ++j) + std::map, Ipv4InterfaceAddress>::const_iterator j; + for (j = m_sendSockets.begin (); j != m_sendSockets.end (); ++j) { Ipv4InterfaceAddress iface = j->second; if (a == iface.GetLocal ()) diff --git a/src/olsr/model/olsr-routing-protocol.h b/src/olsr/model/olsr-routing-protocol.h index 92b726447a6..efb64f9b062 100644 --- a/src/olsr/model/olsr-routing-protocol.h +++ b/src/olsr/model/olsr-routing-protocol.h @@ -764,7 +764,9 @@ class RoutingProtocol : public Ipv4RoutingProtocol // One socket per interface, each bound to that interface's address // (reason: for OLSR Link Sensing we need to know on which interface // HELLO messages arrive) - std::map< Ptr, Ipv4InterfaceAddress > m_socketAddresses; //!< Container of sockets and the interfaces they are opened onto. + std::map< Ptr, Ipv4InterfaceAddress > m_sendSockets; //!< Container of sockets and the interfaces they are opened onto. + Ptr m_recvSocket; //!< Receiving socket. + /// Rx packet trace. TracedCallback m_rxPacketTrace; From 349007d5837d767bb8a289bde9ff2b160c3a9d4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 26 Jun 2017 22:38:46 +0200 Subject: [PATCH 126/551] wifi: Move log2 to wifi utils --- src/wifi/model/wifi-utils.cc | 7 +++++++ src/wifi/model/wifi-utils.h | 8 ++++++++ src/wifi/model/yans-error-rate-model.cc | 7 +------ src/wifi/model/yans-error-rate-model.h | 8 -------- 4 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/wifi/model/wifi-utils.cc b/src/wifi/model/wifi-utils.cc index ec86a529496..f17e2b4ad29 100644 --- a/src/wifi/model/wifi-utils.cc +++ b/src/wifi/model/wifi-utils.cc @@ -23,6 +23,13 @@ namespace ns3 { +double +Log2 (double val) +{ + return std::log (val) / std::log (2.0); +} + + double DbToRatio (double dB) { diff --git a/src/wifi/model/wifi-utils.h b/src/wifi/model/wifi-utils.h index 5fe85290127..f6ae881fdca 100644 --- a/src/wifi/model/wifi-utils.h +++ b/src/wifi/model/wifi-utils.h @@ -27,6 +27,14 @@ namespace ns3 { + /** + * Return the logarithm of the given value to base 2. + * + * \param val + * + * \return the logarithm of val to base 2. + */ + double Log2 (double val); /** * Convert from dBm to Watts. * diff --git a/src/wifi/model/yans-error-rate-model.cc b/src/wifi/model/yans-error-rate-model.cc index 28996ab22ac..0eacaf43f1d 100644 --- a/src/wifi/model/yans-error-rate-model.cc +++ b/src/wifi/model/yans-error-rate-model.cc @@ -20,6 +20,7 @@ */ #include "yans-error-rate-model.h" +#include "wifi-utils.h" #include "wifi-phy.h" #include "ns3/log.h" @@ -44,12 +45,6 @@ YansErrorRateModel::YansErrorRateModel () { } -double -YansErrorRateModel::Log2 (double val) const -{ - return std::log (val) / std::log (2.0); -} - double YansErrorRateModel::GetBpskBer (double snr, uint32_t signalSpread, uint64_t phyRate) const { diff --git a/src/wifi/model/yans-error-rate-model.h b/src/wifi/model/yans-error-rate-model.h index 395c22601a8..1bbcbdc43c9 100644 --- a/src/wifi/model/yans-error-rate-model.h +++ b/src/wifi/model/yans-error-rate-model.h @@ -66,14 +66,6 @@ class YansErrorRateModel : public ErrorRateModel private: - /** - * Return the logarithm of the given value to base 2. - * - * \param val - * - * \return the logarithm of val to base 2. - */ - double Log2 (double val) const; /** * Return BER of BPSK with the given parameters. * From 87925fa799ba446bab03f97f690dd4f9d5f0b2fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 26 Jun 2017 22:46:21 +0200 Subject: [PATCH 127/551] wifi: Use const in setters --- src/wifi/model/ap-wifi-mac.cc | 2 +- src/wifi/model/ap-wifi-mac.h | 2 +- src/wifi/model/aparf-wifi-manager.cc | 2 +- src/wifi/model/aparf-wifi-manager.h | 2 +- src/wifi/model/block-ack-manager.cc | 4 ++-- src/wifi/model/block-ack-manager.h | 4 ++-- src/wifi/model/dca-txop.cc | 4 ++-- src/wifi/model/dca-txop.h | 4 ++-- src/wifi/model/edca-txop-n.cc | 6 +++--- src/wifi/model/edca-txop-n.h | 6 +++--- src/wifi/model/ideal-wifi-manager.cc | 2 +- src/wifi/model/ideal-wifi-manager.h | 2 +- src/wifi/model/interference-helper.cc | 2 +- src/wifi/model/interference-helper.h | 2 +- src/wifi/model/mac-low.cc | 6 +++--- src/wifi/model/mac-low.h | 6 +++--- src/wifi/model/minstrel-ht-wifi-manager.cc | 4 ++-- src/wifi/model/minstrel-ht-wifi-manager.h | 4 ++-- src/wifi/model/minstrel-wifi-manager.cc | 4 ++-- src/wifi/model/minstrel-wifi-manager.h | 4 ++-- src/wifi/model/parf-wifi-manager.cc | 2 +- src/wifi/model/parf-wifi-manager.h | 2 +- src/wifi/model/regular-wifi-mac.cc | 4 ++-- src/wifi/model/regular-wifi-mac.h | 4 ++-- src/wifi/model/rraa-wifi-manager.cc | 4 ++-- src/wifi/model/rraa-wifi-manager.h | 4 ++-- src/wifi/model/rrpaa-wifi-manager.cc | 4 ++-- src/wifi/model/rrpaa-wifi-manager.h | 4 ++-- src/wifi/model/spectrum-wifi-phy.cc | 4 ++-- src/wifi/model/spectrum-wifi-phy.h | 4 ++-- src/wifi/model/wifi-net-device.cc | 8 ++++---- src/wifi/model/wifi-net-device.h | 8 ++++---- src/wifi/model/wifi-phy.cc | 8 ++++---- src/wifi/model/wifi-phy.h | 8 ++++---- src/wifi/model/wifi-radio-energy-model.cc | 4 ++-- src/wifi/model/wifi-radio-energy-model.h | 4 ++-- src/wifi/model/wifi-remote-station-manager.cc | 4 ++-- src/wifi/model/wifi-remote-station-manager.h | 4 ++-- src/wifi/model/wifi-spectrum-phy-interface.cc | 8 ++++---- src/wifi/model/wifi-spectrum-phy-interface.h | 8 ++++---- src/wifi/model/yans-wifi-channel.cc | 4 ++-- src/wifi/model/yans-wifi-channel.h | 4 ++-- src/wifi/model/yans-wifi-phy.cc | 2 +- src/wifi/model/yans-wifi-phy.h | 2 +- 44 files changed, 92 insertions(+), 92 deletions(-) diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index 1c506aeaf17..c4ca807fb9e 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -152,7 +152,7 @@ ApWifiMac::GetBeaconInterval (void) const } void -ApWifiMac::SetWifiRemoteStationManager (Ptr stationManager) +ApWifiMac::SetWifiRemoteStationManager (const Ptr stationManager) { NS_LOG_FUNCTION (this << stationManager); m_beaconDca->SetWifiRemoteStationManager (stationManager); diff --git a/src/wifi/model/ap-wifi-mac.h b/src/wifi/model/ap-wifi-mac.h index 081496b0956..7d99e7213ed 100644 --- a/src/wifi/model/ap-wifi-mac.h +++ b/src/wifi/model/ap-wifi-mac.h @@ -56,7 +56,7 @@ class ApWifiMac : public RegularWifiMac /** * \param stationManager the station manager attached to this MAC. */ - void SetWifiRemoteStationManager (Ptr stationManager); + void SetWifiRemoteStationManager (const Ptr stationManager); /** * \param linkUp the callback to invoke when the link becomes up. diff --git a/src/wifi/model/aparf-wifi-manager.cc b/src/wifi/model/aparf-wifi-manager.cc index 9eb92a3f3fa..666726b14af 100644 --- a/src/wifi/model/aparf-wifi-manager.cc +++ b/src/wifi/model/aparf-wifi-manager.cc @@ -125,7 +125,7 @@ AparfWifiManager::~AparfWifiManager () } void -AparfWifiManager::SetupPhy (Ptr phy) +AparfWifiManager::SetupPhy (const Ptr phy) { m_minPower = phy->GetTxPowerStart (); m_maxPower = phy->GetTxPowerEnd (); diff --git a/src/wifi/model/aparf-wifi-manager.h b/src/wifi/model/aparf-wifi-manager.h index 6df2a77f934..39b6326267d 100644 --- a/src/wifi/model/aparf-wifi-manager.h +++ b/src/wifi/model/aparf-wifi-manager.h @@ -54,7 +54,7 @@ class AparfWifiManager : public WifiRemoteStationManager virtual ~AparfWifiManager (); // Inherited from WifiRemoteStationManager - void SetupPhy (Ptr phy); + void SetupPhy (const Ptr phy); void SetHtSupported (bool enable); void SetVhtSupported (bool enable); void SetHeSupported (bool enable); diff --git a/src/wifi/model/block-ack-manager.cc b/src/wifi/model/block-ack-manager.cc index 5193bb0b22e..9744f7a8fb3 100644 --- a/src/wifi/model/block-ack-manager.cc +++ b/src/wifi/model/block-ack-manager.cc @@ -551,7 +551,7 @@ BlockAckManager::SetBlockAckThreshold (uint8_t nPackets) } void -BlockAckManager::SetWifiRemoteStationManager (Ptr manager) +BlockAckManager::SetWifiRemoteStationManager (const Ptr manager) { NS_LOG_FUNCTION (this << manager); m_stationManager = manager; @@ -797,7 +797,7 @@ BlockAckManager::NotifyMpduTransmission (Mac48Address recipient, uint8_t tid, ui } void -BlockAckManager::SetQueue (Ptr queue) +BlockAckManager::SetQueue (const Ptr queue) { NS_LOG_FUNCTION (this << queue); m_queue = queue; diff --git a/src/wifi/model/block-ack-manager.h b/src/wifi/model/block-ack-manager.h index fc0983eeec0..2789951f6a0 100644 --- a/src/wifi/model/block-ack-manager.h +++ b/src/wifi/model/block-ack-manager.h @@ -87,7 +87,7 @@ class BlockAckManager * * \param manager WifiRemoteStationManager associated with this BlockAckManager */ - void SetWifiRemoteStationManager (Ptr manager); + void SetWifiRemoteStationManager (const Ptr manager); /** * \param recipient Address of peer station involved in block ack mechanism. * \param tid Traffic ID. @@ -256,7 +256,7 @@ class BlockAckManager /** * \param queue The WifiMacQueue object. */ - void SetQueue (Ptr queue); + void SetQueue (const Ptr queue); /** * Set the MacTxMiddle * \param txMiddle the MacTxMiddle diff --git a/src/wifi/model/dca-txop.cc b/src/wifi/model/dca-txop.cc index 099190b94f9..c28802e4c30 100644 --- a/src/wifi/model/dca-txop.cc +++ b/src/wifi/model/dca-txop.cc @@ -115,14 +115,14 @@ void DcaTxop::SetTxMiddle (MacTxMiddle *txMiddle) } void -DcaTxop::SetLow (Ptr low) +DcaTxop::SetLow (const Ptr low) { NS_LOG_FUNCTION (this << low); m_low = low; } void -DcaTxop::SetWifiRemoteStationManager (Ptr remoteManager) +DcaTxop::SetWifiRemoteStationManager (const Ptr remoteManager) { NS_LOG_FUNCTION (this << remoteManager); m_stationManager = remoteManager; diff --git a/src/wifi/model/dca-txop.h b/src/wifi/model/dca-txop.h index 63e696304f6..b33bd816c90 100644 --- a/src/wifi/model/dca-txop.h +++ b/src/wifi/model/dca-txop.h @@ -98,7 +98,7 @@ class DcaTxop : public Object * * \param low MacLow. */ - void SetLow (Ptr low); + void SetLow (const Ptr low); /** * Set DcfManager this DcaTxop is associated to. * @@ -110,7 +110,7 @@ class DcaTxop : public Object * * \param remoteManager WifiRemoteStationManager. */ - virtual void SetWifiRemoteStationManager (Ptr remoteManager); + virtual void SetWifiRemoteStationManager (const Ptr remoteManager); /** * Set MacTxMiddle this DcaTxop is associated to. * diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index a16a089e3aa..f5894b2e704 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -128,7 +128,7 @@ EdcaTxopN::CompleteAmpduTransfer (Mac48Address recipient, uint8_t tid) } void -EdcaTxopN::SetWifiRemoteStationManager (Ptr remoteManager) +EdcaTxopN::SetWifiRemoteStationManager (const Ptr remoteManager) { DcaTxop::SetWifiRemoteStationManager (remoteManager); NS_LOG_FUNCTION (this << remoteManager); @@ -1223,14 +1223,14 @@ EdcaTxopN::MapDestAddressForAggregation (const WifiMacHeader &hdr) } void -EdcaTxopN::SetMsduAggregator (Ptr aggr) +EdcaTxopN::SetMsduAggregator (const Ptr aggr) { NS_LOG_FUNCTION (this << aggr); m_msduAggregator = aggr; } void -EdcaTxopN::SetMpduAggregator (Ptr aggr) +EdcaTxopN::SetMpduAggregator (const Ptr aggr) { NS_LOG_FUNCTION (this << aggr); m_mpduAggregator = aggr; diff --git a/src/wifi/model/edca-txop-n.h b/src/wifi/model/edca-txop-n.h index 25e6f6bc98e..d37aa3f5fde 100644 --- a/src/wifi/model/edca-txop-n.h +++ b/src/wifi/model/edca-txop-n.h @@ -94,7 +94,7 @@ class EdcaTxopN : public DcaTxop * * \param remoteManager WifiRemoteStationManager. */ - void SetWifiRemoteStationManager (Ptr remoteManager); + void SetWifiRemoteStationManager (const Ptr remoteManager); /** * Set type of station with the given type. * @@ -276,13 +276,13 @@ class EdcaTxopN : public DcaTxop * * \param aggr pointer to the MSDU aggregator. */ - void SetMsduAggregator (Ptr aggr); + void SetMsduAggregator (const Ptr aggr); /** * Set the aggregator used to construct A-MPDU subframes. * * \param aggr pointer to the MPDU aggregator. */ - void SetMpduAggregator (Ptr aggr); + void SetMpduAggregator (const Ptr aggr); /** * \param packet packet to send. diff --git a/src/wifi/model/ideal-wifi-manager.cc b/src/wifi/model/ideal-wifi-manager.cc index 152a1425a77..c15acda691d 100644 --- a/src/wifi/model/ideal-wifi-manager.cc +++ b/src/wifi/model/ideal-wifi-manager.cc @@ -72,7 +72,7 @@ IdealWifiManager::~IdealWifiManager () } void -IdealWifiManager::SetupPhy (Ptr phy) +IdealWifiManager::SetupPhy (const Ptr phy) { NS_LOG_FUNCTION (this << phy); WifiRemoteStationManager::SetupPhy (phy); diff --git a/src/wifi/model/ideal-wifi-manager.h b/src/wifi/model/ideal-wifi-manager.h index 12a2d28d6ba..51f388a947f 100644 --- a/src/wifi/model/ideal-wifi-manager.h +++ b/src/wifi/model/ideal-wifi-manager.h @@ -52,7 +52,7 @@ class IdealWifiManager : public WifiRemoteStationManager IdealWifiManager (); virtual ~IdealWifiManager (); - void SetupPhy (Ptr phy); + void SetupPhy (const Ptr phy); private: diff --git a/src/wifi/model/interference-helper.cc b/src/wifi/model/interference-helper.cc index 7100c0b9559..eb4f99c3e65 100644 --- a/src/wifi/model/interference-helper.cc +++ b/src/wifi/model/interference-helper.cc @@ -176,7 +176,7 @@ InterferenceHelper::GetNoiseFigure (void) const } void -InterferenceHelper::SetErrorRateModel (Ptr rate) +InterferenceHelper::SetErrorRateModel (const Ptr rate) { m_errorRateModel = rate; } diff --git a/src/wifi/model/interference-helper.h b/src/wifi/model/interference-helper.h index 8f739d36ffa..bcabe3e9578 100644 --- a/src/wifi/model/interference-helper.h +++ b/src/wifi/model/interference-helper.h @@ -126,7 +126,7 @@ class InterferenceHelper * * \param rate Error rate model */ - void SetErrorRateModel (Ptr rate); + void SetErrorRateModel (const Ptr rate); /** * Return the noise figure. diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 92c7cb84f7e..e70da2e814d 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -304,7 +304,7 @@ MacLow::GetTypeId (void) } void -MacLow::SetupPhyMacLowListener (Ptr phy) +MacLow::SetupPhyMacLowListener (const Ptr phy) { m_phyMacLowListener = new PhyMacLowListener (this); phy->RegisterListener (m_phyMacLowListener); @@ -418,7 +418,7 @@ MacLow::CancelAllEvents (void) } void -MacLow::SetPhy (Ptr phy) +MacLow::SetPhy (const Ptr phy) { m_phy = phy; m_phy->SetReceiveOkCallback (MakeCallback (&MacLow::DeaggregateAmpduAndReceive, this)); @@ -442,7 +442,7 @@ MacLow::ResetPhy (void) } void -MacLow::SetWifiRemoteStationManager (Ptr manager) +MacLow::SetWifiRemoteStationManager (const Ptr manager) { m_stationManager = manager; } diff --git a/src/wifi/model/mac-low.h b/src/wifi/model/mac-low.h index 8989ec032e5..e45722ce7e8 100644 --- a/src/wifi/model/mac-low.h +++ b/src/wifi/model/mac-low.h @@ -266,7 +266,7 @@ class MacLow : public Object * * \param phy WifiPhy associated with this MacLow */ - void SetPhy (Ptr phy); + void SetPhy (const Ptr phy); /** * \return current attached PHY device */ @@ -280,7 +280,7 @@ class MacLow : public Object * * \param manager WifiRemoteStationManager associated with this MacLow */ - void SetWifiRemoteStationManager (Ptr manager); + void SetWifiRemoteStationManager (const Ptr manager); /** * Set MAC address of this MacLow. * @@ -1049,7 +1049,7 @@ class MacLow : public Object * * \param phy the WifiPhy this MacLow is connected to */ - void SetupPhyMacLowListener (Ptr phy); + void SetupPhyMacLowListener (const Ptr phy); /** * Remove current WifiPhy listener for this MacLow. * diff --git a/src/wifi/model/minstrel-ht-wifi-manager.cc b/src/wifi/model/minstrel-ht-wifi-manager.cc index f9c1b7b674f..ed59a79a122 100644 --- a/src/wifi/model/minstrel-ht-wifi-manager.cc +++ b/src/wifi/model/minstrel-ht-wifi-manager.cc @@ -178,7 +178,7 @@ MinstrelHtWifiManager::AssignStreams (int64_t stream) } void -MinstrelHtWifiManager::SetupPhy (Ptr phy) +MinstrelHtWifiManager::SetupPhy (const Ptr phy) { NS_LOG_FUNCTION (this << phy); // Setup phy for legacy manager. @@ -305,7 +305,7 @@ MinstrelHtWifiManager::DoInitialize () } void -MinstrelHtWifiManager::SetupMac (Ptr mac) +MinstrelHtWifiManager::SetupMac (const Ptr mac) { NS_LOG_FUNCTION (this << mac); m_legacyManager->SetupMac (mac); diff --git a/src/wifi/model/minstrel-ht-wifi-manager.h b/src/wifi/model/minstrel-ht-wifi-manager.h index f07eb16dca2..8082df36f6e 100644 --- a/src/wifi/model/minstrel-ht-wifi-manager.h +++ b/src/wifi/model/minstrel-ht-wifi-manager.h @@ -220,8 +220,8 @@ class MinstrelHtWifiManager : public WifiRemoteStationManager int64_t AssignStreams (int64_t stream); // Inherited from WifiRemoteStationManager - void SetupPhy (Ptr phy); - void SetupMac (Ptr mac); + void SetupPhy (const Ptr phy); + void SetupMac (const Ptr mac); void SetHeSupported (bool enable); //HE rates not yet supported /** diff --git a/src/wifi/model/minstrel-wifi-manager.cc b/src/wifi/model/minstrel-wifi-manager.cc index 3fc236bcd8f..38741b089ac 100644 --- a/src/wifi/model/minstrel-wifi-manager.cc +++ b/src/wifi/model/minstrel-wifi-manager.cc @@ -105,7 +105,7 @@ MinstrelWifiManager::~MinstrelWifiManager () } void -MinstrelWifiManager::SetupPhy (Ptr phy) +MinstrelWifiManager::SetupPhy (const Ptr phy) { NS_LOG_FUNCTION (this << phy); uint32_t nModes = phy->GetNModes (); @@ -121,7 +121,7 @@ MinstrelWifiManager::SetupPhy (Ptr phy) } void -MinstrelWifiManager::SetupMac (Ptr mac) +MinstrelWifiManager::SetupMac (const Ptr mac) { NS_LOG_FUNCTION (this << mac); WifiRemoteStationManager::SetupMac (mac); diff --git a/src/wifi/model/minstrel-wifi-manager.h b/src/wifi/model/minstrel-wifi-manager.h index 95c16966635..e72ee4822cd 100644 --- a/src/wifi/model/minstrel-wifi-manager.h +++ b/src/wifi/model/minstrel-wifi-manager.h @@ -163,8 +163,8 @@ class MinstrelWifiManager : public WifiRemoteStationManager virtual ~MinstrelWifiManager (); // Inherited from WifiRemoteStationManager - void SetupPhy (Ptr phy); - void SetupMac (Ptr mac); + void SetupPhy (const Ptr phy); + void SetupMac (const Ptr mac); void SetHtSupported (bool enable); void SetVhtSupported (bool enable); void SetHeSupported (bool enable); diff --git a/src/wifi/model/parf-wifi-manager.cc b/src/wifi/model/parf-wifi-manager.cc index 9987c1222b0..d9e665e5282 100644 --- a/src/wifi/model/parf-wifi-manager.cc +++ b/src/wifi/model/parf-wifi-manager.cc @@ -93,7 +93,7 @@ ParfWifiManager::~ParfWifiManager () } void -ParfWifiManager::SetupPhy (Ptr phy) +ParfWifiManager::SetupPhy (const Ptr phy) { m_minPower = phy->GetTxPowerStart (); m_maxPower = phy->GetTxPowerEnd (); diff --git a/src/wifi/model/parf-wifi-manager.h b/src/wifi/model/parf-wifi-manager.h index 0c56c942005..bd0a83d318c 100644 --- a/src/wifi/model/parf-wifi-manager.h +++ b/src/wifi/model/parf-wifi-manager.h @@ -52,7 +52,7 @@ class ParfWifiManager : public WifiRemoteStationManager virtual ~ParfWifiManager (); // Inherited from WifiRemoteStationManager - void SetupPhy (Ptr phy); + void SetupPhy (const Ptr phy); void SetHtSupported (bool enable); void SetVhtSupported (bool enable); void SetHeSupported (bool enable); diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index a38d8cc46e8..899474d18c2 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -117,7 +117,7 @@ RegularWifiMac::DoDispose () } void -RegularWifiMac::SetWifiRemoteStationManager (Ptr stationManager) +RegularWifiMac::SetWifiRemoteStationManager (const Ptr stationManager) { NS_LOG_FUNCTION (this << stationManager); m_stationManager = stationManager; @@ -494,7 +494,7 @@ RegularWifiMac::GetBKQueue () const } void -RegularWifiMac::SetWifiPhy (Ptr phy) +RegularWifiMac::SetWifiPhy (const Ptr phy) { NS_LOG_FUNCTION (this << phy); m_phy = phy; diff --git a/src/wifi/model/regular-wifi-mac.h b/src/wifi/model/regular-wifi-mac.h index 47368089cf5..9b20dcca7a5 100644 --- a/src/wifi/model/regular-wifi-mac.h +++ b/src/wifi/model/regular-wifi-mac.h @@ -216,7 +216,7 @@ class RegularWifiMac : public WifiMac /** * \param phy the physical layer attached to this MAC. */ - void SetWifiPhy (Ptr phy); + void SetWifiPhy (const Ptr phy); /** * \return the physical layer attached to this MAC. */ @@ -228,7 +228,7 @@ class RegularWifiMac : public WifiMac /** * \param stationManager the station manager attached to this MAC. */ - virtual void SetWifiRemoteStationManager (Ptr stationManager); + virtual void SetWifiRemoteStationManager (const Ptr stationManager); /** * \return the station manager attached to this MAC. */ diff --git a/src/wifi/model/rraa-wifi-manager.cc b/src/wifi/model/rraa-wifi-manager.cc index 35c6ec55549..a481af08de6 100644 --- a/src/wifi/model/rraa-wifi-manager.cc +++ b/src/wifi/model/rraa-wifi-manager.cc @@ -120,7 +120,7 @@ RraaWifiManager::~RraaWifiManager () } void -RraaWifiManager::SetupPhy (Ptr phy) +RraaWifiManager::SetupPhy (const Ptr phy) { NS_LOG_FUNCTION (this); uint32_t nModes = phy->GetNModes (); @@ -140,7 +140,7 @@ RraaWifiManager::SetupPhy (Ptr phy) } void -RraaWifiManager::SetupMac (Ptr mac) +RraaWifiManager::SetupMac (const Ptr mac) { NS_LOG_FUNCTION (this); m_sifs = mac->GetSifs (); diff --git a/src/wifi/model/rraa-wifi-manager.h b/src/wifi/model/rraa-wifi-manager.h index e38d3d2d39f..9518788294f 100644 --- a/src/wifi/model/rraa-wifi-manager.h +++ b/src/wifi/model/rraa-wifi-manager.h @@ -68,8 +68,8 @@ class RraaWifiManager : public WifiRemoteStationManager virtual ~RraaWifiManager (); // Inherited from WifiRemoteStationManager - virtual void SetupPhy (Ptr phy); - virtual void SetupMac (Ptr mac); + virtual void SetupPhy (const Ptr phy); + virtual void SetupMac (const Ptr mac); void SetHtSupported (bool enable); void SetVhtSupported (bool enable); void SetHeSupported (bool enable); diff --git a/src/wifi/model/rrpaa-wifi-manager.cc b/src/wifi/model/rrpaa-wifi-manager.cc index 44d5a272806..d58f86f522a 100644 --- a/src/wifi/model/rrpaa-wifi-manager.cc +++ b/src/wifi/model/rrpaa-wifi-manager.cc @@ -151,7 +151,7 @@ RrpaaWifiManager::AssignStreams (int64_t stream) } void -RrpaaWifiManager::SetupPhy (Ptr phy) +RrpaaWifiManager::SetupPhy (const Ptr phy) { NS_LOG_FUNCTION (this); m_minPower = phy->GetTxPowerStart (); @@ -174,7 +174,7 @@ RrpaaWifiManager::SetupPhy (Ptr phy) } void -RrpaaWifiManager::SetupMac (Ptr mac) +RrpaaWifiManager::SetupMac (const Ptr mac) { NS_LOG_FUNCTION (this); m_sifs = mac->GetSifs (); diff --git a/src/wifi/model/rrpaa-wifi-manager.h b/src/wifi/model/rrpaa-wifi-manager.h index 3f3989ace40..0c411398878 100644 --- a/src/wifi/model/rrpaa-wifi-manager.h +++ b/src/wifi/model/rrpaa-wifi-manager.h @@ -80,8 +80,8 @@ class RrpaaWifiManager : public WifiRemoteStationManager virtual ~RrpaaWifiManager (); // Inherited from WifiRemoteStationManager - virtual void SetupPhy (Ptr phy); - virtual void SetupMac (Ptr mac); + virtual void SetupPhy (const Ptr phy); + virtual void SetupMac (const Ptr mac); virtual void SetHtSupported (bool enable); virtual void SetVhtSupported (bool enable); virtual void SetHeSupported (bool enable); diff --git a/src/wifi/model/spectrum-wifi-phy.cc b/src/wifi/model/spectrum-wifi-phy.cc index f9023bb7ff2..49306a6f3d8 100644 --- a/src/wifi/model/spectrum-wifi-phy.cc +++ b/src/wifi/model/spectrum-wifi-phy.cc @@ -120,7 +120,7 @@ SpectrumWifiPhy::GetChannel (void) const } void -SpectrumWifiPhy::SetChannel (Ptr channel) +SpectrumWifiPhy::SetChannel (const Ptr channel) { m_channel = channel; } @@ -212,7 +212,7 @@ SpectrumWifiPhy::GetRxAntenna (void) const } void -SpectrumWifiPhy::SetAntenna (Ptr a) +SpectrumWifiPhy::SetAntenna (const Ptr a) { NS_LOG_FUNCTION (this << a); m_antenna = a; diff --git a/src/wifi/model/spectrum-wifi-phy.h b/src/wifi/model/spectrum-wifi-phy.h index fc5cda7e130..0e804ebdee8 100644 --- a/src/wifi/model/spectrum-wifi-phy.h +++ b/src/wifi/model/spectrum-wifi-phy.h @@ -63,7 +63,7 @@ class SpectrumWifiPhy : public WifiPhy * * \param channel the SpectrumChannel this SpectrumWifiPhy is to be connected to */ - void SetChannel (Ptr channel); + void SetChannel (const Ptr channel); /** * Add a channel number to the list of operational channels. This method * is used to support scanning for strongest base station. @@ -124,7 +124,7 @@ class SpectrumWifiPhy : public WifiPhy * Note: this method may be split into separate SetTx and SetRx * methods in the future if the modelling need for this arises */ - void SetAntenna (Ptr antenna); + void SetAntenna (const Ptr antenna); /** * Get the antenna model used for reception * diff --git a/src/wifi/model/wifi-net-device.cc b/src/wifi/model/wifi-net-device.cc index 801c1a52543..456010664da 100644 --- a/src/wifi/model/wifi-net-device.cc +++ b/src/wifi/model/wifi-net-device.cc @@ -197,7 +197,7 @@ WifiNetDevice::FlowControlConfig (void) } void -WifiNetDevice::SetMac (Ptr mac) +WifiNetDevice::SetMac (const Ptr mac) { m_mac = mac; CompleteConfig (); @@ -205,14 +205,14 @@ WifiNetDevice::SetMac (Ptr mac) } void -WifiNetDevice::SetPhy (Ptr phy) +WifiNetDevice::SetPhy (const Ptr phy) { m_phy = phy; CompleteConfig (); } void -WifiNetDevice::SetRemoteStationManager (Ptr manager) +WifiNetDevice::SetRemoteStationManager (const Ptr manager) { m_stationManager = manager; CompleteConfig (); @@ -366,7 +366,7 @@ WifiNetDevice::GetNode (void) const } void -WifiNetDevice::SetNode (Ptr node) +WifiNetDevice::SetNode (const Ptr node) { m_node = node; CompleteConfig (); diff --git a/src/wifi/model/wifi-net-device.h b/src/wifi/model/wifi-net-device.h index 8cec969d44b..adfd4f6fe7e 100644 --- a/src/wifi/model/wifi-net-device.h +++ b/src/wifi/model/wifi-net-device.h @@ -61,15 +61,15 @@ class WifiNetDevice : public NetDevice /** * \param mac the mac layer to use. */ - void SetMac (Ptr mac); + void SetMac (const Ptr mac); /** * \param phy the phy layer to use. */ - void SetPhy (Ptr phy); + void SetPhy (const Ptr phy); /** * \param manager the manager to use. */ - void SetRemoteStationManager (Ptr manager); + void SetRemoteStationManager (const Ptr manager); /** * \returns the mac we are currently using. */ @@ -102,7 +102,7 @@ class WifiNetDevice : public NetDevice bool IsBridge (void) const; bool Send (Ptr packet, const Address& dest, uint16_t protocolNumber); Ptr GetNode (void) const; - void SetNode (Ptr node); + void SetNode (const Ptr node); bool NeedsArp (void) const; void SetReceiveCallback (NetDevice::ReceiveCallback cb); Address GetMulticast (Ipv6Address addr) const; diff --git a/src/wifi/model/wifi-phy.cc b/src/wifi/model/wifi-phy.cc index 65acebf6647..1a625d943ed 100644 --- a/src/wifi/model/wifi-phy.cc +++ b/src/wifi/model/wifi-phy.cc @@ -667,7 +667,7 @@ WifiPhy::GetShortPlcpPreambleSupported (void) const } void -WifiPhy::SetDevice (Ptr device) +WifiPhy::SetDevice (const Ptr device) { m_device = device; } @@ -679,7 +679,7 @@ WifiPhy::GetDevice (void) const } void -WifiPhy::SetMobility (Ptr mobility) +WifiPhy::SetMobility (const Ptr mobility) { m_mobility = mobility; } @@ -698,7 +698,7 @@ WifiPhy::GetMobility (void) const } void -WifiPhy::SetErrorRateModel (Ptr rate) +WifiPhy::SetErrorRateModel (const Ptr rate) { m_interference.SetErrorRateModel (rate); m_interference.SetNumberOfReceiveAntennas (GetNumberOfAntennas ()); @@ -711,7 +711,7 @@ WifiPhy::GetErrorRateModel (void) const } void -WifiPhy::SetFrameCaptureModel (Ptr model) +WifiPhy::SetFrameCaptureModel (const Ptr model) { m_frameCaptureModel = model; } diff --git a/src/wifi/model/wifi-phy.h b/src/wifi/model/wifi-phy.h index 3dea8d3edc1..50369ce7bc1 100644 --- a/src/wifi/model/wifi-phy.h +++ b/src/wifi/model/wifi-phy.h @@ -1456,7 +1456,7 @@ class WifiPhy : public Object * * \param device the device this PHY is associated with */ - void SetDevice (Ptr device); + void SetDevice (const Ptr device); /** * Return the device this PHY is associated with * @@ -1473,7 +1473,7 @@ class WifiPhy : public Object * * \param mobility the mobility model this PHY is associated with */ - void SetMobility (Ptr mobility); + void SetMobility (const Ptr mobility); /** * Return the mobility model this PHY is associated with. * This method will return either the mobility model that has been @@ -1600,7 +1600,7 @@ class WifiPhy : public Object * * \param rate the error rate model */ - void SetErrorRateModel (Ptr rate); + void SetErrorRateModel (const Ptr rate); /** * Return the error rate model this PHY is using. * @@ -1613,7 +1613,7 @@ class WifiPhy : public Object * * \param rate the frame capture model */ - void SetFrameCaptureModel (Ptr rate); + void SetFrameCaptureModel (const Ptr rate); /** * Return the frame capture model this PHY is using. * diff --git a/src/wifi/model/wifi-radio-energy-model.cc b/src/wifi/model/wifi-radio-energy-model.cc index 07800c8fb5f..f535f666c73 100644 --- a/src/wifi/model/wifi-radio-energy-model.cc +++ b/src/wifi/model/wifi-radio-energy-model.cc @@ -109,7 +109,7 @@ WifiRadioEnergyModel::~WifiRadioEnergyModel () } void -WifiRadioEnergyModel::SetEnergySource (Ptr source) +WifiRadioEnergyModel::SetEnergySource (const Ptr source) { NS_LOG_FUNCTION (this << source); NS_ASSERT (source != NULL); @@ -239,7 +239,7 @@ WifiRadioEnergyModel::SetEnergyRechargedCallback ( } void -WifiRadioEnergyModel::SetTxCurrentModel (Ptr model) +WifiRadioEnergyModel::SetTxCurrentModel (const Ptr model) { m_txCurrentModel = model; } diff --git a/src/wifi/model/wifi-radio-energy-model.h b/src/wifi/model/wifi-radio-energy-model.h index 249d5b4117f..eee9ba7bf5d 100644 --- a/src/wifi/model/wifi-radio-energy-model.h +++ b/src/wifi/model/wifi-radio-energy-model.h @@ -225,7 +225,7 @@ class WifiRadioEnergyModel : public DeviceEnergyModel * * Implements DeviceEnergyModel::SetEnergySource. */ - void SetEnergySource (Ptr source); + void SetEnergySource (const Ptr source); /** * \returns Total energy consumption of the wifi device. @@ -330,7 +330,7 @@ class WifiRadioEnergyModel : public DeviceEnergyModel /** * \param model the model used to compute the wifi tx current. */ - void SetTxCurrentModel (Ptr model); + void SetTxCurrentModel (const Ptr model); /** * \brief Calls the CalcTxCurrent method of the tx current model to diff --git a/src/wifi/model/wifi-remote-station-manager.cc b/src/wifi/model/wifi-remote-station-manager.cc index d655db5867c..09436fd8258 100644 --- a/src/wifi/model/wifi-remote-station-manager.cc +++ b/src/wifi/model/wifi-remote-station-manager.cc @@ -432,7 +432,7 @@ WifiRemoteStationManager::DoDispose (void) } void -WifiRemoteStationManager::SetupPhy (Ptr phy) +WifiRemoteStationManager::SetupPhy (const Ptr phy) { //We need to track our PHY because it is the object that knows the //full set of transmit rates that are supported. We need to know @@ -449,7 +449,7 @@ WifiRemoteStationManager::SetupPhy (Ptr phy) } void -WifiRemoteStationManager::SetupMac (Ptr mac) +WifiRemoteStationManager::SetupMac (const Ptr mac) { //We need to track our MAC because it is the object that knows the //full set of interframe spaces. diff --git a/src/wifi/model/wifi-remote-station-manager.h b/src/wifi/model/wifi-remote-station-manager.h index 6d526c1d8fc..bd25f7327f0 100644 --- a/src/wifi/model/wifi-remote-station-manager.h +++ b/src/wifi/model/wifi-remote-station-manager.h @@ -108,14 +108,14 @@ class WifiRemoteStationManager : public Object * * \param phy the PHY of this device */ - virtual void SetupPhy (Ptr phy); + virtual void SetupPhy (const Ptr phy); /** * Set up MAC associated with this device since it is the object that * knows the full set of timing parameters (e.g. IFS). * * \param mac the MAC of this device */ - virtual void SetupMac (Ptr mac); + virtual void SetupMac (const Ptr mac); /** * Return the maximum STA short retry count (SSRC). diff --git a/src/wifi/model/wifi-spectrum-phy-interface.cc b/src/wifi/model/wifi-spectrum-phy-interface.cc index e04681503a9..49dc62bc19e 100644 --- a/src/wifi/model/wifi-spectrum-phy-interface.cc +++ b/src/wifi/model/wifi-spectrum-phy-interface.cc @@ -52,7 +52,7 @@ WifiSpectrumPhyInterface::DoDispose (void) m_channel = 0; } -void WifiSpectrumPhyInterface::SetSpectrumWifiPhy (Ptr spectrumWifiPhy) +void WifiSpectrumPhyInterface::SetSpectrumWifiPhy (const Ptr spectrumWifiPhy) { m_spectrumWifiPhy = spectrumWifiPhy; } @@ -70,19 +70,19 @@ WifiSpectrumPhyInterface::GetMobility () } void -WifiSpectrumPhyInterface::SetDevice (Ptr d) +WifiSpectrumPhyInterface::SetDevice (const Ptr d) { m_netDevice = d; } void -WifiSpectrumPhyInterface::SetMobility (Ptr m) +WifiSpectrumPhyInterface::SetMobility (const Ptr m) { m_spectrumWifiPhy->SetMobility (m); } void -WifiSpectrumPhyInterface::SetChannel (Ptr c) +WifiSpectrumPhyInterface::SetChannel (const Ptr c) { NS_LOG_FUNCTION (this << c); m_channel = c; diff --git a/src/wifi/model/wifi-spectrum-phy-interface.h b/src/wifi/model/wifi-spectrum-phy-interface.h index d0289b32dec..c6337cbb4df 100644 --- a/src/wifi/model/wifi-spectrum-phy-interface.h +++ b/src/wifi/model/wifi-spectrum-phy-interface.h @@ -51,14 +51,14 @@ class WifiSpectrumPhyInterface : public SpectrumPhy * Connect SpectrumWifiPhy object * \param phy SpectrumWifiPhy object to be connected to this object */ - void SetSpectrumWifiPhy (Ptr phy); + void SetSpectrumWifiPhy (const Ptr phy); // Inherited from SpectrumPhy Ptr GetDevice () const; - void SetDevice (Ptr d); - void SetMobility (Ptr m); + void SetDevice (const Ptr d); + void SetMobility (const Ptr m); Ptr GetMobility (); - void SetChannel (Ptr c); + void SetChannel (const Ptr c); Ptr GetRxSpectrumModel () const; Ptr GetRxAntenna (); void StartRx (Ptr params); diff --git a/src/wifi/model/yans-wifi-channel.cc b/src/wifi/model/yans-wifi-channel.cc index 26f98001305..c409c3de276 100644 --- a/src/wifi/model/yans-wifi-channel.cc +++ b/src/wifi/model/yans-wifi-channel.cc @@ -63,13 +63,13 @@ YansWifiChannel::~YansWifiChannel () } void -YansWifiChannel::SetPropagationLossModel (Ptr loss) +YansWifiChannel::SetPropagationLossModel (const Ptr loss) { m_loss = loss; } void -YansWifiChannel::SetPropagationDelayModel (Ptr delay) +YansWifiChannel::SetPropagationDelayModel (const Ptr delay) { m_delay = delay; } diff --git a/src/wifi/model/yans-wifi-channel.h b/src/wifi/model/yans-wifi-channel.h index 2e402b3b4b3..19bd07b92ae 100644 --- a/src/wifi/model/yans-wifi-channel.h +++ b/src/wifi/model/yans-wifi-channel.h @@ -65,11 +65,11 @@ class YansWifiChannel : public Channel /** * \param loss the new propagation loss model. */ - void SetPropagationLossModel (Ptr loss); + void SetPropagationLossModel (const Ptr loss); /** * \param delay the new propagation delay model. */ - void SetPropagationDelayModel (Ptr delay); + void SetPropagationDelayModel (const Ptr delay); /** * \param sender the phy object from which the packet is originating. diff --git a/src/wifi/model/yans-wifi-phy.cc b/src/wifi/model/yans-wifi-phy.cc index 7c05893a315..de25ab91fc5 100644 --- a/src/wifi/model/yans-wifi-phy.cc +++ b/src/wifi/model/yans-wifi-phy.cc @@ -66,7 +66,7 @@ YansWifiPhy::GetChannel (void) const } void -YansWifiPhy::SetChannel (Ptr channel) +YansWifiPhy::SetChannel (const Ptr channel) { m_channel = channel; m_channel->Add (this); diff --git a/src/wifi/model/yans-wifi-phy.h b/src/wifi/model/yans-wifi-phy.h index de73ca812bf..6226f0ec4ea 100644 --- a/src/wifi/model/yans-wifi-phy.h +++ b/src/wifi/model/yans-wifi-phy.h @@ -61,7 +61,7 @@ class YansWifiPhy : public WifiPhy * * \param channel the YansWifiChannel this YansWifiPhy is to be connected to */ - void SetChannel (Ptr channel); + void SetChannel (const Ptr channel); /** * \param packet the packet to send From a6574f3ce5f6bf0cad78c8c1a975855b95296678 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 26 Jun 2017 22:47:13 +0200 Subject: [PATCH 128/551] wifi: Make more use of smart pointers instead of normal pointers --- src/wifi/model/ap-wifi-mac.cc | 1 + src/wifi/model/block-ack-manager.cc | 2 +- src/wifi/model/block-ack-manager.h | 6 ++-- src/wifi/model/dca-txop.cc | 10 +++--- src/wifi/model/dca-txop.h | 12 +++---- src/wifi/model/dcf-manager.cc | 42 +++++++++++------------ src/wifi/model/dcf-manager.h | 12 +++---- src/wifi/model/dcf-state.h | 2 +- src/wifi/model/edca-txop-n.cc | 8 ++--- src/wifi/model/edca-txop-n.h | 4 +-- src/wifi/model/mac-rx-middle.h | 3 +- src/wifi/model/mac-tx-middle.h | 3 +- src/wifi/model/qos-blocked-destinations.h | 3 +- src/wifi/model/random-stream.h | 2 +- src/wifi/model/regular-wifi-mac.cc | 11 +++--- src/wifi/model/regular-wifi-mac.h | 6 ++-- src/wifi/model/wifi-mac-queue.cc | 4 +-- src/wifi/model/wifi-mac-queue.h | 4 +-- src/wifi/test/dcf-manager-test.cc | 24 ++++++------- src/wifi/test/wifi-aggregation-test.cc | 12 +++---- 20 files changed, 84 insertions(+), 87 deletions(-) diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index c4ca807fb9e..b0c51faeb75 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -26,6 +26,7 @@ #include "ns3/string.h" #include "ns3/pointer.h" #include "mac-low.h" +#include "mac-tx-middle.h" namespace ns3 { diff --git a/src/wifi/model/block-ack-manager.cc b/src/wifi/model/block-ack-manager.cc index 9744f7a8fb3..f1fa607c1cb 100644 --- a/src/wifi/model/block-ack-manager.cc +++ b/src/wifi/model/block-ack-manager.cc @@ -953,7 +953,7 @@ BlockAckManager::SetUnblockDestinationCallback (Callback txMiddle) { NS_LOG_FUNCTION (this << txMiddle); m_txMiddle = txMiddle; diff --git a/src/wifi/model/block-ack-manager.h b/src/wifi/model/block-ack-manager.h index 2789951f6a0..e07d76e5e9e 100644 --- a/src/wifi/model/block-ack-manager.h +++ b/src/wifi/model/block-ack-manager.h @@ -69,7 +69,7 @@ struct Bar * \brief Manages all block ack agreements for an originator station. * \ingroup wifi */ -class BlockAckManager +class BlockAckManager : public Object { private: /// type conversion operator @@ -261,7 +261,7 @@ class BlockAckManager * Set the MacTxMiddle * \param txMiddle the MacTxMiddle */ - void SetTxMiddle (MacTxMiddle* txMiddle); + void SetTxMiddle (const Ptr txMiddle); /** * \param bAckType Type of block ack @@ -509,7 +509,7 @@ class BlockAckManager uint8_t m_blockAckThreshold; ///< bock ack threshold BlockAckType m_blockAckType; ///< bock ack type Time m_maxDelay; ///< maximum delay - MacTxMiddle* m_txMiddle; ///< the MacTxMiddle + Ptr m_txMiddle; ///< the MacTxMiddle Mac48Address m_address; ///< address Ptr m_queue; ///< queue Callback m_blockAckInactivityTimeout; ///< block ack inactivity timeout callback diff --git a/src/wifi/model/dca-txop.cc b/src/wifi/model/dca-txop.cc index c28802e4c30..84f3ede3f0f 100644 --- a/src/wifi/model/dca-txop.cc +++ b/src/wifi/model/dca-txop.cc @@ -76,9 +76,9 @@ DcaTxop::DcaTxop () m_currentPacket (0) { NS_LOG_FUNCTION (this); - m_dcf = new DcfState (this); + m_dcf = CreateObject (this); m_queue = CreateObject (); - m_rng = new RealRandomStream (); + m_rng = CreateObject (); } DcaTxop::~DcaTxop () @@ -93,22 +93,20 @@ DcaTxop::DoDispose (void) m_queue = 0; m_low = 0; m_stationManager = 0; - delete m_dcf; - delete m_rng; m_dcf = 0; m_rng = 0; m_txMiddle = 0; } void -DcaTxop::SetManager (DcfManager *manager) +DcaTxop::SetManager (const Ptr manager) { NS_LOG_FUNCTION (this << manager); m_manager = manager; m_manager->Add (m_dcf); } -void DcaTxop::SetTxMiddle (MacTxMiddle *txMiddle) +void DcaTxop::SetTxMiddle (const Ptr txMiddle) { NS_LOG_FUNCTION (this); m_txMiddle = txMiddle; diff --git a/src/wifi/model/dca-txop.h b/src/wifi/model/dca-txop.h index b33bd816c90..83dbad0361b 100644 --- a/src/wifi/model/dca-txop.h +++ b/src/wifi/model/dca-txop.h @@ -104,7 +104,7 @@ class DcaTxop : public Object * * \param manager DcfManager. */ - void SetManager (DcfManager *manager); + void SetManager (const Ptr manager); /** * Set WifiRemoteStationsManager this DcaTxop is associated to. * @@ -116,7 +116,7 @@ class DcaTxop : public Object * * \param txMiddle MacTxMiddle. */ - void SetTxMiddle (MacTxMiddle *txMiddle); + void SetTxMiddle (const Ptr txMiddle); /** * \param callback the callback to invoke when a @@ -401,16 +401,16 @@ class DcaTxop : public Object */ void TxDroppedPacket (Ptr item); - DcfState *m_dcf; //!< the DCF state - DcfManager *m_manager; //!< the DCF manager + Ptr m_dcf; //!< the DCF state + Ptr m_manager; //!< the DCF manager TxOk m_txOkCallback; //!< the transmit OK callback TxFailed m_txFailedCallback; //!< the transmit failed callback TxDropped m_txDroppedCallback; //!< the packet dropped callback Ptr m_queue; //!< the wifi MAC queue - MacTxMiddle *m_txMiddle; //!< the MacTxMiddle + Ptr m_txMiddle; //!< the MacTxMiddle Ptr m_low; //!< the MacLow Ptr m_stationManager; //!< the wifi remote station manager - RandomStream *m_rng; //!< the random stream + Ptr m_rng; //!< the random stream Ptr m_currentPacket; //!< the current packet WifiMacHeader m_currentHdr; //!< the current header diff --git a/src/wifi/model/dcf-manager.cc b/src/wifi/model/dcf-manager.cc index 4a55cbaec2f..cabdacfbfce 100644 --- a/src/wifi/model/dcf-manager.cc +++ b/src/wifi/model/dcf-manager.cc @@ -176,7 +176,7 @@ DcfManager::GetEifsNoDifs () const } void -DcfManager::Add (DcfState *dcf) +DcfManager::Add (Ptr dcf) { NS_LOG_FUNCTION (this << dcf); m_states.push_back (dcf); @@ -264,7 +264,7 @@ DcfManager::IsBusy (void) const } bool -DcfManager::IsWithinAifs (DcfState *state) const +DcfManager::IsWithinAifs (Ptr state) const { NS_LOG_FUNCTION (this << state); Time ifsEnd = GetAccessGrantStart () + MicroSeconds (state->GetAifsn () * m_slotTimeUs); @@ -278,7 +278,7 @@ DcfManager::IsWithinAifs (DcfState *state) const } void -DcfManager::RequestAccess (DcfState *state) +DcfManager::RequestAccess (Ptr state) { NS_LOG_FUNCTION (this << state); //Deny access if in sleep mode @@ -330,9 +330,9 @@ DcfManager::DoGrantAccess (void) { NS_LOG_FUNCTION (this); uint32_t k = 0; - for (States::const_iterator i = m_states.begin (); i != m_states.end (); k++) + for (States::iterator i = m_states.begin (); i != m_states.end (); k++) { - DcfState *state = *i; + Ptr state = *i; if (state->IsAccessRequested () && GetBackoffEndFor (state) <= Simulator::Now () ) { @@ -343,10 +343,10 @@ DcfManager::DoGrantAccess (void) NS_LOG_DEBUG ("dcf " << k << " needs access. backoff expired. access granted. slots=" << state->GetBackoffSlots ()); i++; //go to the next item in the list. k++; - std::vector internalCollisionStates; - for (States::const_iterator j = i; j != m_states.end (); j++, k++) + std::vector > internalCollisionStates; + for (States::iterator j = i; j != m_states.end (); j++, k++) { - DcfState *otherState = *j; + Ptr otherState = *j; if (otherState->IsAccessRequested () && GetBackoffEndFor (otherState) <= Simulator::Now ()) { @@ -369,7 +369,7 @@ DcfManager::DoGrantAccess (void) * the result of the calculations. */ state->NotifyAccessGranted (); - for (std::vector::const_iterator k = internalCollisionStates.begin (); + for (std::vector >::iterator k = internalCollisionStates.begin (); k != internalCollisionStates.end (); k++) { (*k)->NotifyInternalCollision (); @@ -429,7 +429,7 @@ DcfManager::GetAccessGrantStart (void) const } Time -DcfManager::GetBackoffStartFor (DcfState *state) +DcfManager::GetBackoffStartFor (Ptr state) { NS_LOG_FUNCTION (this << state); Time mostRecentEvent = MostRecent (state->GetBackoffStart (), @@ -439,7 +439,7 @@ DcfManager::GetBackoffStartFor (DcfState *state) } Time -DcfManager::GetBackoffEndFor (DcfState *state) +DcfManager::GetBackoffEndFor (Ptr state) { NS_LOG_FUNCTION (this << state); NS_LOG_DEBUG ("Backoff start: " << GetBackoffStartFor (state).As (Time::US) << @@ -453,9 +453,9 @@ DcfManager::UpdateBackoff (void) { NS_LOG_FUNCTION (this); uint32_t k = 0; - for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++, k++) + for (States::iterator i = m_states.begin (); i != m_states.end (); i++, k++) { - DcfState *state = *i; + Ptr state = *i; Time backoffStart = GetBackoffStartFor (state); if (backoffStart <= Simulator::Now ()) @@ -495,9 +495,9 @@ DcfManager::DoRestartAccessTimeoutIfNeeded (void) */ bool accessTimeoutNeeded = false; Time expectedBackoffEnd = Simulator::GetMaximumSimulationTime (); - for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::iterator i = m_states.begin (); i != m_states.end (); i++) { - DcfState *state = *i; + Ptr state = *i; if (state->IsAccessRequested ()) { Time tmp = GetBackoffEndFor (state); @@ -627,9 +627,9 @@ DcfManager::NotifySwitchingStartNow (Time duration) } //Reset backoffs - for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::iterator i = m_states.begin (); i != m_states.end (); i++) { - DcfState *state = *i; + Ptr state = *i; uint32_t remainingSlots = state->GetBackoffSlots (); if (remainingSlots > 0) { @@ -659,9 +659,9 @@ DcfManager::NotifySleepNow (void) } //Reset backoffs - for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::iterator i = m_states.begin (); i != m_states.end (); i++) { - DcfState *state = *i; + Ptr state = *i; state->NotifySleep (); } } @@ -671,9 +671,9 @@ DcfManager::NotifyWakeupNow (void) { NS_LOG_FUNCTION (this); m_sleeping = false; - for (States::const_iterator i = m_states.begin (); i != m_states.end (); i++) + for (States::iterator i = m_states.begin (); i != m_states.end (); i++) { - DcfState *state = *i; + Ptr state = *i; uint32_t remainingSlots = state->GetBackoffSlots (); if (remainingSlots > 0) { diff --git a/src/wifi/model/dcf-manager.h b/src/wifi/model/dcf-manager.h index 9a3ec200c6a..bb1a4a66caf 100644 --- a/src/wifi/model/dcf-manager.h +++ b/src/wifi/model/dcf-manager.h @@ -110,7 +110,7 @@ class DcfManager : public Object * has the highest priority, the second DcfState added, has the second * highest priority, etc. */ - void Add (DcfState *dcf); + void Add (Ptr dcf); /** * \param state a DcfState @@ -120,7 +120,7 @@ class DcfManager : public Object * timer and, invoking DcfState::DoNotifyAccessGranted when the access * is granted if it ever gets granted. */ - void RequestAccess (DcfState *state); + void RequestAccess (Ptr state); /** * \param duration expected duration of reception @@ -280,7 +280,7 @@ class DcfManager : public Object * * \return the time when the backoff procedure started */ - Time GetBackoffStartFor (DcfState *state); + Time GetBackoffStartFor (Ptr state); /** * Return the time when the backoff procedure * ended (or will ended) for the given DcfState. @@ -289,7 +289,7 @@ class DcfManager : public Object * * \return the time when the backoff procedure ended (or will ended) */ - Time GetBackoffEndFor (DcfState *state); + Time GetBackoffEndFor (Ptr state); void DoRestartAccessTimeoutIfNeeded (void); @@ -317,12 +317,12 @@ class DcfManager : public Object * \return true if the device is within AIFS, * false otherwise */ - bool IsWithinAifs (DcfState* state) const; + bool IsWithinAifs (Ptr state) const; /** * typedef for a vector of DcfStates */ - typedef std::vector States; + typedef std::vector > States; States m_states; //!< the DCF states Time m_lastAckTimeoutEnd; //!< the last ACK timeout end time diff --git a/src/wifi/model/dcf-state.h b/src/wifi/model/dcf-state.h index 3af95058e67..0adb2cdc84d 100644 --- a/src/wifi/model/dcf-state.h +++ b/src/wifi/model/dcf-state.h @@ -38,7 +38,7 @@ class DcaTxop; * DcfState::SetAifsn and DcfState::SetCwBounds allow the user to * control the relative QoS differentiation. */ -class DcfState +class DcfState : public Object { public: /** diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index f5894b2e704..6c2858adaf1 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -74,8 +74,8 @@ EdcaTxopN::EdcaTxopN () m_currentIsFragmented (false) { NS_LOG_FUNCTION (this); - m_qosBlockedDestinations = new QosBlockedDestinations (); - m_baManager = new BlockAckManager (); + m_qosBlockedDestinations = CreateObject (); + m_baManager = CreateObject (); m_baManager->SetQueue (m_queue); m_baManager->SetBlockAckType (m_blockAckType); m_baManager->SetBlockDestinationCallback (MakeCallback (&QosBlockedDestinations::Block, m_qosBlockedDestinations)); @@ -94,10 +94,8 @@ void EdcaTxopN::DoDispose (void) { NS_LOG_FUNCTION (this); - delete m_qosBlockedDestinations; - delete m_baManager; - m_qosBlockedDestinations = 0; m_baManager = 0; + m_qosBlockedDestinations = 0; m_msduAggregator = 0; m_mpduAggregator = 0; DcaTxop::DoDispose (); diff --git a/src/wifi/model/edca-txop-n.h b/src/wifi/model/edca-txop-n.h index d37aa3f5fde..1408eb9ac78 100644 --- a/src/wifi/model/edca-txop-n.h +++ b/src/wifi/model/edca-txop-n.h @@ -543,8 +543,8 @@ class EdcaTxopN : public DcaTxop Ptr m_msduAggregator; //!< A-MSDU aggregator Ptr m_mpduAggregator; //!< A-MPDU aggregator TypeOfStation m_typeOfStation; //!< the type of station - QosBlockedDestinations *m_qosBlockedDestinations; //!< QOS blocked destinations - BlockAckManager *m_baManager; //!< the Block ACK manager + Ptr m_qosBlockedDestinations; //!< QOS blocked destinations + Ptr m_baManager; //!< the Block ACK manager uint8_t m_blockAckThreshold; //!< the Block ACK threshold BlockAckType m_blockAckType; //!< the Block ACK type Time m_currentPacketTimestamp; //!< the current packet timestamp diff --git a/src/wifi/model/mac-rx-middle.h b/src/wifi/model/mac-rx-middle.h index 2a6392ab7b3..c04095d8a0f 100644 --- a/src/wifi/model/mac-rx-middle.h +++ b/src/wifi/model/mac-rx-middle.h @@ -23,6 +23,7 @@ #include #include "ns3/packet.h" +#include "ns3/object.h" namespace ns3 { @@ -34,7 +35,7 @@ class OriginatorRxStatus; * * This class handles duplicate detection and recomposition of fragments. */ -class MacRxMiddle +class MacRxMiddle : public Object { public: /** diff --git a/src/wifi/model/mac-tx-middle.h b/src/wifi/model/mac-tx-middle.h index fa93e4baa76..bc3469eca17 100644 --- a/src/wifi/model/mac-tx-middle.h +++ b/src/wifi/model/mac-tx-middle.h @@ -25,6 +25,7 @@ #include #include "ns3/mac48-address.h" +#include "ns3/object.h" namespace ns3 { @@ -35,7 +36,7 @@ class WifiMacHeader; * * Handles sequence numbering of IEEE 802.11 data frames */ -class MacTxMiddle +class MacTxMiddle : public Object { public: MacTxMiddle (); diff --git a/src/wifi/model/qos-blocked-destinations.h b/src/wifi/model/qos-blocked-destinations.h index e0756282a89..4960b3671ed 100644 --- a/src/wifi/model/qos-blocked-destinations.h +++ b/src/wifi/model/qos-blocked-destinations.h @@ -24,6 +24,7 @@ #include #include "ns3/mac48-address.h" +#include "ns3/object.h" namespace ns3 { @@ -31,7 +32,7 @@ namespace ns3 { * Keep track of destination address - TID pairs that are waiting * for a block ACK response. */ -class QosBlockedDestinations +class QosBlockedDestinations : public Object { public: QosBlockedDestinations (); diff --git a/src/wifi/model/random-stream.h b/src/wifi/model/random-stream.h index 8e1cfb9c457..0c4c4896ef4 100644 --- a/src/wifi/model/random-stream.h +++ b/src/wifi/model/random-stream.h @@ -29,7 +29,7 @@ namespace ns3 { * A simple wrapper around RngStream to make testing * of the code easier. */ -class RandomStream +class RandomStream : public Object { public: virtual ~RandomStream (); diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index 899474d18c2..7ae5ee06c37 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -42,15 +42,15 @@ RegularWifiMac::RegularWifiMac () m_heSupported (0) { NS_LOG_FUNCTION (this); - m_rxMiddle = new MacRxMiddle (); + m_rxMiddle = CreateObject (); m_rxMiddle->SetForwardCallback (MakeCallback (&RegularWifiMac::Receive, this)); - m_txMiddle = new MacTxMiddle (); + m_txMiddle = CreateObject (); m_low = CreateObject (); m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle)); - m_dcfManager = new DcfManager (); + m_dcfManager = CreateObject (); m_dcfManager->SetupLow (m_low); m_dca = CreateObject (); @@ -91,10 +91,8 @@ void RegularWifiMac::DoDispose () { NS_LOG_FUNCTION (this); - delete m_rxMiddle; - m_rxMiddle = 0; - delete m_txMiddle; + m_rxMiddle = 0; m_txMiddle = 0; m_low->Dispose (); @@ -112,7 +110,6 @@ RegularWifiMac::DoDispose () i->second = 0; } - delete m_dcfManager; m_dcfManager = 0; } diff --git a/src/wifi/model/regular-wifi-mac.h b/src/wifi/model/regular-wifi-mac.h index 9b20dcca7a5..ac467d0722e 100644 --- a/src/wifi/model/regular-wifi-mac.h +++ b/src/wifi/model/regular-wifi-mac.h @@ -288,10 +288,10 @@ class RegularWifiMac : public WifiMac virtual void DoInitialize (); virtual void DoDispose (); - MacRxMiddle *m_rxMiddle; //!< RX middle (de-fragmentation etc.) - MacTxMiddle *m_txMiddle; //!< TX middle (aggregation etc.) + Ptr m_rxMiddle; //!< RX middle (de-fragmentation etc.) + Ptr m_txMiddle; //!< TX middle (aggregation etc.) Ptr m_low; //!< MacLow (RTS, CTS, DATA, ACK etc.) - DcfManager *m_dcfManager; //!< DCF manager (access to channel) + Ptr m_dcfManager; //!< DCF manager (access to channel) Ptr m_phy; //!< Wifi PHY Ptr m_stationManager; //!< Remote station manager (rate control, RTS/CTS/fragmentation thresholds etc.) diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index d0a1a195351..279e4188a42 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -255,7 +255,7 @@ WifiMacQueue::DequeueByTidAndAddress (uint8_t tid, template<> Ptr -WifiMacQueue::DequeueFirstAvailable (const QosBlockedDestinations *blockedPackets) +WifiMacQueue::DequeueFirstAvailable (const Ptr blockedPackets) { NS_LOG_FUNCTION (this); @@ -321,7 +321,7 @@ WifiMacQueue::PeekByTidAndAddress (uint8_t tid, template<> Ptr -WifiMacQueue::PeekFirstAvailable (const QosBlockedDestinations *blockedPackets) +WifiMacQueue::PeekFirstAvailable (const Ptr blockedPackets) { NS_LOG_FUNCTION (this); diff --git a/src/wifi/model/wifi-mac-queue.h b/src/wifi/model/wifi-mac-queue.h index 3d7c7dd1a55..0ba602da042 100644 --- a/src/wifi/model/wifi-mac-queue.h +++ b/src/wifi/model/wifi-mac-queue.h @@ -224,7 +224,7 @@ class WifiQueue : public Queue * * \return packet */ - Ptr DequeueFirstAvailable (const QosBlockedDestinations *blockedPackets); + Ptr DequeueFirstAvailable (const Ptr blockedPackets); /** * Peek the packet in the front of the queue. The packet is not removed. * @@ -254,7 +254,7 @@ class WifiQueue : public Queue * * \return packet */ - Ptr PeekFirstAvailable (const QosBlockedDestinations *blockedPackets); + Ptr PeekFirstAvailable (const Ptr blockedPackets); /** * Remove the packet in the front of the queue. * diff --git a/src/wifi/test/dcf-manager-test.cc b/src/wifi/test/dcf-manager-test.cc index 8f17101cfe7..1a8afe29d06 100644 --- a/src/wifi/test/dcf-manager-test.cc +++ b/src/wifi/test/dcf-manager-test.cc @@ -241,7 +241,7 @@ class DcfManagerTest : public TestCase * \param expectedGrantTime DoAccessRequest expectedGrantTime * \param state DcfStateTest */ - void DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state); + void DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, Ptr state); /** * Add CCA busy event function * \param at the event time @@ -261,7 +261,7 @@ class DcfManagerTest : public TestCase */ void AddRxStartEvt (uint64_t at, uint64_t duration); - typedef std::vector DcfStates; //!< the DCF test states typedef + typedef std::vector > DcfStates; //!< the DCF test states typedef typedef std::vector > Dca; //!< the DCA TXOP tests typedef Ptr m_dcfManager; //!< the DCF manager @@ -336,7 +336,7 @@ DcfManagerTest::DcfManagerTest () void DcfManagerTest::NotifyAccessGranted (uint32_t i) { - DcfStateTest *state = m_dcfStates[i]; + Ptr state = m_dcfStates[i]; NS_TEST_EXPECT_MSG_EQ (state->m_expectedGrants.empty (), false, "Have expected grants"); if (!state->m_expectedGrants.empty ()) { @@ -359,7 +359,7 @@ DcfManagerTest::AddTxEvt (uint64_t at, uint64_t duration) void DcfManagerTest::NotifyInternalCollision (uint32_t i) { - DcfStateTest *state = m_dcfStates[i]; + Ptr state = m_dcfStates[i]; NS_TEST_EXPECT_MSG_EQ (state->m_expectedInternalCollision.empty (), false, "Have expected internal collisions"); if (!state->m_expectedInternalCollision.empty ()) { @@ -373,7 +373,7 @@ DcfManagerTest::NotifyInternalCollision (uint32_t i) void DcfManagerTest::NotifyCollision (uint32_t i) { - DcfStateTest *state = m_dcfStates[i]; + Ptr state = m_dcfStates[i]; NS_TEST_EXPECT_MSG_EQ (state->m_expectedCollision.empty (), false, "Have expected collisions"); if (!state->m_expectedCollision.empty ()) { @@ -387,7 +387,7 @@ DcfManagerTest::NotifyCollision (uint32_t i) void DcfManagerTest::NotifyChannelSwitching (uint32_t i) { - DcfStateTest *state = m_dcfStates[i]; + Ptr state = m_dcfStates[i]; if (!state->m_expectedGrants.empty ()) { std::pair expected = state->m_expectedGrants.front (); @@ -399,7 +399,7 @@ DcfManagerTest::NotifyChannelSwitching (uint32_t i) void DcfManagerTest::ExpectInternalCollision (uint64_t time, uint32_t nSlots, uint32_t from) { - DcfStateTest *state = m_dcfStates[from]; + Ptr state = m_dcfStates[from]; struct DcfStateTest::ExpectedCollision col; col.at = time; col.nSlots = nSlots; @@ -409,7 +409,7 @@ DcfManagerTest::ExpectInternalCollision (uint64_t time, uint32_t nSlots, uint32_ void DcfManagerTest::ExpectCollision (uint64_t time, uint32_t nSlots, uint32_t from) { - DcfStateTest *state = m_dcfStates[from]; + Ptr state = m_dcfStates[from]; struct DcfStateTest::ExpectedCollision col; col.at = time; col.nSlots = nSlots; @@ -431,7 +431,7 @@ DcfManagerTest::AddDcfState (uint32_t aifsn) { Ptr dca = CreateObject (this, m_dcfStates.size ()); m_dca.push_back (dca); - DcfStateTest *state = new DcfStateTest (dca); + Ptr state = CreateObject (dca); state->SetAifsn (aifsn); m_dcfStates.push_back (state); m_dcfManager->Add (state); @@ -445,11 +445,11 @@ DcfManagerTest::EndTest (void) for (DcfStates::const_iterator i = m_dcfStates.begin (); i != m_dcfStates.end (); i++) { - DcfStateTest *state = *i; + Ptr state = *i; NS_TEST_EXPECT_MSG_EQ (state->m_expectedGrants.empty (), true, "Have no expected grants"); NS_TEST_EXPECT_MSG_EQ (state->m_expectedInternalCollision.empty (), true, "Have no internal collisions"); NS_TEST_EXPECT_MSG_EQ (state->m_expectedCollision.empty (), true, "Have no expected collisions"); - delete state; + state = 0; } m_dcfStates.clear (); @@ -543,7 +543,7 @@ DcfManagerTest::AddAccessRequestWithSuccessfullAck (uint64_t at, uint64_t txTime } void -DcfManagerTest::DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state) +DcfManagerTest::DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, Ptr state) { state->QueueTx (txTime, expectedGrantTime); m_dcfManager->RequestAccess (state); diff --git a/src/wifi/test/wifi-aggregation-test.cc b/src/wifi/test/wifi-aggregation-test.cc index a53b6542d98..e6a899a2bd2 100644 --- a/src/wifi/test/wifi-aggregation-test.cc +++ b/src/wifi/test/wifi-aggregation-test.cc @@ -48,11 +48,11 @@ class AmpduAggregationTest : public TestCase Ptr m_low; ///< MacLow Ptr m_phy; ///< Phy Ptr m_edca; ///< EDCA - MacTxMiddle *m_txMiddle; ///< MacTxMiddle + Ptr m_txMiddle; ///< MacTxMiddle Ptr m_manager; ///< remote station manager ObjectFactory m_factory; ///< factory Ptr m_mpduAggregator; ///< A-MPDU aggregrator - DcfManager *m_dcfManager; ///< DCF manager + Ptr m_dcfManager; ///< DCF manager }; AmpduAggregationTest::AmpduAggregationTest () @@ -87,7 +87,7 @@ AmpduAggregationTest::DoRun (void) m_low->SetWifiRemoteStationManager (m_manager); m_low->SetAddress (Mac48Address ("00:00:00:00:00:01")); - m_dcfManager = new DcfManager (); + m_dcfManager = CreateObject (); m_dcfManager->SetupLow (m_low); m_dcfManager->SetupPhyListener (m_phy); m_dcfManager->SetSlot (MicroSeconds (9)); @@ -98,7 +98,7 @@ AmpduAggregationTest::DoRun (void) m_edca->SetWifiRemoteStationManager (m_manager); m_edca->SetManager (m_dcfManager); - m_txMiddle = new MacTxMiddle (); + m_txMiddle = CreateObject (); m_edca->SetTxMiddle (m_txMiddle); m_edca->CompleteConfig (); @@ -238,7 +238,7 @@ AmpduAggregationTest::DoRun (void) Simulator::Destroy (); - delete m_txMiddle; + m_txMiddle = 0; m_low->Dispose (); m_low = 0; @@ -246,7 +246,7 @@ AmpduAggregationTest::DoRun (void) m_edca->Dispose (); m_edca = 0; - delete m_dcfManager; + m_dcfManager = 0; } /** From 69f43db97b1ddb81b91d9a59d9772f562c1366dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 26 Jun 2017 22:49:53 +0200 Subject: [PATCH 129/551] wifi: Use static for class functions --- src/wifi/model/mac-low.cc | 30 +++++++++++++++--------------- src/wifi/model/mac-low.h | 15 ++++++++------- src/wifi/model/wifi-phy.cc | 4 ++-- src/wifi/model/wifi-phy.h | 4 ++-- 4 files changed, 27 insertions(+), 26 deletions(-) diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index e70da2e814d..0fdfe5adffc 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -724,7 +724,7 @@ MacLow::StartTransmission (Ptr packet, } } - NS_LOG_DEBUG ("startTx size=" << GetSize (m_currentPacket, &m_currentHdr) << + NS_LOG_DEBUG ("startTx size=" << GetSize (m_currentPacket, &m_currentHdr, m_ampdu) << ", to=" << m_currentHdr.GetAddr1 () << ", dca=" << m_currentDca); if (m_txParams.MustSendRts ()) @@ -1154,7 +1154,7 @@ MacLow::ReceiveOk (Ptr packet, double rxSnr, WifiTxVector txVector, bool } uint32_t -MacLow::GetAckSize (void) const +MacLow::GetAckSize (void) { WifiMacHeader ack; ack.SetType (WIFI_MAC_CTL_ACK); @@ -1162,7 +1162,7 @@ MacLow::GetAckSize (void) const } uint32_t -MacLow::GetBlockAckSize (BlockAckType type) const +MacLow::GetBlockAckSize (BlockAckType type) { WifiMacHeader hdr; hdr.SetType (WIFI_MAC_CTL_BACKRESP); @@ -1184,7 +1184,7 @@ MacLow::GetBlockAckSize (BlockAckType type) const } uint32_t -MacLow::GetRtsSize (void) const +MacLow::GetRtsSize (void) { WifiMacHeader rts; rts.SetType (WIFI_MAC_CTL_RTS); @@ -1230,7 +1230,7 @@ MacLow::GetCtsDuration (WifiTxVector ctsTxVector) const } uint32_t -MacLow::GetCtsSize (void) const +MacLow::GetCtsSize (void) { WifiMacHeader cts; cts.SetType (WIFI_MAC_CTL_CTS); @@ -1238,11 +1238,11 @@ MacLow::GetCtsSize (void) const } uint32_t -MacLow::GetSize (Ptr packet, const WifiMacHeader *hdr) const +MacLow::GetSize (Ptr packet, const WifiMacHeader *hdr, bool isAmpdu) { uint32_t size; WifiMacTrailer fcs; - if (m_ampdu) + if (isAmpdu) { size = packet->GetSize (); } @@ -1317,7 +1317,7 @@ MacLow::CalculateOverallTxTime (Ptr packet, txTime += Time (GetSifs () * 2); } WifiTxVector dataTxVector = GetDataTxVector (packet, hdr); - uint32_t dataSize = GetSize (packet, hdr); + uint32_t dataSize = GetSize (packet, hdr, m_ampdu); txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, m_phy->GetFrequency ()); txTime += GetSifs (); if (params.MustWaitAck ()) @@ -1343,7 +1343,7 @@ MacLow::CalculateOverallTxFragmentTime (Ptr packet, } WifiTxVector dataTxVector = GetDataTxVector (packet, hdr); Ptr fragment = Create (fragmentSize); - uint32_t dataSize = GetSize (fragment, hdr); + uint32_t dataSize = GetSize (fragment, hdr, m_ampdu); txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, m_phy->GetFrequency ()); txTime += GetSifs (); if (params.MustWaitAck ()) @@ -1708,7 +1708,7 @@ MacLow::SendRtsForPacket (void) duration += GetSifs (); duration += GetCtsDuration (m_currentHdr.GetAddr1 (), rtsTxVector); duration += GetSifs (); - duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), + duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr, m_ampdu), m_currentTxVector, m_phy->GetFrequency ()); duration += GetSifs (); if (m_txParams.MustWaitBasicBlockAck ()) @@ -1755,7 +1755,7 @@ MacLow::SendRtsForPacket (void) void MacLow::StartDataTxTimers (WifiTxVector dataTxVector) { - Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, m_phy->GetFrequency ()); + Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr, m_ampdu), dataTxVector, m_phy->GetFrequency ()); if (m_txParams.MustWaitNormalAck ()) { Time timerDelay = txDuration + GetAckTimeout (); @@ -1925,7 +1925,7 @@ MacLow::SendCtsToSelf (void) else { duration += GetSifs (); - duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket,&m_currentHdr), + duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr, m_ampdu), m_currentTxVector, m_phy->GetFrequency ()); if (m_txParams.MustWaitBasicBlockAck ()) { @@ -2080,7 +2080,7 @@ MacLow::SendDataAfterCts (Mac48Address source, Time duration) } } - Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), m_currentTxVector, m_phy->GetFrequency ()); + Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr, m_ampdu), m_currentTxVector, m_phy->GetFrequency ()); duration -= txDuration; duration -= GetSifs (); @@ -2164,7 +2164,7 @@ MacLow::SendAckAfterData (Mac48Address source, Time duration, WifiMode dataTxMod } bool -MacLow::IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize) const +MacLow::IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize) { return ((seq - winstart + 4096) % 4096) < winsize; } @@ -3094,7 +3094,7 @@ MacLow::PerformMsduAggregation (Ptr packet, WifiMacHeader *hdr, Ti } void -MacLow::AddWifiMacTrailer (Ptr packet) const +MacLow::AddWifiMacTrailer (Ptr packet) { WifiMacTrailer fcs; packet->AddTrailer (fcs); diff --git a/src/wifi/model/mac-low.h b/src/wifi/model/mac-low.h index e45722ce7e8..afc02b3a7e3 100644 --- a/src/wifi/model/mac-low.h +++ b/src/wifi/model/mac-low.h @@ -619,41 +619,42 @@ class MacLow : public Object * * \return the total ACK size */ - uint32_t GetAckSize (void) const; + static uint32_t GetAckSize (void); /** * Return the total Block ACK size (including FCS trailer). * * \param type the Block ACK type * \return the total Block ACK size */ - uint32_t GetBlockAckSize (BlockAckType type) const; + static uint32_t GetBlockAckSize (BlockAckType type); /** * Return the total RTS size (including FCS trailer). * * \return the total RTS size */ - uint32_t GetRtsSize (void) const; + static uint32_t GetRtsSize (void); /** * Return the total CTS size (including FCS trailer). * * \return the total CTS size */ - uint32_t GetCtsSize (void) const; + static uint32_t GetCtsSize (void); /** * Return the total size of the packet after WifiMacHeader and FCS trailer * have been added. * * \param packet the packet to be encapsulated with WifiMacHeader and FCS trailer * \param hdr the WifiMacHeader + * \param isAmpdu whether packet is part of an A-MPDU * \return the total packet size */ - uint32_t GetSize (Ptr packet, const WifiMacHeader *hdr) const; + static uint32_t GetSize (Ptr packet, const WifiMacHeader *hdr, bool isAmpdu); /** * Add FCS trailer to a packet. * * \param packet */ - void AddWifiMacTrailer (Ptr packet) const; + static void AddWifiMacTrailer (Ptr packet); /** * Forward the packet down to WifiPhy for transmission. This is called for the entire A-MPDu when MPDU aggregation is used. * @@ -976,7 +977,7 @@ class MacLow : public Object * * This method checks if the MPDU's sequence number is inside the scoreboard boundaries or not */ - bool IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize) const; + static bool IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize); /** * \param packet the packet * \param hdr the header diff --git a/src/wifi/model/wifi-phy.cc b/src/wifi/model/wifi-phy.cc index 1a625d943ed..c931a4e9d10 100644 --- a/src/wifi/model/wifi-phy.cc +++ b/src/wifi/model/wifi-phy.cc @@ -1273,7 +1273,7 @@ WifiPhy::GetFrequency (void) const } bool -WifiPhy::Is2_4Ghz (double frequency) const +WifiPhy::Is2_4Ghz (double frequency) { if (frequency >= 2400 && frequency <= 2500) { @@ -1283,7 +1283,7 @@ WifiPhy::Is2_4Ghz (double frequency) const } bool -WifiPhy::Is5Ghz (double frequency) const +WifiPhy::Is5Ghz (double frequency) { if (frequency >= 5000 && frequency <= 6000) { diff --git a/src/wifi/model/wifi-phy.h b/src/wifi/model/wifi-phy.h index 50369ce7bc1..cfd91eb1d11 100644 --- a/src/wifi/model/wifi-phy.h +++ b/src/wifi/model/wifi-phy.h @@ -1521,12 +1521,12 @@ class WifiPhy : public Object * \param frequency the frequency to check * \return whether frequency is in the 2.4 GHz band */ - bool Is2_4Ghz (double frequency) const; + static bool Is2_4Ghz (double frequency); /** * \param frequency the frequency to check * \return whether frequency is in the 5 GHz band */ - bool Is5Ghz (double frequency) const; + static bool Is5Ghz (double frequency); /** * Enable or disable support for HT/VHT short guard interval. * From df1b368b7a6ed634901b6612b2580796dafb484f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 26 Jun 2017 22:52:02 +0200 Subject: [PATCH 130/551] wifi: (fixes 2757) Properly enforce 802.11n/ac/ax maximum TXOP --- RELEASE_NOTES | 1 + examples/wireless/examples-to-run.py | 2 +- examples/wireless/wifi-aggregation.cc | 2 +- src/wifi/model/mac-low.cc | 6 +++--- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 74b8741e623..0ed5bced842 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -105,6 +105,7 @@ Bugs fixed - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes +- Bug 2757 - 802.11n/ac/ax maximum TXOP is not properly enforced - Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts - Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast - Bug 2760 - OLSR uses unicast-bound sockets to receive broadcasts diff --git a/examples/wireless/examples-to-run.py b/examples/wireless/examples-to-run.py index 78cec1d0c1d..17432eca155 100755 --- a/examples/wireless/examples-to-run.py +++ b/examples/wireless/examples-to-run.py @@ -33,7 +33,7 @@ ("ofdm-he-validation", "True", "True"), ("ht-wifi-network --simulationTime=0.1 --minExpectedThroughput=5 --maxExpectedThroughput=134", "True", "True"), ("vht-wifi-network --simulationTime=0.1 --minExpectedThroughput=5 --maxExpectedThroughput=555", "True", "True"), - ("he-wifi-network --simulationTime=0.25 --minExpectedThroughput=6.5 --maxExpectedThroughput=754", "True", "True"), + ("he-wifi-network --simulationTime=0.25 --minExpectedThroughput=6.35 --maxExpectedThroughput=754", "True", "True"), ("simple-ht-hidden-stations --simulationTime=1 --minExpectedThroughput=16.7 --maxExpectedThroughput=16.8", "True", "True"), ("mixed-network --simulationTime=1", "True", "True"), ("wifi-aggregation --simulationTime=1 --verifyResults=1", "True", "True"), diff --git a/examples/wireless/wifi-aggregation.cc b/examples/wireless/wifi-aggregation.cc index 6d284822ff9..588b1e28bff 100644 --- a/examples/wireless/wifi-aggregation.cc +++ b/examples/wireless/wifi-aggregation.cc @@ -284,7 +284,7 @@ int main (int argc, char *argv[]) uint64_t totalPacketsThrough = DynamicCast (serverAppA.Get (0))->GetReceived (); double throughput = totalPacketsThrough * payloadSize * 8 / (simulationTime * 1000000.0); std::cout << "Throughput with default configuration (A-MPDU aggregation enabled, 65kB): " << throughput << " Mbit/s" << '\n'; - if (verifyResults && (throughput < 59.5 || throughput > 60.5)) + if (verifyResults && (throughput < 59 || throughput > 60)) { NS_LOG_ERROR ("Obtained throughput " << throughput << " is not in the expected boundaries!"); exit (1); diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 0fdfe5adffc..b6c30cfb455 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -2669,14 +2669,14 @@ MacLow::StopMpduAggregation (Ptr peekedPacket, WifiMacHeader peeke return true; } - Time aPPDUMaxTime = MilliSeconds (10); + Time aPPDUMaxTime = MicroSeconds (5484); uint8_t tid = GetTid (peekedPacket, peekedHdr); AcIndex ac = QosUtilsMapTidToAc (tid); std::map >::const_iterator edcaIt = m_edca.find (ac); - if (m_currentTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT) + if (m_phy->GetGreenfield ()) { - aPPDUMaxTime = MicroSeconds (5484); + aPPDUMaxTime = MicroSeconds (10000); } //A STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime From 2f6fdbe31fbd6e7fc45365a46ddcf9690c388061 Mon Sep 17 00:00:00 2001 From: Varun Reddy Date: Sun, 2 Jul 2017 15:37:17 +0200 Subject: [PATCH 131/551] wifi: (fixes #2761) Make sure CTS frames are not sent in A-MPDUs --- src/wifi/model/mac-low.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index b6c30cfb455..26844784a0e 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -1495,7 +1495,7 @@ MacLow::ForwardDown (Ptr packet, const WifiMacHeader* hdr, WifiTxV ", preamble=" << txVector.GetPreambleType () << ", duration=" << hdr->GetDuration () << ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec); - if (!m_ampdu || hdr->IsAck () || hdr->IsRts () || hdr->IsBlockAck () || hdr->IsMgt ()) + if (!m_ampdu || hdr->IsAck () || hdr->IsRts () || hdr->IsCts () || hdr->IsBlockAck () || hdr->IsMgt ()) { m_phy->SendPacket (packet, txVector); } From 4da17e78b8ec9995becd1897a3a106441928dfcb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Sun, 2 Jul 2017 15:41:30 +0200 Subject: [PATCH 132/551] Update RELEASE_NOTES and AUTHORS list --- AUTHORS | 1 + RELEASE_NOTES | 1 + 2 files changed, 2 insertions(+) diff --git a/AUTHORS b/AUTHORS index 1b840c8f451..e937ee6a5c6 100644 --- a/AUTHORS +++ b/AUTHORS @@ -144,6 +144,7 @@ Ovidiu Poncea (ovidiu.poncea@cs.pub.ro) Vikas Pushkar (vikaskupushkar@gmail.com) Andrea Ranieri (andreran@uno.it) Bruno Ranieri (Yrrsinn@googlemail.com) +Varun Reddy (varunamarreddy@gmail.com) Ken Renard (kenneth.renard@arl.army.mil) Manuel Requena (mrequena@cttc.es) Matias Richart (mrichart@fing.edu.uy) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 0ed5bced842..11a25855a26 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -109,6 +109,7 @@ Bugs fixed - Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts - Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast - Bug 2760 - OLSR uses unicast-bound sockets to receive broadcasts +- Bug 2761 - Packet has no Traffic ID for CTS frames when A-MPDU is used Known issues ------------ From 85e5d91383f11ce8cc583d5de524a80322c2407d Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Mon, 3 Jul 2017 02:41:24 +0200 Subject: [PATCH 133/551] Add .gitattributes file - needed to avoid GitHub wrong language scan --- .gitattributes | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000000..63a1629cb17 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +src/*/bindings/* linguist-generated=true + From 895ecc8a12a777158cc86a8e83e52257ad04fabf Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 2 Jul 2017 21:32:55 -0700 Subject: [PATCH 134/551] wifi: Further changes to commit 12941 for smart pointer usage * Use ns3::Object only when trace sources or attributes are anticipated; otherwise use reference counted smart pointer * Remove RandomStream class because it adds no real functionality. It provides a TestRandomStream class for deterministic random variables (for testing) but this test class is unused and could be accomplished by other means. --- src/wifi/model/block-ack-manager.cc | 13 +++ src/wifi/model/block-ack-manager.h | 6 ++ src/wifi/model/dca-txop.cc | 17 ++-- src/wifi/model/dca-txop.h | 4 +- src/wifi/model/dcf-state.cc | 12 +++ src/wifi/model/dcf-state.h | 7 ++ src/wifi/model/edca-txop-n.cc | 23 ++--- src/wifi/model/mac-rx-middle.h | 4 +- src/wifi/model/mac-tx-middle.h | 4 +- src/wifi/model/qos-blocked-destinations.h | 4 +- src/wifi/model/random-stream.cc | 68 ------------- src/wifi/model/random-stream.h | 118 ---------------------- src/wifi/model/regular-wifi-mac.cc | 4 +- src/wifi/test/wifi-aggregation-test.cc | 2 +- src/wifi/wscript | 2 +- 15 files changed, 69 insertions(+), 219 deletions(-) delete mode 100644 src/wifi/model/random-stream.cc delete mode 100644 src/wifi/model/random-stream.h diff --git a/src/wifi/model/block-ack-manager.cc b/src/wifi/model/block-ack-manager.cc index f1fa607c1cb..5788ca0ffa2 100644 --- a/src/wifi/model/block-ack-manager.cc +++ b/src/wifi/model/block-ack-manager.cc @@ -56,6 +56,19 @@ Bar::Bar (Ptr bar, Mac48Address recipient, uint8_t tid, bool immed NS_LOG_FUNCTION (this << bar << recipient << (uint16_t)tid << immediate); } +NS_OBJECT_ENSURE_REGISTERED (BlockAckManager); + +TypeId +BlockAckManager::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::BlockAckManager") + .SetParent () + .SetGroupName ("Wifi") + .AddConstructor () + ; + return tid; +} + BlockAckManager::BlockAckManager () { NS_LOG_FUNCTION (this); diff --git a/src/wifi/model/block-ack-manager.h b/src/wifi/model/block-ack-manager.h index e07d76e5e9e..2e308693cc6 100644 --- a/src/wifi/model/block-ack-manager.h +++ b/src/wifi/model/block-ack-manager.h @@ -79,6 +79,12 @@ class BlockAckManager : public Object public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + BlockAckManager (); ~BlockAckManager (); diff --git a/src/wifi/model/dca-txop.cc b/src/wifi/model/dca-txop.cc index 84f3ede3f0f..68870b7fa66 100644 --- a/src/wifi/model/dca-txop.cc +++ b/src/wifi/model/dca-txop.cc @@ -25,7 +25,6 @@ #include "dcf-state.h" #include "wifi-mac-queue.h" #include "mac-tx-middle.h" -#include "random-stream.h" #undef NS_LOG_APPEND_CONTEXT #define NS_LOG_APPEND_CONTEXT if (m_low != 0) { std::clog << "[mac=" << m_low->GetAddress () << "] "; } @@ -78,7 +77,7 @@ DcaTxop::DcaTxop () NS_LOG_FUNCTION (this); m_dcf = CreateObject (this); m_queue = CreateObject (); - m_rng = CreateObject (); + m_rng = CreateObject (); } DcaTxop::~DcaTxop () @@ -229,7 +228,7 @@ int64_t DcaTxop::AssignStreams (int64_t stream) { NS_LOG_FUNCTION (this << stream); - m_rng->AssignStreams (stream); + m_rng->SetStream (stream); return 1; } @@ -269,7 +268,7 @@ DcaTxop::DoInitialize () { NS_LOG_FUNCTION (this); m_dcf->ResetCw (); - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); } bool @@ -436,7 +435,7 @@ void DcaTxop::NotifyCollision (void) { NS_LOG_FUNCTION (this); - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); RestartAccessIfNeeded (); } @@ -487,7 +486,7 @@ DcaTxop::MissedCts (void) { m_dcf->UpdateFailedCw (); } - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); RestartAccessIfNeeded (); } @@ -509,7 +508,7 @@ DcaTxop::GotAck (void) */ m_currentPacket = 0; m_dcf->ResetCw (); - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); RestartAccessIfNeeded (); } else @@ -541,7 +540,7 @@ DcaTxop::MissedAck (void) m_currentHdr.SetRetry (); m_dcf->UpdateFailedCw (); } - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); RestartAccessIfNeeded (); } @@ -582,7 +581,7 @@ DcaTxop::EndTxNoAck (void) NS_LOG_DEBUG ("a transmission that did not require an ACK just finished"); m_currentPacket = 0; m_dcf->ResetCw (); - m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ())); + m_dcf->StartBackoffNow (m_rng->GetInteger (0, m_dcf->GetCw ())); StartAccessIfNeeded (); } diff --git a/src/wifi/model/dca-txop.h b/src/wifi/model/dca-txop.h index 83dbad0361b..a61540c214e 100644 --- a/src/wifi/model/dca-txop.h +++ b/src/wifi/model/dca-txop.h @@ -30,7 +30,7 @@ namespace ns3 { class DcfState; class DcfManager; class MacTxMiddle; -class RandomStream; +class UniformRandomVariable; class CtrlBAckResponseHeader; /** @@ -410,7 +410,7 @@ class DcaTxop : public Object Ptr m_txMiddle; //!< the MacTxMiddle Ptr m_low; //!< the MacLow Ptr m_stationManager; //!< the wifi remote station manager - Ptr m_rng; //!< the random stream + Ptr m_rng; //!< the random stream Ptr m_currentPacket; //!< the current packet WifiMacHeader m_currentHdr; //!< the current header diff --git a/src/wifi/model/dcf-state.cc b/src/wifi/model/dcf-state.cc index 837b87635e5..e78554a1f3b 100644 --- a/src/wifi/model/dcf-state.cc +++ b/src/wifi/model/dcf-state.cc @@ -26,6 +26,18 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DcfState"); +NS_OBJECT_ENSURE_REGISTERED (DcfState); + +TypeId +DcfState::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::DcfState") + .SetParent () + .SetGroupName ("Wifi") + ; + return tid; +} + DcfState::DcfState (Ptr txop) : m_backoffSlots (0), m_backoffStart (Seconds (0.0)), diff --git a/src/wifi/model/dcf-state.h b/src/wifi/model/dcf-state.h index 0adb2cdc84d..51a385eb401 100644 --- a/src/wifi/model/dcf-state.h +++ b/src/wifi/model/dcf-state.h @@ -41,6 +41,13 @@ class DcaTxop; class DcfState : public Object { public: + + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + /** * Constructor * diff --git a/src/wifi/model/edca-txop-n.cc b/src/wifi/model/edca-txop-n.cc index 6c2858adaf1..6cf9e48dbcd 100644 --- a/src/wifi/model/edca-txop-n.cc +++ b/src/wifi/model/edca-txop-n.cc @@ -27,7 +27,6 @@ #include "dcf-state.h" #include "mac-tx-middle.h" #include "wifi-mac-trailer.h" -#include "random-stream.h" #include "wifi-mac-queue.h" #include "qos-blocked-destinations.h" #include "ns3/simulator.h" @@ -74,7 +73,7 @@ EdcaTxopN::EdcaTxopN () m_currentIsFragmented (false) { NS_LOG_FUNCTION (this); - m_qosBlockedDestinations = CreateObject (); + m_qosBlockedDestinations = Create (); m_baManager = CreateObject (); m_baManager->SetQueue (m_queue); m_baManager->SetBlockAckType (m_blockAckType); @@ -423,7 +422,7 @@ void EdcaTxopN::NotifyInternalCollision (void) m_dcf->UpdateFailedCw (); } } - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -432,7 +431,7 @@ void EdcaTxopN::NotifyCollision (void) { NS_LOG_FUNCTION (this); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -495,7 +494,7 @@ EdcaTxopN::MissedCts (void) m_dcf->UpdateFailedCw (); m_cwTrace = m_dcf->GetCw (); } - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -543,7 +542,7 @@ EdcaTxopN::GotAck (void) m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } m_cwTrace = m_dcf->GetCw (); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -557,7 +556,7 @@ EdcaTxopN::GotAck (void) { m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); m_cwTrace = m_dcf->GetCw (); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); m_fragmentNumber++; RestartAccessIfNeeded (); @@ -626,7 +625,7 @@ EdcaTxopN::MissedAck (void) m_dcf->UpdateFailedCw (); m_cwTrace = m_dcf->GetCw (); } - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -700,7 +699,7 @@ EdcaTxopN::MissedBlockAck (uint8_t nMpdus) m_dcf->ResetCw (); m_cwTrace = m_dcf->GetCw (); } - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -963,7 +962,7 @@ EdcaTxopN::EndTxNoAck (void) m_currentPacket = 0; m_dcf->ResetCw (); m_cwTrace = m_dcf->GetCw (); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); StartAccessIfNeeded (); } @@ -1293,7 +1292,7 @@ EdcaTxopN::GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address rec m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop); } m_cwTrace = m_dcf->GetCw (); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); RestartAccessIfNeeded (); } @@ -1563,7 +1562,7 @@ EdcaTxopN::DoInitialize () NS_LOG_FUNCTION (this); m_dcf->ResetCw (); m_cwTrace = m_dcf->GetCw (); - m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ()); + m_backoffTrace = m_rng->GetInteger (0, m_dcf->GetCw ()); m_dcf->StartBackoffNow (m_backoffTrace); } diff --git a/src/wifi/model/mac-rx-middle.h b/src/wifi/model/mac-rx-middle.h index c04095d8a0f..9c84a908cb8 100644 --- a/src/wifi/model/mac-rx-middle.h +++ b/src/wifi/model/mac-rx-middle.h @@ -23,7 +23,7 @@ #include #include "ns3/packet.h" -#include "ns3/object.h" +#include "ns3/simple-ref-count.h" namespace ns3 { @@ -35,7 +35,7 @@ class OriginatorRxStatus; * * This class handles duplicate detection and recomposition of fragments. */ -class MacRxMiddle : public Object +class MacRxMiddle : public SimpleRefCount { public: /** diff --git a/src/wifi/model/mac-tx-middle.h b/src/wifi/model/mac-tx-middle.h index bc3469eca17..1056084d88b 100644 --- a/src/wifi/model/mac-tx-middle.h +++ b/src/wifi/model/mac-tx-middle.h @@ -25,7 +25,7 @@ #include #include "ns3/mac48-address.h" -#include "ns3/object.h" +#include "ns3/simple-ref-count.h" namespace ns3 { @@ -36,7 +36,7 @@ class WifiMacHeader; * * Handles sequence numbering of IEEE 802.11 data frames */ -class MacTxMiddle : public Object +class MacTxMiddle : public SimpleRefCount { public: MacTxMiddle (); diff --git a/src/wifi/model/qos-blocked-destinations.h b/src/wifi/model/qos-blocked-destinations.h index 4960b3671ed..96ba07e9f31 100644 --- a/src/wifi/model/qos-blocked-destinations.h +++ b/src/wifi/model/qos-blocked-destinations.h @@ -24,7 +24,7 @@ #include #include "ns3/mac48-address.h" -#include "ns3/object.h" +#include "ns3/simple-ref-count.h" namespace ns3 { @@ -32,7 +32,7 @@ namespace ns3 { * Keep track of destination address - TID pairs that are waiting * for a block ACK response. */ -class QosBlockedDestinations : public Object +class QosBlockedDestinations : public SimpleRefCount { public: QosBlockedDestinations (); diff --git a/src/wifi/model/random-stream.cc b/src/wifi/model/random-stream.cc deleted file mode 100644 index 54e23f77c3e..00000000000 --- a/src/wifi/model/random-stream.cc +++ /dev/null @@ -1,68 +0,0 @@ -/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ -/* - * Copyright (c) 2007 INRIA - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation; - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Author: Mathieu Lacage - */ - -#include "random-stream.h" - -namespace ns3 { - -RandomStream::~RandomStream () -{ -} - -RealRandomStream::RealRandomStream () -{ - m_stream = CreateObject (); -} - -uint32_t -RealRandomStream::GetNext (uint32_t min, uint32_t max) -{ - return m_stream->GetInteger (min, max); -} - -int64_t -RealRandomStream::AssignStreams (int64_t stream) -{ - m_stream->SetStream (stream); - return 1; -} - -void -TestRandomStream::AddNext (uint32_t v) -{ - m_nexts.push_back (v); -} - -uint32_t -TestRandomStream::GetNext (uint32_t min, uint32_t max) -{ - NS_ASSERT (!m_nexts.empty ()); - uint32_t next = m_nexts.front (); - m_nexts.pop_front (); - return next; -} - -int64_t -TestRandomStream::AssignStreams (int64_t stream) -{ - return 0; -} - -} //namespace ns3 diff --git a/src/wifi/model/random-stream.h b/src/wifi/model/random-stream.h deleted file mode 100644 index 0c4c4896ef4..00000000000 --- a/src/wifi/model/random-stream.h +++ /dev/null @@ -1,118 +0,0 @@ -/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ -/* - * Copyright (c) 2007 INRIA - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation; - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Author: Mathieu Lacage - */ - -#ifndef RANDOM_STREAM_H -#define RANDOM_STREAM_H - -#include "ns3/random-variable-stream.h" - -namespace ns3 { - -/** - * A simple wrapper around RngStream to make testing - * of the code easier. - */ -class RandomStream : public Object -{ -public: - virtual ~RandomStream (); - /** - * Get integer between min and max (including min and max). - * - * \param min lower bound (inclusive) - * \param max upper bound (inclusive) - * - * \return a random number between min and max (including min and max) - */ - virtual uint32_t GetNext (uint32_t min, uint32_t max) = 0; - - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * - * \return the number of stream indices assigned by this model - */ - virtual int64_t AssignStreams (int64_t stream) = 0; -}; - - -/** - * RealRandomStream class - */ -class RealRandomStream : public RandomStream -{ -public: - RealRandomStream (); - virtual uint32_t GetNext (uint32_t min, uint32_t max); - - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * - * \return the number of stream indices assigned by this model - */ - virtual int64_t AssignStreams (int64_t stream); - - -private: - /// Provides uniform random variables. - Ptr m_stream; -}; - - -/** - * TestRandomStream class - */ -class TestRandomStream : public RandomStream -{ -public: - /** - * Add the given value to the list. - * - * \param v - */ - void AddNext (uint32_t v); - virtual uint32_t GetNext (uint32_t min, uint32_t max); - - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * - * \return the number of stream indices assigned by this model - */ - virtual int64_t AssignStreams (int64_t stream); - - -private: - std::list m_nexts; ///< nexts -}; - -} //namespace ns3 - -#endif /* RANDOM_STREAM_H */ diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index 7ae5ee06c37..d83f31fc823 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -42,10 +42,10 @@ RegularWifiMac::RegularWifiMac () m_heSupported (0) { NS_LOG_FUNCTION (this); - m_rxMiddle = CreateObject (); + m_rxMiddle = Create (); m_rxMiddle->SetForwardCallback (MakeCallback (&RegularWifiMac::Receive, this)); - m_txMiddle = CreateObject (); + m_txMiddle = Create (); m_low = CreateObject (); m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle)); diff --git a/src/wifi/test/wifi-aggregation-test.cc b/src/wifi/test/wifi-aggregation-test.cc index e6a899a2bd2..8961c4e832c 100644 --- a/src/wifi/test/wifi-aggregation-test.cc +++ b/src/wifi/test/wifi-aggregation-test.cc @@ -98,7 +98,7 @@ AmpduAggregationTest::DoRun (void) m_edca->SetWifiRemoteStationManager (m_manager); m_edca->SetManager (m_dcfManager); - m_txMiddle = CreateObject (); + m_txMiddle = Create (); m_edca->SetTxMiddle (m_txMiddle); m_edca->CompleteConfig (); diff --git a/src/wifi/wscript b/src/wifi/wscript index a8ddd1df05f..78d28ea01a8 100644 --- a/src/wifi/wscript +++ b/src/wifi/wscript @@ -32,7 +32,6 @@ def build(bld): 'model/capability-information.cc', 'model/status-code.cc', 'model/mgt-headers.cc', - 'model/random-stream.cc', 'model/dcf-manager.cc', 'model/dcf-state.cc', 'model/wifi-mac.cc', @@ -194,6 +193,7 @@ def build(bld): 'model/he-capabilities.h', 'model/frame-capture-model.h', 'model/simple-frame-capture-model.h', + 'model/qos-blocked-destinations.h', 'helper/wifi-radio-energy-model-helper.h', 'helper/vht-wifi-mac-helper.h', 'helper/ht-wifi-mac-helper.h', From 11677374d9d44441206770023ced3a05dc3d1564 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 2 Jul 2017 21:41:03 -0700 Subject: [PATCH 135/551] wifi: rescan bindings (64-bit only) --- src/wifi/bindings/modulegen__gcc_LP64.py | 4134 +++++++++++++++------- 1 file changed, 2811 insertions(+), 1323 deletions(-) diff --git a/src/wifi/bindings/modulegen__gcc_LP64.py b/src/wifi/bindings/modulegen__gcc_LP64.py index df909e6459e..be85fdfe699 100644 --- a/src/wifi/bindings/modulegen__gcc_LP64.py +++ b/src/wifi/bindings/modulegen__gcc_LP64.py @@ -20,32 +20,32 @@ def module_init(): def register_types(module): root_module = module.get_root() + ## propagation-environment.h (module 'propagation'): ns3::EnvironmentType [enumeration] + module.add_enum('EnvironmentType', ['UrbanEnvironment', 'SubUrbanEnvironment', 'OpenAreasEnvironment'], import_from_module='ns.propagation') + ## propagation-environment.h (module 'propagation'): ns3::CitySize [enumeration] + module.add_enum('CitySize', ['SmallCity', 'MediumCity', 'LargeCity'], import_from_module='ns.propagation') ## log.h (module 'core'): ns3::LogLevel [enumeration] module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') + ## edca-txop-n.h (module 'wifi'): ns3::TypeOfStation [enumeration] + module.add_enum('TypeOfStation', ['STA', 'AP', 'ADHOC_STA', 'MESH', 'HT_STA', 'HT_AP', 'HT_ADHOC_STA', 'OCB']) + ## qos-utils.h (module 'wifi'): ns3::AcIndex [enumeration] + module.add_enum('AcIndex', ['AC_BE', 'AC_BK', 'AC_VI', 'AC_VO', 'AC_BE_NQOS', 'AC_UNDEF']) ## ht-operation.h (module 'wifi'): ns3::HtProtectionType [enumeration] module.add_enum('HtProtectionType', ['NO_PROTECTION', 'NON_MEMBER_PROTECTION', 'TWENTY_MHZ_PROTECTION', 'MIXED_MODE_PROTECTION']) + ## ctrl-headers.h (module 'wifi'): ns3::BlockAckType [enumeration] + module.add_enum('BlockAckType', ['BASIC_BLOCK_ACK', 'COMPRESSED_BLOCK_ACK', 'MULTI_TID_BLOCK_ACK']) ## wifi-mac-header.h (module 'wifi'): ns3::WifiMacType [enumeration] module.add_enum('WifiMacType', ['WIFI_MAC_CTL_CTLWRAPPER', 'WIFI_MAC_CTL_RTS', 'WIFI_MAC_CTL_CTS', 'WIFI_MAC_CTL_ACK', 'WIFI_MAC_CTL_BACKREQ', 'WIFI_MAC_CTL_BACKRESP', 'WIFI_MAC_MGT_BEACON', 'WIFI_MAC_MGT_ASSOCIATION_REQUEST', 'WIFI_MAC_MGT_ASSOCIATION_RESPONSE', 'WIFI_MAC_MGT_DISASSOCIATION', 'WIFI_MAC_MGT_REASSOCIATION_REQUEST', 'WIFI_MAC_MGT_REASSOCIATION_RESPONSE', 'WIFI_MAC_MGT_PROBE_REQUEST', 'WIFI_MAC_MGT_PROBE_RESPONSE', 'WIFI_MAC_MGT_AUTHENTICATION', 'WIFI_MAC_MGT_DEAUTHENTICATION', 'WIFI_MAC_MGT_ACTION', 'WIFI_MAC_MGT_ACTION_NO_ACK', 'WIFI_MAC_MGT_MULTIHOP_ACTION', 'WIFI_MAC_DATA', 'WIFI_MAC_DATA_CFACK', 'WIFI_MAC_DATA_CFPOLL', 'WIFI_MAC_DATA_CFACK_CFPOLL', 'WIFI_MAC_DATA_NULL', 'WIFI_MAC_DATA_NULL_CFACK', 'WIFI_MAC_DATA_NULL_CFPOLL', 'WIFI_MAC_DATA_NULL_CFACK_CFPOLL', 'WIFI_MAC_QOSDATA', 'WIFI_MAC_QOSDATA_CFACK', 'WIFI_MAC_QOSDATA_CFPOLL', 'WIFI_MAC_QOSDATA_CFACK_CFPOLL', 'WIFI_MAC_QOSDATA_NULL', 'WIFI_MAC_QOSDATA_NULL_CFPOLL', 'WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL']) - ## wifi-preamble.h (module 'wifi'): ns3::WifiPreamble [enumeration] - module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT', 'WIFI_PREAMBLE_HT_MF', 'WIFI_PREAMBLE_HT_GF', 'WIFI_PREAMBLE_VHT', 'WIFI_PREAMBLE_HE_SU', 'WIFI_PREAMBLE_HE_ER_SU', 'WIFI_PREAMBLE_HE_MU', 'WIFI_PREAMBLE_HE_TB', 'WIFI_PREAMBLE_NONE']) ## wifi-phy.h (module 'wifi'): ns3::MpduType [enumeration] module.add_enum('MpduType', ['NORMAL_MPDU', 'MPDU_IN_AGGREGATE', 'LAST_MPDU_IN_AGGREGATE']) - ## wifi-mode.h (module 'wifi'): ns3::WifiModulationClass [enumeration] - module.add_enum('WifiModulationClass', ['WIFI_MOD_CLASS_UNKNOWN', 'WIFI_MOD_CLASS_IR', 'WIFI_MOD_CLASS_FHSS', 'WIFI_MOD_CLASS_DSSS', 'WIFI_MOD_CLASS_HR_DSSS', 'WIFI_MOD_CLASS_ERP_PBCC', 'WIFI_MOD_CLASS_DSSS_OFDM', 'WIFI_MOD_CLASS_ERP_OFDM', 'WIFI_MOD_CLASS_OFDM', 'WIFI_MOD_CLASS_HT', 'WIFI_MOD_CLASS_VHT', 'WIFI_MOD_CLASS_HE']) ## wifi-phy-standard.h (module 'wifi'): ns3::WifiPhyStandard [enumeration] module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211g', 'WIFI_PHY_STANDARD_80211_10MHZ', 'WIFI_PHY_STANDARD_80211_5MHZ', 'WIFI_PHY_STANDARD_holland', 'WIFI_PHY_STANDARD_80211n_2_4GHZ', 'WIFI_PHY_STANDARD_80211n_5GHZ', 'WIFI_PHY_STANDARD_80211ac', 'WIFI_PHY_STANDARD_80211ax_2_4GHZ', 'WIFI_PHY_STANDARD_80211ax_5GHZ', 'WIFI_PHY_STANDARD_UNSPECIFIED']) - ## qos-utils.h (module 'wifi'): ns3::AcIndex [enumeration] - module.add_enum('AcIndex', ['AC_BE', 'AC_BK', 'AC_VI', 'AC_VO', 'AC_BE_NQOS', 'AC_UNDEF']) + ## wifi-preamble.h (module 'wifi'): ns3::WifiPreamble [enumeration] + module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT', 'WIFI_PREAMBLE_HT_MF', 'WIFI_PREAMBLE_HT_GF', 'WIFI_PREAMBLE_VHT', 'WIFI_PREAMBLE_HE_SU', 'WIFI_PREAMBLE_HE_ER_SU', 'WIFI_PREAMBLE_HE_MU', 'WIFI_PREAMBLE_HE_TB', 'WIFI_PREAMBLE_NONE']) + ## wifi-mode.h (module 'wifi'): ns3::WifiModulationClass [enumeration] + module.add_enum('WifiModulationClass', ['WIFI_MOD_CLASS_UNKNOWN', 'WIFI_MOD_CLASS_IR', 'WIFI_MOD_CLASS_FHSS', 'WIFI_MOD_CLASS_DSSS', 'WIFI_MOD_CLASS_HR_DSSS', 'WIFI_MOD_CLASS_ERP_PBCC', 'WIFI_MOD_CLASS_DSSS_OFDM', 'WIFI_MOD_CLASS_ERP_OFDM', 'WIFI_MOD_CLASS_OFDM', 'WIFI_MOD_CLASS_HT', 'WIFI_MOD_CLASS_VHT', 'WIFI_MOD_CLASS_HE']) ## wifi-mode.h (module 'wifi'): ns3::WifiCodeRate [enumeration] module.add_enum('WifiCodeRate', ['WIFI_CODE_RATE_UNDEFINED', 'WIFI_CODE_RATE_3_4', 'WIFI_CODE_RATE_2_3', 'WIFI_CODE_RATE_1_2', 'WIFI_CODE_RATE_5_6']) - ## edca-txop-n.h (module 'wifi'): ns3::TypeOfStation [enumeration] - module.add_enum('TypeOfStation', ['STA', 'AP', 'ADHOC_STA', 'MESH', 'HT_STA', 'HT_AP', 'HT_ADHOC_STA', 'OCB']) - ## ctrl-headers.h (module 'wifi'): ns3::BlockAckType [enumeration] - module.add_enum('BlockAckType', ['BASIC_BLOCK_ACK', 'COMPRESSED_BLOCK_ACK', 'MULTI_TID_BLOCK_ACK']) - ## propagation-environment.h (module 'propagation'): ns3::EnvironmentType [enumeration] - module.add_enum('EnvironmentType', ['UrbanEnvironment', 'SubUrbanEnvironment', 'OpenAreasEnvironment'], import_from_module='ns.propagation') - ## propagation-environment.h (module 'propagation'): ns3::CitySize [enumeration] - module.add_enum('CitySize', ['SmallCity', 'MediumCity', 'LargeCity'], import_from_module='ns.propagation') ## address.h (module 'network'): ns3::Address [class] module.add_class('Address', import_from_module='ns.network') ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration] @@ -70,8 +70,6 @@ def register_types(module): module.add_class('BlockAckAgreement') ## block-ack-cache.h (module 'wifi'): ns3::BlockAckCache [class] module.add_class('BlockAckCache') - ## block-ack-manager.h (module 'wifi'): ns3::BlockAckManager [class] - module.add_class('BlockAckManager') ## buffer.h (module 'network'): ns3::Buffer [class] module.add_class('Buffer', import_from_module='ns.network') ## buffer.h (module 'network'): ns3::Buffer::Iterator [class] @@ -92,8 +90,42 @@ def register_types(module): module.add_class('CapabilityInformation') ## data-rate.h (module 'network'): ns3::DataRate [class] module.add_class('DataRate', import_from_module='ns.network') - ## dcf-state.h (module 'wifi'): ns3::DcfState [class] - module.add_class('DcfState') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::InterferenceHelper::Event']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::MacRxMiddle']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::MacTxMiddle']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::OutputStreamWrapper']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::QosBlockedDestinations']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumModel']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::WifiInformationElement']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::WifiMacQueueItem']) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer [class] module.add_class('DeviceEnergyModelContainer', import_from_module='ns.energy') ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper [class] @@ -134,10 +166,6 @@ def register_types(module): root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address']) ## mac-low.h (module 'wifi'): ns3::MacLowTransmissionParameters [class] module.add_class('MacLowTransmissionParameters') - ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle [class] - module.add_class('MacRxMiddle') - ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle [class] - module.add_class('MacTxMiddle') ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::McsGroup [struct] module.add_class('McsGroup') ## wifi-phy.h (module 'wifi'): ns3::MpduInfo [struct] @@ -160,8 +188,8 @@ def register_types(module): module.add_class('PacketMetadata', import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) ## packet.h (module 'network'): ns3::PacketTagIterator [class] @@ -262,9 +290,9 @@ def register_types(module): module.add_class('YansWifiPhyHelper', parent=root_module['ns3::WifiPhyHelper']) ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## ampdu-tag.h (module 'wifi'): ns3::AmpduTag [class] module.add_class('AmpduTag', parent=root_module['ns3::Tag']) @@ -330,12 +358,18 @@ def register_types(module): module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::InterferenceHelper::Event', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::MacRxMiddle', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::MacTxMiddle', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::NixVector', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::OutputStreamWrapper', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] + module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::QosBlockedDestinations', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::QueueItem', 'ns3::empty', 'ns3::DefaultDeleter'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount')) ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount > [class] @@ -464,6 +498,8 @@ def register_types(module): module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter >']) ## attribute.h (module 'core'): ns3::AttributeValue [class] module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter >']) + ## block-ack-manager.h (module 'wifi'): ns3::BlockAckManager [class] + module.add_class('BlockAckManager', parent=root_module['ns3::Object']) ## boolean.h (module 'core'): ns3::BooleanChecker [class] module.add_class('BooleanChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker']) ## boolean.h (module 'core'): ns3::BooleanValue [class] @@ -498,6 +534,8 @@ def register_types(module): module.add_class('DcaTxop', parent=root_module['ns3::Object']) ## dcf-manager.h (module 'wifi'): ns3::DcfManager [class] module.add_class('DcfManager', parent=root_module['ns3::Object']) + ## dcf-state.h (module 'wifi'): ns3::DcfState [class] + module.add_class('DcfState', parent=root_module['ns3::Object']) ## random-variable-stream.h (module 'core'): ns3::DeterministicRandomVariable [class] module.add_class('DeterministicRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream']) ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel [class] @@ -554,6 +592,8 @@ def register_types(module): module.add_class('ExtendedSupportedRatesIE', parent=root_module['ns3::WifiInformationElement']) ## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel [class] module.add_class('FixedRssLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel']) + ## frame-capture-model.h (module 'wifi'): ns3::FrameCaptureModel [class] + module.add_class('FrameCaptureModel', parent=root_module['ns3::Object']) ## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel [class] module.add_class('FriisPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel']) ## random-variable-stream.h (module 'core'): ns3::GammaRandomVariable [class] @@ -620,6 +660,10 @@ def register_types(module): module.add_class('Mac48AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) ## mac-low.h (module 'wifi'): ns3::MacLow [class] module.add_class('MacLow', parent=root_module['ns3::Object']) + ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle [class] + module.add_class('MacRxMiddle', parent=root_module['ns3::SimpleRefCount< ns3::MacRxMiddle, ns3::empty, ns3::DefaultDeleter >']) + ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle [class] + module.add_class('MacTxMiddle', parent=root_module['ns3::SimpleRefCount< ns3::MacTxMiddle, ns3::empty, ns3::DefaultDeleter >']) ## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class] module.add_class('MatrixPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel']) ## mgt-headers.h (module 'wifi'): ns3::MgtBeaconHeader [class] @@ -668,6 +712,10 @@ def register_types(module): module.add_class('ParetoRandomVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariableStream']) ## parf-wifi-manager.h (module 'wifi'): ns3::ParfWifiManager [class] module.add_class('ParfWifiManager', parent=root_module['ns3::WifiRemoteStationManager']) + ## qos-blocked-destinations.h (module 'wifi'): ns3::QosBlockedDestinations [class] + module.add_class('QosBlockedDestinations', parent=root_module['ns3::SimpleRefCount< ns3::QosBlockedDestinations, ns3::empty, ns3::DefaultDeleter >']) + ## queue.h (module 'network'): ns3::Queue [class] + module.add_class('Queue', template_parameters=['ns3::WifiMacQueueItem'], parent=root_module['ns3::QueueBase']) ## queue-item.h (module 'network'): ns3::QueueItem [class] module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >']) ## queue-item.h (module 'network'): ns3::QueueItem::Uint8Values [enumeration] @@ -678,6 +726,8 @@ def register_types(module): module.add_class('RraaWifiManager', parent=root_module['ns3::WifiRemoteStationManager']) ## rrpaa-wifi-manager.h (module 'wifi'): ns3::RrpaaWifiManager [class] module.add_class('RrpaaWifiManager', parent=root_module['ns3::WifiRemoteStationManager']) + ## simple-frame-capture-model.h (module 'wifi'): ns3::SimpleFrameCaptureModel [class] + module.add_class('SimpleFrameCaptureModel', parent=root_module['ns3::FrameCaptureModel']) ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel [class] module.add_class('SpectrumChannel', import_from_module='ns.spectrum', parent=root_module['ns3::Channel']) ## spectrum-wifi-phy.h (module 'wifi'): ns3::SpectrumWifiPhy [class] @@ -730,6 +780,10 @@ def register_types(module): module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue']) ## wifi-net-device.h (module 'wifi'): ns3::WifiNetDevice [class] module.add_class('WifiNetDevice', parent=root_module['ns3::NetDevice']) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue [class] + module.add_class('WifiMacQueue', parent=root_module['ns3::Queue< ns3::WifiMacQueueItem >']) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue::DropPolicy [enumeration] + module.add_enum('DropPolicy', ['DROP_NEWEST', 'DROP_OLDEST'], outer_class=root_module['ns3::WifiMacQueue']) ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel [class] module.add_class('WifiRadioEnergyModel', parent=root_module['ns3::DeviceEnergyModel']) ## yans-error-rate-model.h (module 'wifi'): ns3::YansErrorRateModel [class] @@ -744,6 +798,64 @@ def register_types(module): module.add_class('AdhocWifiMac', parent=root_module['ns3::RegularWifiMac']) ## ap-wifi-mac.h (module 'wifi'): ns3::ApWifiMac [class] module.add_class('ApWifiMac', parent=root_module['ns3::RegularWifiMac']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'bool', 'unsigned int', 'double', 'ns3::Time', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'const ns3::WifiMacHeader &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'double', 'double', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'double', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::DataRate', 'ns3::DataRate', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::WifiMode', 'ns3::WifiPreamble', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::WifiMode', 'ns3::WifiPreamble', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'unsigned short', 'ns3::WifiTxVector', 'ns3::MpduInfo', 'ns3::SignalNoiseDbm', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'unsigned short', 'ns3::WifiTxVector', 'ns3::MpduInfo', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::WifiMacHeader *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::WifiTxVector', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Time', 'ns3::Time', 'ns3::WifiPhy::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Time', 'ns3::Time', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned int', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long', 'unsigned long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) ## queue-item.h (module 'network'): ns3::QueueDiscItem [class] module.add_class('QueueDiscItem', import_from_module='ns.network', parent=root_module['ns3::QueueItem']) module.add_container('ns3::HtMinstrelRate', 'ns3::HtRateInfo', container_type=u'vector') @@ -757,76 +869,78 @@ def register_types(module): module.add_container('std::vector< unsigned char >', 'unsigned char', container_type=u'vector') module.add_container('std::map< ns3::Mac48Address, bool >', ('ns3::Mac48Address', 'bool'), container_type=u'map') module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmpduSubframeHeader > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmpduSubframeHeader >', container_type=u'list') + module.add_container('ns3::MpduAggregator::DeaggregatedMpdus', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmpduSubframeHeader >', container_type=u'list') module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type=u'list') - typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >', u'ns3::MinstrelMcsGroups') - typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >*', u'ns3::MinstrelMcsGroups*') - typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >&', u'ns3::MinstrelMcsGroups&') - typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >', u'ns3::MinstrelRate') - typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >*', u'ns3::MinstrelRate*') - typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >&', u'ns3::MinstrelRate&') - typehandlers.add_type_alias(u'uint8_t', u'ns3::WifiInformationElementId') - typehandlers.add_type_alias(u'uint8_t*', u'ns3::WifiInformationElementId*') - typehandlers.add_type_alias(u'uint8_t&', u'ns3::WifiInformationElementId&') + module.add_container('ns3::MsduAggregator::DeaggregatedMsdus', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type=u'list') typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >', u'ns3::WifiMacQueue') typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >*', u'ns3::WifiMacQueue*') typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >&', u'ns3::WifiMacQueue&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >', u'ns3::RraaThresholdsTable') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >*', u'ns3::RraaThresholdsTable*') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >&', u'ns3::RraaThresholdsTable&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >', u'ns3::Values') typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >*', u'ns3::Values*') typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >&', u'ns3::Values&') typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', u'ns3::Bands') typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', u'ns3::Bands*') typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', u'ns3::Bands&') + typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') + typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') + typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >', u'ns3::RrpaaThresholdsTable') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >*', u'ns3::RrpaaThresholdsTable*') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >&', u'ns3::RrpaaThresholdsTable&') typehandlers.add_type_alias(u'std::vector< std::vector< double, std::allocator< double > >, std::allocator< std::vector< double, std::allocator< double > > > >', u'ns3::RrpaaProbabilitiesTable') typehandlers.add_type_alias(u'std::vector< std::vector< double, std::allocator< double > >, std::allocator< std::vector< double, std::allocator< double > > > >*', u'ns3::RrpaaProbabilitiesTable*') typehandlers.add_type_alias(u'std::vector< std::vector< double, std::allocator< double > >, std::allocator< std::vector< double, std::allocator< double > > > >&', u'ns3::RrpaaProbabilitiesTable&') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >', u'ns3::RraaThresholdsTable') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >*', u'ns3::RraaThresholdsTable*') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRraaThresholds, ns3::WifiMode > > >&', u'ns3::RraaThresholdsTable&') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >', u'ns3::TxTime') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >*', u'ns3::TxTime*') + typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >&', u'ns3::TxTime&') + typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >', u'ns3::MinstrelMcsGroups') + typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >*', u'ns3::MinstrelMcsGroups*') + typehandlers.add_type_alias(u'std::vector< ns3::McsGroup, std::allocator< ns3::McsGroup > >&', u'ns3::MinstrelMcsGroups&') + typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >', u'ns3::HtMinstrelRate') + typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >*', u'ns3::HtMinstrelRate*') + typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >&', u'ns3::HtMinstrelRate&') + typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >', u'ns3::McsGroupData') + typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >*', u'ns3::McsGroupData*') + typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >&', u'ns3::McsGroupData&') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >', u'ns3::HtSampleRate') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >*', u'ns3::HtSampleRate*') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >&', u'ns3::HtSampleRate&') + typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >', u'ns3::MinstrelRate') + typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >*', u'ns3::MinstrelRate*') + typehandlers.add_type_alias(u'std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >&', u'ns3::MinstrelRate&') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >', u'ns3::SampleRate') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >*', u'ns3::SampleRate*') + typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >&', u'ns3::SampleRate&') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') module.add_typedef(root_module['ns3::Vector3D'], 'Vector') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >', u'ns3::TxTime') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >*', u'ns3::TxTime*') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::Time, ns3::WifiMode >, std::allocator< std::pair< ns3::Time, ns3::WifiMode > > >&', u'ns3::TxTime&') - typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >', u'ns3::WifiModeList') - typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >*', u'ns3::WifiModeList*') - typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >&', u'ns3::WifiModeList&') typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >', u'ns3::RrpaaThresholdsTable') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >*', u'ns3::RrpaaThresholdsTable*') - typehandlers.add_type_alias(u'std::vector< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode >, std::allocator< std::pair< ns3::WifiRrpaaThresholds, ns3::WifiMode > > >&', u'ns3::RrpaaThresholdsTable&') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >', u'ns3::SampleRate') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >*', u'ns3::SampleRate*') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >&', u'ns3::SampleRate&') - typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') - typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') - typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') - typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >', u'ns3::McsGroupData') - typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >*', u'ns3::McsGroupData*') - typehandlers.add_type_alias(u'std::vector< ns3::GroupInfo, std::allocator< ns3::GroupInfo > >&', u'ns3::McsGroupData&') - typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >', u'ns3::HtMinstrelRate') - typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >*', u'ns3::HtMinstrelRate*') - typehandlers.add_type_alias(u'std::vector< ns3::HtRateInfo, std::allocator< ns3::HtRateInfo > >&', u'ns3::HtMinstrelRate&') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') - typehandlers.add_type_alias(u'__gnu_cxx::__normal_iterator< ns3::WifiMode const *, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >', u'ns3::WifiModeListIterator') - typehandlers.add_type_alias(u'__gnu_cxx::__normal_iterator< ns3::WifiMode const *, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >*', u'ns3::WifiModeListIterator*') - typehandlers.add_type_alias(u'__gnu_cxx::__normal_iterator< ns3::WifiMode const *, std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > >&', u'ns3::WifiModeListIterator&') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >', u'ns3::HtSampleRate') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >*', u'ns3::HtSampleRate*') - typehandlers.add_type_alias(u'std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >&', u'ns3::HtSampleRate&') + typehandlers.add_type_alias(u'uint8_t', u'ns3::WifiInformationElementId') + typehandlers.add_type_alias(u'uint8_t*', u'ns3::WifiInformationElementId*') + typehandlers.add_type_alias(u'uint8_t&', u'ns3::WifiInformationElementId&') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >', u'ns3::WifiModeList') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >*', u'ns3::WifiModeList*') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > >&', u'ns3::WifiModeList&') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > const_iterator', u'ns3::WifiModeListIterator') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > const_iterator*', u'ns3::WifiModeListIterator*') + typehandlers.add_type_alias(u'std::vector< ns3::WifiMode, std::allocator< ns3::WifiMode > > const_iterator&', u'ns3::WifiModeListIterator&') ## Register a nested module for the namespace FatalImpl @@ -861,12 +975,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -889,36 +1003,36 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -936,7 +1050,6 @@ def register_methods(root_module): register_Ns3Bar_methods(root_module, root_module['ns3::Bar']) register_Ns3BlockAckAgreement_methods(root_module, root_module['ns3::BlockAckAgreement']) register_Ns3BlockAckCache_methods(root_module, root_module['ns3::BlockAckCache']) - register_Ns3BlockAckManager_methods(root_module, root_module['ns3::BlockAckManager']) register_Ns3Buffer_methods(root_module, root_module['ns3::Buffer']) register_Ns3BufferIterator_methods(root_module, root_module['ns3::Buffer::Iterator']) register_Ns3ByteTagIterator_methods(root_module, root_module['ns3::ByteTagIterator']) @@ -947,7 +1060,24 @@ def register_methods(root_module): register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) register_Ns3CapabilityInformation_methods(root_module, root_module['ns3::CapabilityInformation']) register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) - register_Ns3DcfState_methods(root_module, root_module['ns3::DcfState']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3InterferenceHelperEvent_methods(root_module, root_module['ns3::DefaultDeleter< ns3::InterferenceHelper::Event >']) + register_Ns3DefaultDeleter__Ns3MacRxMiddle_methods(root_module, root_module['ns3::DefaultDeleter< ns3::MacRxMiddle >']) + register_Ns3DefaultDeleter__Ns3MacTxMiddle_methods(root_module, root_module['ns3::DefaultDeleter< ns3::MacTxMiddle >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::DefaultDeleter< ns3::OutputStreamWrapper >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3QosBlockedDestinations_methods(root_module, root_module['ns3::DefaultDeleter< ns3::QosBlockedDestinations >']) + register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumModel >']) + register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumValue >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) + register_Ns3DefaultDeleter__Ns3WifiInformationElement_methods(root_module, root_module['ns3::DefaultDeleter< ns3::WifiInformationElement >']) + register_Ns3DefaultDeleter__Ns3WifiMacQueueItem_methods(root_module, root_module['ns3::DefaultDeleter< ns3::WifiMacQueueItem >']) register_Ns3DeviceEnergyModelContainer_methods(root_module, root_module['ns3::DeviceEnergyModelContainer']) register_Ns3DeviceEnergyModelHelper_methods(root_module, root_module['ns3::DeviceEnergyModelHelper']) register_Ns3DsssErrorRateModel_methods(root_module, root_module['ns3::DsssErrorRateModel']) @@ -965,8 +1095,6 @@ def register_methods(root_module): register_Ns3LogComponent_methods(root_module, root_module['ns3::LogComponent']) register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address']) register_Ns3MacLowTransmissionParameters_methods(root_module, root_module['ns3::MacLowTransmissionParameters']) - register_Ns3MacRxMiddle_methods(root_module, root_module['ns3::MacRxMiddle']) - register_Ns3MacTxMiddle_methods(root_module, root_module['ns3::MacTxMiddle']) register_Ns3McsGroup_methods(root_module, root_module['ns3::McsGroup']) register_Ns3MpduInfo_methods(root_module, root_module['ns3::MpduInfo']) register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer']) @@ -1053,9 +1181,12 @@ def register_methods(root_module): register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3InterferenceHelperEvent_Ns3Empty_Ns3DefaultDeleter__lt__ns3InterferenceHelperEvent__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::InterferenceHelper::Event, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3MacRxMiddle_Ns3Empty_Ns3DefaultDeleter__lt__ns3MacRxMiddle__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::MacRxMiddle, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3MacTxMiddle_Ns3Empty_Ns3DefaultDeleter__lt__ns3MacTxMiddle__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::MacTxMiddle, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter >']) + register_Ns3SimpleRefCount__Ns3QosBlockedDestinations_Ns3Empty_Ns3DefaultDeleter__lt__ns3QosBlockedDestinations__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::QosBlockedDestinations, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3QueueItem__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumModel__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::SpectrumModel, ns3::empty, ns3::DefaultDeleter >']) register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumSignalParameters__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::SpectrumSignalParameters, ns3::empty, ns3::DefaultDeleter >']) @@ -1108,6 +1239,7 @@ def register_methods(root_module): register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor']) register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker']) register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue']) + register_Ns3BlockAckManager_methods(root_module, root_module['ns3::BlockAckManager']) register_Ns3BooleanChecker_methods(root_module, root_module['ns3::BooleanChecker']) register_Ns3BooleanValue_methods(root_module, root_module['ns3::BooleanValue']) register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker']) @@ -1125,6 +1257,7 @@ def register_methods(root_module): register_Ns3DataRateValue_methods(root_module, root_module['ns3::DataRateValue']) register_Ns3DcaTxop_methods(root_module, root_module['ns3::DcaTxop']) register_Ns3DcfManager_methods(root_module, root_module['ns3::DcfManager']) + register_Ns3DcfState_methods(root_module, root_module['ns3::DcfState']) register_Ns3DeterministicRandomVariable_methods(root_module, root_module['ns3::DeterministicRandomVariable']) register_Ns3DeviceEnergyModel_methods(root_module, root_module['ns3::DeviceEnergyModel']) register_Ns3DoubleValue_methods(root_module, root_module['ns3::DoubleValue']) @@ -1153,6 +1286,7 @@ def register_methods(root_module): register_Ns3ExponentialRandomVariable_methods(root_module, root_module['ns3::ExponentialRandomVariable']) register_Ns3ExtendedSupportedRatesIE_methods(root_module, root_module['ns3::ExtendedSupportedRatesIE']) register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel']) + register_Ns3FrameCaptureModel_methods(root_module, root_module['ns3::FrameCaptureModel']) register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel']) register_Ns3GammaRandomVariable_methods(root_module, root_module['ns3::GammaRandomVariable']) register_Ns3HeCapabilities_methods(root_module, root_module['ns3::HeCapabilities']) @@ -1186,6 +1320,8 @@ def register_methods(root_module): register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker']) register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) register_Ns3MacLow_methods(root_module, root_module['ns3::MacLow']) + register_Ns3MacRxMiddle_methods(root_module, root_module['ns3::MacRxMiddle']) + register_Ns3MacTxMiddle_methods(root_module, root_module['ns3::MacTxMiddle']) register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel']) register_Ns3MgtBeaconHeader_methods(root_module, root_module['ns3::MgtBeaconHeader']) register_Ns3MinstrelHtWifiManager_methods(root_module, root_module['ns3::MinstrelHtWifiManager']) @@ -1209,10 +1345,13 @@ def register_methods(root_module): register_Ns3Packet_methods(root_module, root_module['ns3::Packet']) register_Ns3ParetoRandomVariable_methods(root_module, root_module['ns3::ParetoRandomVariable']) register_Ns3ParfWifiManager_methods(root_module, root_module['ns3::ParfWifiManager']) + register_Ns3QosBlockedDestinations_methods(root_module, root_module['ns3::QosBlockedDestinations']) + register_Ns3Queue__Ns3WifiMacQueueItem_methods(root_module, root_module['ns3::Queue< ns3::WifiMacQueueItem >']) register_Ns3QueueItem_methods(root_module, root_module['ns3::QueueItem']) register_Ns3RegularWifiMac_methods(root_module, root_module['ns3::RegularWifiMac']) register_Ns3RraaWifiManager_methods(root_module, root_module['ns3::RraaWifiManager']) register_Ns3RrpaaWifiManager_methods(root_module, root_module['ns3::RrpaaWifiManager']) + register_Ns3SimpleFrameCaptureModel_methods(root_module, root_module['ns3::SimpleFrameCaptureModel']) register_Ns3SpectrumChannel_methods(root_module, root_module['ns3::SpectrumChannel']) register_Ns3SpectrumWifiPhy_methods(root_module, root_module['ns3::SpectrumWifiPhy']) register_Ns3Ssid_methods(root_module, root_module['ns3::Ssid']) @@ -1239,6 +1378,7 @@ def register_methods(root_module): register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker']) register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue']) register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice']) + register_Ns3WifiMacQueue_methods(root_module, root_module['ns3::WifiMacQueue']) register_Ns3WifiRadioEnergyModel_methods(root_module, root_module['ns3::WifiRadioEnergyModel']) register_Ns3YansErrorRateModel_methods(root_module, root_module['ns3::YansErrorRateModel']) register_Ns3YansWifiChannel_methods(root_module, root_module['ns3::YansWifiChannel']) @@ -1246,6 +1386,35 @@ def register_methods(root_module): register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) register_Ns3AdhocWifiMac_methods(root_module, root_module['ns3::AdhocWifiMac']) register_Ns3ApWifiMac_methods(root_module, root_module['ns3::ApWifiMac']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Bool_Unsigned_int_Double_Ns3Time_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, bool, unsigned int, double, ns3::Time, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Const_ns3WifiMacHeader___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, const ns3::WifiMacHeader &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Double_Double_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, double, double, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3DataRate_Ns3DataRate_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::DataRate, ns3::DataRate, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3WifiMode_Ns3WifiPreamble_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3WifiTxVector_Ns3MpduInfo_Ns3SignalNoiseDbm_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3WifiTxVector_Ns3MpduInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3WifiMacQueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3WifiMacHeader___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3WifiTxVector_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Ns3WifiPhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Time, ns3::Time, ns3::WifiPhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Time, ns3::Time, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3QueueDiscItem_methods(root_module, root_module['ns3::QueueDiscItem']) register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation']) register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a']) @@ -1255,15 +1424,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -1326,7 +1495,7 @@ def register_Ns3Address_methods(root_module, cls): def register_Ns3Angles_methods(root_module, cls): cls.add_output_stream_operator() - ## angles.h (module 'antenna'): ns3::Angles::Angles(ns3::Angles const & arg0) [copy constructor] + ## angles.h (module 'antenna'): ns3::Angles::Angles(ns3::Angles const & arg0) [constructor] cls.add_constructor([param('ns3::Angles const &', 'arg0')]) ## angles.h (module 'antenna'): ns3::Angles::Angles() [constructor] cls.add_constructor([]) @@ -1343,50 +1512,50 @@ def register_Ns3Angles_methods(root_module, cls): return def register_Ns3AsciiTraceHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::_Ios_Openmode filemode=std::ios_base::out) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::ios_base::openmode filemode=std::ios_base::out) [member function] cls.add_method('CreateFileStream', 'ns3::Ptr< ns3::OutputStreamWrapper >', - [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode', default_value='std::ios_base::out')]) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + [param('std::string', 'filename'), param('std::ios_base::openmode', 'filemode', default_value='std::ios_base::out')]) + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], @@ -1402,7 +1571,7 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls): return def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice() [constructor] cls.add_constructor([]) @@ -1462,7 +1631,7 @@ def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): return def register_Ns3AthstatsHelper_methods(root_module, cls): - ## athstats-helper.h (module 'wifi'): ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [copy constructor] + ## athstats-helper.h (module 'wifi'): ns3::AthstatsHelper::AthstatsHelper(ns3::AthstatsHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AthstatsHelper const &', 'arg0')]) ## athstats-helper.h (module 'wifi'): ns3::AthstatsHelper::AthstatsHelper() [constructor] cls.add_constructor([]) @@ -1485,25 +1654,25 @@ def register_Ns3AthstatsHelper_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -1513,7 +1682,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -1526,7 +1695,7 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): def register_Ns3BandInfo_methods(root_module, cls): ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo() [constructor] cls.add_constructor([]) - ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [constructor] cls.add_constructor([param('ns3::BandInfo const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::fc [variable] cls.add_instance_attribute('fc', 'double', is_const=False) @@ -1537,11 +1706,11 @@ def register_Ns3BandInfo_methods(root_module, cls): return def register_Ns3Bar_methods(root_module, cls): - ## block-ack-manager.h (module 'wifi'): ns3::Bar::Bar(ns3::Bar const & arg0) [copy constructor] + ## block-ack-manager.h (module 'wifi'): ns3::Bar::Bar(ns3::Bar const & arg0) [constructor] cls.add_constructor([param('ns3::Bar const &', 'arg0')]) ## block-ack-manager.h (module 'wifi'): ns3::Bar::Bar() [constructor] cls.add_constructor([]) - ## block-ack-manager.h (module 'wifi'): ns3::Bar::Bar(ns3::Ptr packet, ns3::Mac48Address recipient, uint8_t tid, bool immediate) [constructor] + ## block-ack-manager.h (module 'wifi'): ns3::Bar::Bar(ns3::Ptr packet, ns3::Mac48Address recipient, uint8_t tid, bool immediate) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('bool', 'immediate')]) ## block-ack-manager.h (module 'wifi'): ns3::Bar::bar [variable] cls.add_instance_attribute('bar', 'ns3::Ptr< ns3::Packet const >', is_const=False) @@ -1554,7 +1723,7 @@ def register_Ns3Bar_methods(root_module, cls): return def register_Ns3BlockAckAgreement_methods(root_module, cls): - ## block-ack-agreement.h (module 'wifi'): ns3::BlockAckAgreement::BlockAckAgreement(ns3::BlockAckAgreement const & arg0) [copy constructor] + ## block-ack-agreement.h (module 'wifi'): ns3::BlockAckAgreement::BlockAckAgreement(ns3::BlockAckAgreement const & arg0) [constructor] cls.add_constructor([param('ns3::BlockAckAgreement const &', 'arg0')]) ## block-ack-agreement.h (module 'wifi'): ns3::BlockAckAgreement::BlockAckAgreement() [constructor] cls.add_constructor([]) @@ -1651,7 +1820,7 @@ def register_Ns3BlockAckAgreement_methods(root_module, cls): def register_Ns3BlockAckCache_methods(root_module, cls): ## block-ack-cache.h (module 'wifi'): ns3::BlockAckCache::BlockAckCache() [constructor] cls.add_constructor([]) - ## block-ack-cache.h (module 'wifi'): ns3::BlockAckCache::BlockAckCache(ns3::BlockAckCache const & arg0) [copy constructor] + ## block-ack-cache.h (module 'wifi'): ns3::BlockAckCache::BlockAckCache(ns3::BlockAckCache const & arg0) [constructor] cls.add_constructor([param('ns3::BlockAckCache const &', 'arg0')]) ## block-ack-cache.h (module 'wifi'): void ns3::BlockAckCache::FillBlockAckBitmap(ns3::CtrlBAckResponseHeader * blockAckHeader) [member function] cls.add_method('FillBlockAckBitmap', @@ -1676,239 +1845,77 @@ def register_Ns3BlockAckCache_methods(root_module, cls): [param('ns3::WifiMacHeader const *', 'hdr')]) return -def register_Ns3BlockAckManager_methods(root_module, cls): - ## block-ack-manager.h (module 'wifi'): ns3::BlockAckManager::BlockAckManager() [constructor] +def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) + ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::AlreadyExists(uint16_t currentSeq, ns3::Mac48Address recipient, uint8_t tid) const [member function] - cls.add_method('AlreadyExists', - 'bool', - [param('uint16_t', 'currentSeq'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], - is_const=True) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::CompleteAmpduExchange(ns3::Mac48Address recipient, uint8_t tid) [member function] - cls.add_method('CompleteAmpduExchange', + ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] + cls.add_constructor([param('uint32_t', 'dataSize')]) + ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] + cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) + ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] + cls.add_method('AddAtEnd', 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::CreateAgreement(ns3::MgtAddBaRequestHeader const * reqHdr, ns3::Mac48Address recipient) [member function] - cls.add_method('CreateAgreement', + [param('uint32_t', 'end')]) + ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] + cls.add_method('AddAtEnd', 'void', - [param('ns3::MgtAddBaRequestHeader const *', 'reqHdr'), param('ns3::Mac48Address', 'recipient')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::DestroyAgreement(ns3::Mac48Address recipient, uint8_t tid) [member function] - cls.add_method('DestroyAgreement', + [param('ns3::Buffer const &', 'o')]) + ## buffer.h (module 'network'): void ns3::Buffer::AddAtStart(uint32_t start) [member function] + cls.add_method('AddAtStart', 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::ExistsAgreement(ns3::Mac48Address recipient, uint8_t tid) const [member function] - cls.add_method('ExistsAgreement', - 'bool', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + [param('uint32_t', 'start')]) + ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] + cls.add_method('Begin', + 'ns3::Buffer::Iterator', + [], is_const=True) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::ExistsAgreementInState(ns3::Mac48Address recipient, uint8_t tid, ns3::OriginatorBlockAckAgreement::State state) const [member function] - cls.add_method('ExistsAgreementInState', - 'bool', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('ns3::OriginatorBlockAckAgreement::State', 'state')], + ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function] + cls.add_method('CopyData', + 'void', + [param('std::ostream *', 'os'), param('uint32_t', 'size')], is_const=True) - ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNBufferedPackets(ns3::Mac48Address recipient, uint8_t tid) const [member function] - cls.add_method('GetNBufferedPackets', + ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function] + cls.add_method('CopyData', 'uint32_t', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], is_const=True) - ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNRetryNeededPackets(ns3::Mac48Address recipient, uint8_t tid) const [member function] - cls.add_method('GetNRetryNeededPackets', - 'uint32_t', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] + cls.add_method('CreateFragment', + 'ns3::Buffer', + [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True) - ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::GetNextPacket(ns3::WifiMacHeader & hdr) [member function] - cls.add_method('GetNextPacket', - 'ns3::Ptr< ns3::Packet const >', - [param('ns3::WifiMacHeader &', 'hdr')]) - ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNextPacketSize() const [member function] - cls.add_method('GetNextPacketSize', + ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function] + cls.add_method('Deserialize', 'uint32_t', + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) + ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function] + cls.add_method('End', + 'ns3::Buffer::Iterator', [], is_const=True) - ## block-ack-manager.h (module 'wifi'): uint16_t ns3::BlockAckManager::GetSeqNumOfNextRetryPacket(ns3::Mac48Address recipient, uint8_t tid) const [member function] - cls.add_method('GetSeqNumOfNextRetryPacket', - 'uint16_t', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSerializedSize() const [member function] + cls.add_method('GetSerializedSize', + 'uint32_t', + [], is_const=True) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasBar(ns3::Bar & bar) [member function] - cls.add_method('HasBar', - 'bool', - [param('ns3::Bar &', 'bar')]) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasOtherFragments(uint16_t sequenceNumber) const [member function] - cls.add_method('HasOtherFragments', - 'bool', - [param('uint16_t', 'sequenceNumber')], + ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSize() const [member function] + cls.add_method('GetSize', + 'uint32_t', + [], is_const=True) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasPackets() const [member function] - cls.add_method('HasPackets', - 'bool', + ## buffer.h (module 'network'): uint8_t const * ns3::Buffer::PeekData() const [member function] + cls.add_method('PeekData', + 'uint8_t const *', [], is_const=True) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::NeedBarRetransmission(uint8_t tid, uint16_t seqNumber, ns3::Mac48Address recipient) [member function] - cls.add_method('NeedBarRetransmission', - 'bool', - [param('uint8_t', 'tid'), param('uint16_t', 'seqNumber'), param('ns3::Mac48Address', 'recipient')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyAgreementEstablished(ns3::Mac48Address recipient, uint8_t tid, uint16_t startingSeq) [member function] - cls.add_method('NotifyAgreementEstablished', - 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'startingSeq')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyAgreementUnsuccessful(ns3::Mac48Address recipient, uint8_t tid) [member function] - cls.add_method('NotifyAgreementUnsuccessful', - 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyGotBlockAck(ns3::CtrlBAckResponseHeader const * blockAck, ns3::Mac48Address recipient, double rxSnr, ns3::WifiMode txMode, double dataSnr) [member function] - cls.add_method('NotifyGotBlockAck', - 'void', - [param('ns3::CtrlBAckResponseHeader const *', 'blockAck'), param('ns3::Mac48Address', 'recipient'), param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode'), param('double', 'dataSnr')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyMpduTransmission(ns3::Mac48Address recipient, uint8_t tid, uint16_t nextSeqNumber, ns3::WifiMacHeader::QosAckPolicy policy) [member function] - cls.add_method('NotifyMpduTransmission', + ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] + cls.add_method('RemoveAtEnd', 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'nextSeqNumber'), param('ns3::WifiMacHeader::QosAckPolicy', 'policy')]) - ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::PeekNextPacket(ns3::WifiMacHeader & hdr) [member function] - cls.add_method('PeekNextPacket', - 'ns3::Ptr< ns3::Packet const >', - [param('ns3::WifiMacHeader &', 'hdr')]) - ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::PeekNextPacketByTidAndAddress(ns3::WifiMacHeader & hdr, ns3::Mac48Address recipient, uint8_t tid, ns3::Time * timestamp) [member function] - cls.add_method('PeekNextPacketByTidAndAddress', - 'ns3::Ptr< ns3::Packet const >', - [param('ns3::WifiMacHeader &', 'hdr'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('ns3::Time *', 'timestamp')]) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::RemovePacket(uint8_t tid, ns3::Mac48Address recipient, uint16_t seqnumber) [member function] - cls.add_method('RemovePacket', - 'bool', - [param('uint8_t', 'tid'), param('ns3::Mac48Address', 'recipient'), param('uint16_t', 'seqnumber')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckInactivityCallback(ns3::Callback callback) [member function] - cls.add_method('SetBlockAckInactivityCallback', - 'void', - [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, bool, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckThreshold(uint8_t nPackets) [member function] - cls.add_method('SetBlockAckThreshold', - 'void', - [param('uint8_t', 'nPackets')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckType(ns3::BlockAckType bAckType) [member function] - cls.add_method('SetBlockAckType', - 'void', - [param('ns3::BlockAckType', 'bAckType')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockDestinationCallback(ns3::Callback callback) [member function] - cls.add_method('SetBlockDestinationCallback', - 'void', - [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetMaxPacketDelay(ns3::Time maxDelay) [member function] - cls.add_method('SetMaxPacketDelay', - 'void', - [param('ns3::Time', 'maxDelay')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetQueue(ns3::Ptr > queue) [member function] - cls.add_method('SetQueue', - 'void', - [param('ns3::Ptr< ns3::WifiQueue< ns3::WifiMacQueueItem > >', 'queue')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxFailedCallback(ns3::Callback callback) [member function] - cls.add_method('SetTxFailedCallback', - 'void', - [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxMiddle(ns3::MacTxMiddle * txMiddle) [member function] - cls.add_method('SetTxMiddle', - 'void', - [param('ns3::MacTxMiddle *', 'txMiddle')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxOkCallback(ns3::Callback callback) [member function] - cls.add_method('SetTxOkCallback', - 'void', - [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetUnblockDestinationCallback(ns3::Callback callback) [member function] - cls.add_method('SetUnblockDestinationCallback', - 'void', - [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetWifiRemoteStationManager(ns3::Ptr manager) [member function] - cls.add_method('SetWifiRemoteStationManager', - 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'manager')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::StorePacket(ns3::Ptr packet, ns3::WifiMacHeader const & hdr, ns3::Time tStamp) [member function] - cls.add_method('StorePacket', - 'void', - [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr'), param('ns3::Time', 'tStamp')]) - ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::SwitchToBlockAckIfNeeded(ns3::Mac48Address recipient, uint8_t tid, uint16_t startingSeq) [member function] - cls.add_method('SwitchToBlockAckIfNeeded', - 'bool', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'startingSeq')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::TearDownBlockAck(ns3::Mac48Address recipient, uint8_t tid) [member function] - cls.add_method('TearDownBlockAck', - 'void', - [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::UpdateAgreement(ns3::MgtAddBaResponseHeader const * respHdr, ns3::Mac48Address recipient) [member function] - cls.add_method('UpdateAgreement', - 'void', - [param('ns3::MgtAddBaResponseHeader const *', 'respHdr'), param('ns3::Mac48Address', 'recipient')]) - return - -def register_Ns3Buffer_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] - cls.add_constructor([]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] - cls.add_constructor([param('uint32_t', 'dataSize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] - cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) - ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] - cls.add_method('AddAtEnd', - 'void', - [param('uint32_t', 'end')]) - ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] - cls.add_method('AddAtEnd', - 'void', - [param('ns3::Buffer const &', 'o')]) - ## buffer.h (module 'network'): void ns3::Buffer::AddAtStart(uint32_t start) [member function] - cls.add_method('AddAtStart', - 'void', - [param('uint32_t', 'start')]) - ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] - cls.add_method('Begin', - 'ns3::Buffer::Iterator', - [], - is_const=True) - ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function] - cls.add_method('CopyData', - 'void', - [param('std::ostream *', 'os'), param('uint32_t', 'size')], - is_const=True) - ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function] - cls.add_method('CopyData', - 'uint32_t', - [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], - is_const=True) - ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] - cls.add_method('CreateFragment', - 'ns3::Buffer', - [param('uint32_t', 'start'), param('uint32_t', 'length')], - is_const=True) - ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function] - cls.add_method('Deserialize', - 'uint32_t', - [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) - ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function] - cls.add_method('End', - 'ns3::Buffer::Iterator', - [], - is_const=True) - ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSerializedSize() const [member function] - cls.add_method('GetSerializedSize', - 'uint32_t', - [], - is_const=True) - ## buffer.h (module 'network'): uint32_t ns3::Buffer::GetSize() const [member function] - cls.add_method('GetSize', - 'uint32_t', - [], - is_const=True) - ## buffer.h (module 'network'): uint8_t const * ns3::Buffer::PeekData() const [member function] - cls.add_method('PeekData', - 'uint8_t const *', - [], - is_const=True) - ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] - cls.add_method('RemoveAtEnd', - 'void', - [param('uint32_t', 'end')]) - ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] - cls.add_method('RemoveAtStart', + [param('uint32_t', 'end')]) + ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] + cls.add_method('RemoveAtStart', 'void', [param('uint32_t', 'start')]) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] @@ -1919,7 +1926,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -2079,7 +2086,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2093,7 +2100,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -2120,7 +2127,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -2154,7 +2161,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -2173,7 +2180,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -2190,7 +2197,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -2205,7 +2212,7 @@ def register_Ns3CallbackBase_methods(root_module, cls): return def register_Ns3CapabilityInformation_methods(root_module, cls): - ## capability-information.h (module 'wifi'): ns3::CapabilityInformation::CapabilityInformation(ns3::CapabilityInformation const & arg0) [copy constructor] + ## capability-information.h (module 'wifi'): ns3::CapabilityInformation::CapabilityInformation(ns3::CapabilityInformation const & arg0) [constructor] cls.add_constructor([param('ns3::CapabilityInformation const &', 'arg0')]) ## capability-information.h (module 'wifi'): ns3::CapabilityInformation::CapabilityInformation() [constructor] cls.add_constructor([]) @@ -2269,7 +2276,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('>=') - ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRate::DataRate() [constructor] cls.add_constructor([]) @@ -2291,7 +2298,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], - deprecated=True, is_const=True) + is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', 'uint64_t', @@ -2299,128 +2306,224 @@ def register_Ns3DataRate_methods(root_module, cls): is_const=True) return -def register_Ns3DcfState_methods(root_module, cls): - ## dcf-state.h (module 'wifi'): ns3::DcfState::DcfState(ns3::DcfState const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DcfState const &', 'arg0')]) - ## dcf-state.h (module 'wifi'): ns3::DcfState::DcfState(ns3::Ptr txop) [constructor] - cls.add_constructor([param('ns3::Ptr< ns3::DcaTxop >', 'txop')]) - ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetAifsn() const [member function] - cls.add_method('GetAifsn', - 'uint32_t', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCw() const [member function] - cls.add_method('GetCw', - 'uint32_t', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCwMax() const [member function] - cls.add_method('GetCwMax', - 'uint32_t', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCwMin() const [member function] - cls.add_method('GetCwMin', - 'uint32_t', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): ns3::Time ns3::DcfState::GetTxopLimit() const [member function] - cls.add_method('GetTxopLimit', - 'ns3::Time', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): bool ns3::DcfState::IsAccessRequested() const [member function] - cls.add_method('IsAccessRequested', - 'bool', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): bool ns3::DcfState::IsEdca() const [member function] - cls.add_method('IsEdca', - 'bool', - [], - is_const=True) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::ResetCw() [member function] - cls.add_method('ResetCw', +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', 'void', - []) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetAifsn(uint32_t aifsn) [member function] - cls.add_method('SetAifsn', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', 'void', - [param('uint32_t', 'aifsn')]) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetCwMax(uint32_t maxCw) [member function] - cls.add_method('SetCwMax', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', 'void', - [param('uint32_t', 'maxCw')]) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetCwMin(uint32_t minCw) [member function] - cls.add_method('SetCwMin', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', 'void', - [param('uint32_t', 'minCw')]) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetTxopLimit(ns3::Time txopLimit) [member function] - cls.add_method('SetTxopLimit', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', 'void', - [param('ns3::Time', 'txopLimit')]) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::StartBackoffNow(uint32_t nSlots) [member function] - cls.add_method('StartBackoffNow', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', 'void', - [param('uint32_t', 'nSlots')]) - ## dcf-state.h (module 'wifi'): void ns3::DcfState::UpdateFailedCw() [member function] - cls.add_method('UpdateFailedCw', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3InterferenceHelperEvent_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::InterferenceHelper::Event > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::InterferenceHelper::Event * object) [member function] + cls.add_method('Delete', 'void', - []) - ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetBackoffSlots() const [member function] - cls.add_method('GetBackoffSlots', - 'uint32_t', - [], - is_const=True, visibility='protected') - ## dcf-state.h (module 'wifi'): ns3::Time ns3::DcfState::GetBackoffStart() const [member function] - cls.add_method('GetBackoffStart', - 'ns3::Time', - [], - is_const=True, visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyAccessGranted() [member function] - cls.add_method('NotifyAccessGranted', + [param('ns3::InterferenceHelper::Event *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3MacRxMiddle_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::MacRxMiddle > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::MacRxMiddle * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyAccessRequested() [member function] - cls.add_method('NotifyAccessRequested', + [param('ns3::MacRxMiddle *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3MacTxMiddle_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::MacTxMiddle > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::MacTxMiddle * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyChannelSwitching() [member function] - cls.add_method('NotifyChannelSwitching', + [param('ns3::MacTxMiddle *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyCollision() [member function] - cls.add_method('NotifyCollision', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::OutputStreamWrapper > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::OutputStreamWrapper * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyInternalCollision() [member function] - cls.add_method('NotifyInternalCollision', + [param('ns3::OutputStreamWrapper *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifySleep() [member function] - cls.add_method('NotifySleep', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3QosBlockedDestinations_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::QosBlockedDestinations > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::QosBlockedDestinations * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyWakeUp() [member function] - cls.add_method('NotifyWakeUp', + [param('ns3::QosBlockedDestinations *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumModel > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumModel * object) [member function] + cls.add_method('Delete', 'void', - [], - visibility='protected') - ## dcf-state.h (module 'wifi'): void ns3::DcfState::UpdateBackoffSlotsNow(uint32_t nSlots, ns3::Time backoffUpdateBound) [member function] - cls.add_method('UpdateBackoffSlotsNow', + [param('ns3::SpectrumModel *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumValue * object) [member function] + cls.add_method('Delete', 'void', - [param('uint32_t', 'nSlots'), param('ns3::Time', 'backoffUpdateBound')], - visibility='protected') + [param('ns3::SpectrumValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3WifiInformationElement_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::WifiInformationElement > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::WifiInformationElement * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::WifiInformationElement *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3WifiMacQueueItem_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::WifiMacQueueItem > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::WifiMacQueueItem * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::WifiMacQueueItem *', 'object')], + is_static=True) return def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): - ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [copy constructor] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelContainer const &', 'arg0')]) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer() [constructor] cls.add_constructor([]) @@ -2442,18 +2545,18 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'modelName')]) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::Begin() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Clear() [member function] cls.add_method('Clear', 'void', []) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::End() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): ns3::Ptr ns3::DeviceEnergyModelContainer::Get(uint32_t i) const [member function] @@ -2471,7 +2574,7 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::DeviceEnergyModelHelper::Install(ns3::Ptr device, ns3::Ptr source) const [member function] cls.add_method('Install', @@ -2498,7 +2601,7 @@ def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): def register_Ns3DsssErrorRateModel_methods(root_module, cls): ## dsss-error-rate-model.h (module 'wifi'): ns3::DsssErrorRateModel::DsssErrorRateModel() [constructor] cls.add_constructor([]) - ## dsss-error-rate-model.h (module 'wifi'): ns3::DsssErrorRateModel::DsssErrorRateModel(ns3::DsssErrorRateModel const & arg0) [copy constructor] + ## dsss-error-rate-model.h (module 'wifi'): ns3::DsssErrorRateModel::DsssErrorRateModel(ns3::DsssErrorRateModel const & arg0) [constructor] cls.add_constructor([param('ns3::DsssErrorRateModel const &', 'arg0')]) ## dsss-error-rate-model.h (module 'wifi'): static double ns3::DsssErrorRateModel::DqpskFunction(double x) [member function] cls.add_method('DqpskFunction', @@ -2530,7 +2633,7 @@ def register_Ns3DsssErrorRateModel_methods(root_module, cls): def register_Ns3EnergySourceHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(ns3::Ptr node) const [member function] cls.add_method('Install', @@ -2565,9 +2668,9 @@ def register_Ns3EnergySourceHelper_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -2612,7 +2715,7 @@ def register_Ns3EventId_methods(root_module, cls): def register_Ns3GroupInfo_methods(root_module, cls): ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::GroupInfo::GroupInfo() [constructor] cls.add_constructor([]) - ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::GroupInfo::GroupInfo(ns3::GroupInfo const & arg0) [copy constructor] + ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::GroupInfo::GroupInfo(ns3::GroupInfo const & arg0) [constructor] cls.add_constructor([param('ns3::GroupInfo const &', 'arg0')]) ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::GroupInfo::m_col [variable] cls.add_instance_attribute('m_col', 'uint8_t', is_const=False) @@ -2631,7 +2734,7 @@ def register_Ns3GroupInfo_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -2662,7 +2765,7 @@ def register_Ns3Hasher_methods(root_module, cls): def register_Ns3HtRateInfo_methods(root_module, cls): ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::HtRateInfo::HtRateInfo() [constructor] cls.add_constructor([]) - ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::HtRateInfo::HtRateInfo(ns3::HtRateInfo const & arg0) [copy constructor] + ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::HtRateInfo::HtRateInfo(ns3::HtRateInfo const & arg0) [constructor] cls.add_constructor([param('ns3::HtRateInfo const &', 'arg0')]) ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::HtRateInfo::adjustedRetryCount [variable] cls.add_instance_attribute('adjustedRetryCount', 'uint32_t', is_const=False) @@ -2701,14 +2804,14 @@ def register_Ns3HtRateInfo_methods(root_module, cls): return def register_Ns3InterferenceHelper_methods(root_module, cls): - ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::InterferenceHelper(ns3::InterferenceHelper const & arg0) [copy constructor] + ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::InterferenceHelper(ns3::InterferenceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::InterferenceHelper const &', 'arg0')]) ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::InterferenceHelper() [constructor] cls.add_constructor([]) - ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(uint32_t size, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] + ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::Add(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::Time duration, double rxPower) [member function] cls.add_method('Add', 'ns3::Ptr< ns3::InterferenceHelper::Event >', - [param('uint32_t', 'size'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) + [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector'), param('ns3::Time', 'duration'), param('double', 'rxPower')]) ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::AddForeignSignal(ns3::Time duration, double rxPower) [member function] cls.add_method('AddForeignSignal', 'void', @@ -2725,10 +2828,11 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_method('EraseEvents', 'void', []) - ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) [member function] + ## interference-helper.h (module 'wifi'): ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) const [member function] cls.add_method('GetEnergyDuration', 'ns3::Time', - [param('double', 'energyW')]) + [param('double', 'energyW')], + is_const=True) ## interference-helper.h (module 'wifi'): ns3::Ptr ns3::InterferenceHelper::GetErrorRateModel() const [member function] cls.add_method('GetErrorRateModel', 'ns3::Ptr< ns3::ErrorRateModel >', @@ -2747,10 +2851,10 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): cls.add_method('NotifyRxStart', 'void', []) - ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::SetErrorRateModel(ns3::Ptr rate) [member function] + ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::SetErrorRateModel(ns3::Ptr const rate) [member function] cls.add_method('SetErrorRateModel', 'void', - [param('ns3::Ptr< ns3::ErrorRateModel >', 'rate')]) + [param('ns3::Ptr< ns3::ErrorRateModel > const', 'rate')]) ## interference-helper.h (module 'wifi'): void ns3::InterferenceHelper::SetNoiseFigure(double value) [member function] cls.add_method('SetNoiseFigure', 'void', @@ -2764,7 +2868,7 @@ def register_Ns3InterferenceHelper_methods(root_module, cls): def register_Ns3InterferenceHelperSnrPer_methods(root_module, cls): ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::SnrPer::SnrPer() [constructor] cls.add_constructor([]) - ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::SnrPer::SnrPer(ns3::InterferenceHelper::SnrPer const & arg0) [copy constructor] + ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::SnrPer::SnrPer(ns3::InterferenceHelper::SnrPer const & arg0) [constructor] cls.add_constructor([param('ns3::InterferenceHelper::SnrPer const &', 'arg0')]) ## interference-helper.h (module 'wifi'): ns3::InterferenceHelper::SnrPer::per [variable] cls.add_instance_attribute('per', 'double', is_const=False) @@ -2773,11 +2877,11 @@ def register_Ns3InterferenceHelperSnrPer_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -2891,10 +2995,10 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -2954,17 +3058,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -3031,7 +3135,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -3153,9 +3257,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -3164,7 +3268,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -3211,10 +3315,10 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -3228,9 +3332,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -3260,11 +3364,11 @@ def register_Ns3LogComponent_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -3333,7 +3437,7 @@ def register_Ns3Mac48Address_methods(root_module, cls): def register_Ns3MacLowTransmissionParameters_methods(root_module, cls): cls.add_output_stream_operator() - ## mac-low.h (module 'wifi'): ns3::MacLowTransmissionParameters::MacLowTransmissionParameters(ns3::MacLowTransmissionParameters const & arg0) [copy constructor] + ## mac-low.h (module 'wifi'): ns3::MacLowTransmissionParameters::MacLowTransmissionParameters(ns3::MacLowTransmissionParameters const & arg0) [constructor] cls.add_constructor([param('ns3::MacLowTransmissionParameters const &', 'arg0')]) ## mac-low.h (module 'wifi'): ns3::MacLowTransmissionParameters::MacLowTransmissionParameters() [constructor] cls.add_constructor([]) @@ -3451,45 +3555,10 @@ def register_Ns3MacLowTransmissionParameters_methods(root_module, cls): is_const=True) return -def register_Ns3MacRxMiddle_methods(root_module, cls): - ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle::MacRxMiddle(ns3::MacRxMiddle const & arg0) [copy constructor] - cls.add_constructor([param('ns3::MacRxMiddle const &', 'arg0')]) - ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle::MacRxMiddle() [constructor] - cls.add_constructor([]) - ## mac-rx-middle.h (module 'wifi'): void ns3::MacRxMiddle::Receive(ns3::Ptr packet, ns3::WifiMacHeader const * hdr) [member function] - cls.add_method('Receive', - 'void', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr')]) - ## mac-rx-middle.h (module 'wifi'): void ns3::MacRxMiddle::SetForwardCallback(ns3::Callback, ns3::WifiMacHeader const*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] - cls.add_method('SetForwardCallback', - 'void', - [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::WifiMacHeader const *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - return - -def register_Ns3MacTxMiddle_methods(root_module, cls): - ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle::MacTxMiddle(ns3::MacTxMiddle const & arg0) [copy constructor] - cls.add_constructor([param('ns3::MacTxMiddle const &', 'arg0')]) - ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle::MacTxMiddle() [constructor] - cls.add_constructor([]) - ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::GetNextSeqNumberByTidAndAddress(uint8_t tid, ns3::Mac48Address addr) const [member function] - cls.add_method('GetNextSeqNumberByTidAndAddress', - 'uint16_t', - [param('uint8_t', 'tid'), param('ns3::Mac48Address', 'addr')], - is_const=True) - ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::GetNextSequenceNumberFor(ns3::WifiMacHeader const * hdr) [member function] - cls.add_method('GetNextSequenceNumberFor', - 'uint16_t', - [param('ns3::WifiMacHeader const *', 'hdr')]) - ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::PeekNextSequenceNumberFor(ns3::WifiMacHeader const * hdr) [member function] - cls.add_method('PeekNextSequenceNumberFor', - 'uint16_t', - [param('ns3::WifiMacHeader const *', 'hdr')]) - return - def register_Ns3McsGroup_methods(root_module, cls): ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::McsGroup::McsGroup() [constructor] cls.add_constructor([]) - ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::McsGroup::McsGroup(ns3::McsGroup const & arg0) [copy constructor] + ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::McsGroup::McsGroup(ns3::McsGroup const & arg0) [constructor] cls.add_constructor([param('ns3::McsGroup const &', 'arg0')]) ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::McsGroup::chWidth [variable] cls.add_instance_attribute('chWidth', 'uint8_t', is_const=False) @@ -3510,7 +3579,7 @@ def register_Ns3McsGroup_methods(root_module, cls): def register_Ns3MpduInfo_methods(root_module, cls): ## wifi-phy.h (module 'wifi'): ns3::MpduInfo::MpduInfo() [constructor] cls.add_constructor([]) - ## wifi-phy.h (module 'wifi'): ns3::MpduInfo::MpduInfo(ns3::MpduInfo const & arg0) [copy constructor] + ## wifi-phy.h (module 'wifi'): ns3::MpduInfo::MpduInfo(ns3::MpduInfo const & arg0) [constructor] cls.add_constructor([param('ns3::MpduInfo const &', 'arg0')]) ## wifi-phy.h (module 'wifi'): ns3::MpduInfo::mpduRefNumber [variable] cls.add_instance_attribute('mpduRefNumber', 'uint64_t', is_const=False) @@ -3519,7 +3588,7 @@ def register_Ns3MpduInfo_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -3541,14 +3610,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -3564,7 +3633,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -3592,9 +3661,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -3605,9 +3674,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -3630,7 +3699,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -3691,7 +3760,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -3702,7 +3771,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -3737,7 +3806,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): return def register_Ns3OriginatorBlockAckAgreement_methods(root_module, cls): - ## originator-block-ack-agreement.h (module 'wifi'): ns3::OriginatorBlockAckAgreement::OriginatorBlockAckAgreement(ns3::OriginatorBlockAckAgreement const & arg0) [copy constructor] + ## originator-block-ack-agreement.h (module 'wifi'): ns3::OriginatorBlockAckAgreement::OriginatorBlockAckAgreement(ns3::OriginatorBlockAckAgreement const & arg0) [constructor] cls.add_constructor([param('ns3::OriginatorBlockAckAgreement const &', 'arg0')]) ## originator-block-ack-agreement.h (module 'wifi'): ns3::OriginatorBlockAckAgreement::OriginatorBlockAckAgreement() [constructor] cls.add_constructor([]) @@ -3785,7 +3854,7 @@ def register_Ns3OriginatorBlockAckAgreement_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -3863,7 +3932,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -3877,10 +3946,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -3896,7 +3967,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -3910,7 +3981,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -3927,7 +3998,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -3961,7 +4032,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -3976,7 +4047,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -4048,10 +4119,10 @@ def register_Ns3PcapFile_methods(root_module, cls): cls.add_method('IsNanoSecMode', 'bool', []) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', - [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) + [param('std::string const &', 'filename'), param('std::ios_base::openmode', 'mode')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function] cls.add_method('Read', 'void', @@ -4060,11 +4131,11 @@ def register_Ns3PcapFile_methods(root_module, cls): cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) @@ -4075,14 +4146,14 @@ def register_Ns3PcapFile_methods(root_module, cls): return def register_Ns3PcapHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::_Ios_Openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::ios_base::openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] cls.add_method('CreateFile', 'ns3::Ptr< ns3::PcapFileWrapper >', - [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='0')]) + [param('std::string', 'filename'), param('std::ios_base::openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='0')]) ## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr device, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromDevice', 'std::string', @@ -4094,7 +4165,7 @@ def register_Ns3PcapHelper_methods(root_module, cls): return def register_Ns3PcapHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice() [constructor] cls.add_constructor([]) @@ -4130,15 +4201,15 @@ def register_Ns3PcapHelperForDevice_methods(root_module, cls): return def register_Ns3PropagationCache__Ns3JakesProcess_methods(root_module, cls): - ## propagation-cache.h (module 'propagation'): ns3::PropagationCache::PropagationCache(ns3::PropagationCache const & arg0) [copy constructor] + ## propagation-cache.h (module 'propagation'): ns3::PropagationCache::PropagationCache(ns3::PropagationCache const & arg0) [constructor] cls.add_constructor([param('ns3::PropagationCache< ns3::JakesProcess > const &', 'arg0')]) ## propagation-cache.h (module 'propagation'): ns3::PropagationCache::PropagationCache() [constructor] cls.add_constructor([]) - ## propagation-cache.h (module 'propagation'): void ns3::PropagationCache::AddPathData(ns3::Ptr data, ns3::Ptr a, ns3::Ptr b, uint32_t modelUid) [member function] + ## propagation-cache.h (module 'propagation'): void ns3::PropagationCache::AddPathData(ns3::Ptr data, ns3::Ptr a, ns3::Ptr b, uint32_t modelUid) [member function] cls.add_method('AddPathData', 'void', [param('ns3::Ptr< ns3::JakesProcess >', 'data'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b'), param('uint32_t', 'modelUid')]) - ## propagation-cache.h (module 'propagation'): ns3::Ptr ns3::PropagationCache::GetPathData(ns3::Ptr a, ns3::Ptr b, uint32_t modelUid) [member function] + ## propagation-cache.h (module 'propagation'): ns3::Ptr ns3::PropagationCache::GetPathData(ns3::Ptr a, ns3::Ptr b, uint32_t modelUid) [member function] cls.add_method('GetPathData', 'ns3::Ptr< ns3::JakesProcess >', [param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b'), param('uint32_t', 'modelUid')]) @@ -4147,7 +4218,7 @@ def register_Ns3PropagationCache__Ns3JakesProcess_methods(root_module, cls): def register_Ns3RateInfo_methods(root_module, cls): ## minstrel-wifi-manager.h (module 'wifi'): ns3::RateInfo::RateInfo() [constructor] cls.add_constructor([]) - ## minstrel-wifi-manager.h (module 'wifi'): ns3::RateInfo::RateInfo(ns3::RateInfo const & arg0) [copy constructor] + ## minstrel-wifi-manager.h (module 'wifi'): ns3::RateInfo::RateInfo(ns3::RateInfo const & arg0) [constructor] cls.add_constructor([param('ns3::RateInfo const &', 'arg0')]) ## minstrel-wifi-manager.h (module 'wifi'): ns3::RateInfo::adjustedRetryCount [variable] cls.add_instance_attribute('adjustedRetryCount', 'uint32_t', is_const=False) @@ -4182,7 +4253,7 @@ def register_Ns3RateInfo_methods(root_module, cls): def register_Ns3SignalNoiseDbm_methods(root_module, cls): ## wifi-phy.h (module 'wifi'): ns3::SignalNoiseDbm::SignalNoiseDbm() [constructor] cls.add_constructor([]) - ## wifi-phy.h (module 'wifi'): ns3::SignalNoiseDbm::SignalNoiseDbm(ns3::SignalNoiseDbm const & arg0) [copy constructor] + ## wifi-phy.h (module 'wifi'): ns3::SignalNoiseDbm::SignalNoiseDbm(ns3::SignalNoiseDbm const & arg0) [constructor] cls.add_constructor([param('ns3::SignalNoiseDbm const &', 'arg0')]) ## wifi-phy.h (module 'wifi'): ns3::SignalNoiseDbm::noise [variable] cls.add_instance_attribute('noise', 'double', is_const=False) @@ -4193,7 +4264,7 @@ def register_Ns3SignalNoiseDbm_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -4203,7 +4274,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -4284,7 +4355,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3StatusCode_methods(root_module, cls): cls.add_output_stream_operator() - ## status-code.h (module 'wifi'): ns3::StatusCode::StatusCode(ns3::StatusCode const & arg0) [copy constructor] + ## status-code.h (module 'wifi'): ns3::StatusCode::StatusCode(ns3::StatusCode const & arg0) [constructor] cls.add_constructor([param('ns3::StatusCode const &', 'arg0')]) ## status-code.h (module 'wifi'): ns3::StatusCode::StatusCode() [constructor] cls.add_constructor([]) @@ -4320,7 +4391,7 @@ def register_Ns3StatusCode_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -4350,7 +4421,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -4394,14 +4465,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -4414,7 +4485,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -4423,11 +4494,15 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TracedValue__Double_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< double > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(double const & v) [constructor] cls.add_constructor([param('double const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4435,7 +4510,7 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4457,11 +4532,15 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(unsigned int const & v) [constructor] cls.add_constructor([param('unsigned int const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4469,7 +4548,7 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4491,11 +4570,15 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): def register_Ns3TracedValue__Unsigned_long_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< unsigned long > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(long unsigned int const & v) [constructor] cls.add_constructor([param('long unsigned int const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned long > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned long > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4503,7 +4586,7 @@ def register_Ns3TracedValue__Unsigned_long_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -4523,33 +4606,32 @@ def register_Ns3TracedValue__Unsigned_long_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -4565,7 +4647,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -4575,9 +4657,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -4644,12 +4726,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -4659,12 +4741,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -4674,7 +4756,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -4690,7 +4772,7 @@ def register_Ns3TypeId_methods(root_module, cls): cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::QueueBase']) + template_parameters=[u'ns3::QueueBase']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', @@ -4704,13 +4786,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -4729,7 +4810,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -4746,14 +4827,21 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -4761,14 +4849,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -4778,7 +4873,7 @@ def register_Ns3Vector3D_methods(root_module, cls): return def register_Ns3WifiHelper_methods(root_module, cls): - ## wifi-helper.h (module 'wifi'): ns3::WifiHelper::WifiHelper(ns3::WifiHelper const & arg0) [copy constructor] + ## wifi-helper.h (module 'wifi'): ns3::WifiHelper::WifiHelper(ns3::WifiHelper const & arg0) [constructor] cls.add_constructor([param('ns3::WifiHelper const &', 'arg0')]) ## wifi-helper.h (module 'wifi'): ns3::WifiHelper::WifiHelper() [constructor] cls.add_constructor([]) @@ -4790,12 +4885,17 @@ def register_Ns3WifiHelper_methods(root_module, cls): cls.add_method('Default', 'ns3::WifiHelper', [], - is_static=True, deprecated=True) + is_static=True) ## wifi-helper.h (module 'wifi'): static void ns3::WifiHelper::EnableLogComponents() [member function] cls.add_method('EnableLogComponents', 'void', [], is_static=True) + ## wifi-helper.h (module 'wifi'): ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::WifiPhyHelper const & phy, ns3::WifiMacHelper const & mac, ns3::NodeContainer::Iterator first, ns3::NodeContainer::Iterator last) const [member function] + cls.add_method('Install', + 'ns3::NetDeviceContainer', + [param('ns3::WifiPhyHelper const &', 'phy'), param('ns3::WifiMacHelper const &', 'mac'), param('std::vector< ns3::Ptr< ns3::Node > > const_iterator', 'first'), param('std::vector< ns3::Ptr< ns3::Node > > const_iterator', 'last')], + is_const=True, is_virtual=True) ## wifi-helper.h (module 'wifi'): ns3::NetDeviceContainer ns3::WifiHelper::Install(ns3::WifiPhyHelper const & phy, ns3::WifiMacHelper const & mac, ns3::NodeContainer c) const [member function] cls.add_method('Install', 'ns3::NetDeviceContainer', @@ -4823,7 +4923,7 @@ def register_Ns3WifiHelper_methods(root_module, cls): return def register_Ns3WifiMacHelper_methods(root_module, cls): - ## wifi-mac-helper.h (module 'wifi'): ns3::WifiMacHelper::WifiMacHelper(ns3::WifiMacHelper const & arg0) [copy constructor] + ## wifi-mac-helper.h (module 'wifi'): ns3::WifiMacHelper::WifiMacHelper(ns3::WifiMacHelper const & arg0) [constructor] cls.add_constructor([param('ns3::WifiMacHelper const &', 'arg0')]) ## wifi-mac-helper.h (module 'wifi'): ns3::WifiMacHelper::WifiMacHelper() [constructor] cls.add_constructor([]) @@ -4840,9 +4940,9 @@ def register_Ns3WifiMacHelper_methods(root_module, cls): return def register_Ns3WifiMode_methods(root_module, cls): - cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## wifi-mode.h (module 'wifi'): ns3::WifiMode::WifiMode(ns3::WifiMode const & arg0) [copy constructor] + cls.add_output_stream_operator() + ## wifi-mode.h (module 'wifi'): ns3::WifiMode::WifiMode(ns3::WifiMode const & arg0) [constructor] cls.add_constructor([param('ns3::WifiMode const &', 'arg0')]) ## wifi-mode.h (module 'wifi'): ns3::WifiMode::WifiMode() [constructor] cls.add_constructor([]) @@ -4931,7 +5031,7 @@ def register_Ns3WifiMode_methods(root_module, cls): return def register_Ns3WifiModeFactory_methods(root_module, cls): - ## wifi-mode.h (module 'wifi'): ns3::WifiModeFactory::WifiModeFactory(ns3::WifiModeFactory const & arg0) [copy constructor] + ## wifi-mode.h (module 'wifi'): ns3::WifiModeFactory::WifiModeFactory(ns3::WifiModeFactory const & arg0) [constructor] cls.add_constructor([param('ns3::WifiModeFactory const &', 'arg0')]) ## wifi-mode.h (module 'wifi'): static ns3::WifiMode ns3::WifiModeFactory::CreateWifiMcs(std::string uniqueName, uint8_t mcsValue, ns3::WifiModulationClass modClass) [member function] cls.add_method('CreateWifiMcs', @@ -4946,7 +5046,7 @@ def register_Ns3WifiModeFactory_methods(root_module, cls): return def register_Ns3WifiPhyHelper_methods(root_module, cls): - ## wifi-helper.h (module 'wifi'): ns3::WifiPhyHelper::WifiPhyHelper(ns3::WifiPhyHelper const & arg0) [copy constructor] + ## wifi-helper.h (module 'wifi'): ns3::WifiPhyHelper::WifiPhyHelper(ns3::WifiPhyHelper const & arg0) [constructor] cls.add_constructor([param('ns3::WifiPhyHelper const &', 'arg0')]) ## wifi-helper.h (module 'wifi'): ns3::WifiPhyHelper::WifiPhyHelper() [constructor] cls.add_constructor([]) @@ -4972,12 +5072,12 @@ def register_Ns3WifiPhyHelper_methods(root_module, cls): cls.add_method('SetPcapDataLinkType', 'void', [param('ns3::WifiPhyHelper::SupportedPcapDataLinkTypes', 'dlt')]) - ## wifi-helper.h (module 'wifi'): static void ns3::WifiPhyHelper::PcapSniffRxEvent(ns3::Ptr file, ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu, ns3::SignalNoiseDbm signalNoise) [member function] + ## wifi-helper.h (module 'wifi'): static void ns3::WifiPhyHelper::PcapSniffRxEvent(ns3::Ptr file, ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu, ns3::SignalNoiseDbm signalNoise) [member function] cls.add_method('PcapSniffRxEvent', 'void', [param('ns3::Ptr< ns3::PcapFileWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduInfo', 'aMpdu'), param('ns3::SignalNoiseDbm', 'signalNoise')], is_static=True, visibility='protected') - ## wifi-helper.h (module 'wifi'): static void ns3::WifiPhyHelper::PcapSniffTxEvent(ns3::Ptr file, ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu) [member function] + ## wifi-helper.h (module 'wifi'): static void ns3::WifiPhyHelper::PcapSniffTxEvent(ns3::Ptr file, ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu) [member function] cls.add_method('PcapSniffTxEvent', 'void', [param('ns3::Ptr< ns3::PcapFileWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduInfo', 'aMpdu')], @@ -4997,7 +5097,7 @@ def register_Ns3WifiPhyHelper_methods(root_module, cls): def register_Ns3WifiPhyListener_methods(root_module, cls): ## wifi-phy.h (module 'wifi'): ns3::WifiPhyListener::WifiPhyListener() [constructor] cls.add_constructor([]) - ## wifi-phy.h (module 'wifi'): ns3::WifiPhyListener::WifiPhyListener(ns3::WifiPhyListener const & arg0) [copy constructor] + ## wifi-phy.h (module 'wifi'): ns3::WifiPhyListener::WifiPhyListener(ns3::WifiPhyListener const & arg0) [constructor] cls.add_constructor([param('ns3::WifiPhyListener const &', 'arg0')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhyListener::NotifyMaybeCcaBusyStart(ns3::Time duration) [member function] cls.add_method('NotifyMaybeCcaBusyStart', @@ -5042,7 +5142,7 @@ def register_Ns3WifiPhyListener_methods(root_module, cls): return def register_Ns3WifiPhyTag_methods(root_module, cls): - ## wifi-phy-tag.h (module 'wifi'): ns3::WifiPhyTag::WifiPhyTag(ns3::WifiPhyTag const & arg0) [copy constructor] + ## wifi-phy-tag.h (module 'wifi'): ns3::WifiPhyTag::WifiPhyTag(ns3::WifiPhyTag const & arg0) [constructor] cls.add_constructor([param('ns3::WifiPhyTag const &', 'arg0')]) ## wifi-phy-tag.h (module 'wifi'): ns3::WifiPhyTag::WifiPhyTag() [constructor] cls.add_constructor([]) @@ -5091,7 +5191,7 @@ def register_Ns3WifiPhyTag_methods(root_module, cls): return def register_Ns3WifiRadioEnergyModelHelper_methods(root_module, cls): - ## wifi-radio-energy-model-helper.h (module 'wifi'): ns3::WifiRadioEnergyModelHelper::WifiRadioEnergyModelHelper(ns3::WifiRadioEnergyModelHelper const & arg0) [copy constructor] + ## wifi-radio-energy-model-helper.h (module 'wifi'): ns3::WifiRadioEnergyModelHelper::WifiRadioEnergyModelHelper(ns3::WifiRadioEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRadioEnergyModelHelper const &', 'arg0')]) ## wifi-radio-energy-model-helper.h (module 'wifi'): ns3::WifiRadioEnergyModelHelper::WifiRadioEnergyModelHelper() [constructor] cls.add_constructor([]) @@ -5100,11 +5200,11 @@ def register_Ns3WifiRadioEnergyModelHelper_methods(root_module, cls): 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], is_virtual=True) - ## wifi-radio-energy-model-helper.h (module 'wifi'): void ns3::WifiRadioEnergyModelHelper::SetDepletionCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model-helper.h (module 'wifi'): void ns3::WifiRadioEnergyModelHelper::SetDepletionCallback(ns3::WifiRadioEnergyModel::WifiRadioEnergyDepletionCallback callback) [member function] cls.add_method('SetDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-radio-energy-model-helper.h (module 'wifi'): void ns3::WifiRadioEnergyModelHelper::SetRechargedCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model-helper.h (module 'wifi'): void ns3::WifiRadioEnergyModelHelper::SetRechargedCallback(ns3::WifiRadioEnergyModel::WifiRadioEnergyRechargedCallback callback) [member function] cls.add_method('SetRechargedCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -5120,7 +5220,7 @@ def register_Ns3WifiRadioEnergyModelHelper_methods(root_module, cls): return def register_Ns3WifiRadioEnergyModelPhyListener_methods(root_module, cls): - ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModelPhyListener::WifiRadioEnergyModelPhyListener(ns3::WifiRadioEnergyModelPhyListener const & arg0) [copy constructor] + ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModelPhyListener::WifiRadioEnergyModelPhyListener(ns3::WifiRadioEnergyModelPhyListener const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRadioEnergyModelPhyListener const &', 'arg0')]) ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModelPhyListener::WifiRadioEnergyModelPhyListener() [constructor] cls.add_constructor([]) @@ -5164,11 +5264,11 @@ def register_Ns3WifiRadioEnergyModelPhyListener_methods(root_module, cls): 'void', [], is_virtual=True) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModelPhyListener::SetChangeStateCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModelPhyListener::SetChangeStateCallback(ns3::DeviceEnergyModel::ChangeStateCallback callback) [member function] cls.add_method('SetChangeStateCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModelPhyListener::SetUpdateTxCurrentCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModelPhyListener::SetUpdateTxCurrentCallback(ns3::WifiRadioEnergyModelPhyListener::UpdateTxCurrentCallback callback) [member function] cls.add_method('SetUpdateTxCurrentCallback', 'void', [param('ns3::Callback< void, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -5177,7 +5277,7 @@ def register_Ns3WifiRadioEnergyModelPhyListener_methods(root_module, cls): def register_Ns3WifiRemoteStation_methods(root_module, cls): ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStation::WifiRemoteStation() [constructor] cls.add_constructor([]) - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStation::WifiRemoteStation(ns3::WifiRemoteStation const & arg0) [copy constructor] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStation::WifiRemoteStation(ns3::WifiRemoteStation const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRemoteStation const &', 'arg0')]) ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStation::m_slrc [variable] cls.add_instance_attribute('m_slrc', 'uint32_t', is_const=False) @@ -5190,7 +5290,7 @@ def register_Ns3WifiRemoteStation_methods(root_module, cls): return def register_Ns3WifiRemoteStationInfo_methods(root_module, cls): - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationInfo::WifiRemoteStationInfo(ns3::WifiRemoteStationInfo const & arg0) [copy constructor] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationInfo::WifiRemoteStationInfo(ns3::WifiRemoteStationInfo const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRemoteStationInfo const &', 'arg0')]) ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationInfo::WifiRemoteStationInfo() [constructor] cls.add_constructor([]) @@ -5212,7 +5312,7 @@ def register_Ns3WifiRemoteStationInfo_methods(root_module, cls): def register_Ns3WifiRemoteStationState_methods(root_module, cls): ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationState::WifiRemoteStationState() [constructor] cls.add_constructor([]) - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationState::WifiRemoteStationState(ns3::WifiRemoteStationState const & arg0) [copy constructor] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationState::WifiRemoteStationState(ns3::WifiRemoteStationState const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRemoteStationState const &', 'arg0')]) ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationState::m_address [variable] cls.add_instance_attribute('m_address', 'ns3::Mac48Address', is_const=False) @@ -5255,7 +5355,7 @@ def register_Ns3WifiRemoteStationState_methods(root_module, cls): def register_Ns3WifiRraaThresholds_methods(root_module, cls): ## rraa-wifi-manager.h (module 'wifi'): ns3::WifiRraaThresholds::WifiRraaThresholds() [constructor] cls.add_constructor([]) - ## rraa-wifi-manager.h (module 'wifi'): ns3::WifiRraaThresholds::WifiRraaThresholds(ns3::WifiRraaThresholds const & arg0) [copy constructor] + ## rraa-wifi-manager.h (module 'wifi'): ns3::WifiRraaThresholds::WifiRraaThresholds(ns3::WifiRraaThresholds const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRraaThresholds const &', 'arg0')]) ## rraa-wifi-manager.h (module 'wifi'): ns3::WifiRraaThresholds::m_ewnd [variable] cls.add_instance_attribute('m_ewnd', 'uint32_t', is_const=False) @@ -5268,7 +5368,7 @@ def register_Ns3WifiRraaThresholds_methods(root_module, cls): def register_Ns3WifiRrpaaThresholds_methods(root_module, cls): ## rrpaa-wifi-manager.h (module 'wifi'): ns3::WifiRrpaaThresholds::WifiRrpaaThresholds() [constructor] cls.add_constructor([]) - ## rrpaa-wifi-manager.h (module 'wifi'): ns3::WifiRrpaaThresholds::WifiRrpaaThresholds(ns3::WifiRrpaaThresholds const & arg0) [copy constructor] + ## rrpaa-wifi-manager.h (module 'wifi'): ns3::WifiRrpaaThresholds::WifiRrpaaThresholds(ns3::WifiRrpaaThresholds const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRrpaaThresholds const &', 'arg0')]) ## rrpaa-wifi-manager.h (module 'wifi'): ns3::WifiRrpaaThresholds::m_ewnd [variable] cls.add_instance_attribute('m_ewnd', 'uint32_t', is_const=False) @@ -5280,7 +5380,7 @@ def register_Ns3WifiRrpaaThresholds_methods(root_module, cls): def register_Ns3WifiTxVector_methods(root_module, cls): cls.add_output_stream_operator() - ## wifi-tx-vector.h (module 'wifi'): ns3::WifiTxVector::WifiTxVector(ns3::WifiTxVector const & arg0) [copy constructor] + ## wifi-tx-vector.h (module 'wifi'): ns3::WifiTxVector::WifiTxVector(ns3::WifiTxVector const & arg0) [constructor] cls.add_constructor([param('ns3::WifiTxVector const &', 'arg0')]) ## wifi-tx-vector.h (module 'wifi'): ns3::WifiTxVector::WifiTxVector() [constructor] cls.add_constructor([]) @@ -5388,7 +5488,7 @@ def register_Ns3WifiTxVector_methods(root_module, cls): return def register_Ns3YansWifiChannelHelper_methods(root_module, cls): - ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiChannelHelper::YansWifiChannelHelper(ns3::YansWifiChannelHelper const & arg0) [copy constructor] + ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiChannelHelper::YansWifiChannelHelper(ns3::YansWifiChannelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::YansWifiChannelHelper const &', 'arg0')]) ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiChannelHelper::YansWifiChannelHelper() [constructor] cls.add_constructor([]) @@ -5417,7 +5517,7 @@ def register_Ns3YansWifiChannelHelper_methods(root_module, cls): return def register_Ns3YansWifiPhyHelper_methods(root_module, cls): - ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiPhyHelper::YansWifiPhyHelper(ns3::YansWifiPhyHelper const & arg0) [copy constructor] + ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiPhyHelper::YansWifiPhyHelper(ns3::YansWifiPhyHelper const & arg0) [constructor] cls.add_constructor([param('ns3::YansWifiPhyHelper const &', 'arg0')]) ## yans-wifi-helper.h (module 'wifi'): ns3::YansWifiPhyHelper::YansWifiPhyHelper() [constructor] cls.add_constructor([]) @@ -5444,79 +5544,79 @@ def register_Ns3YansWifiPhyHelper_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3AmpduTag_methods(root_module, cls): - ## ampdu-tag.h (module 'wifi'): ns3::AmpduTag::AmpduTag(ns3::AmpduTag const & arg0) [copy constructor] + ## ampdu-tag.h (module 'wifi'): ns3::AmpduTag::AmpduTag(ns3::AmpduTag const & arg0) [constructor] cls.add_constructor([param('ns3::AmpduTag const &', 'arg0')]) ## ampdu-tag.h (module 'wifi'): ns3::AmpduTag::AmpduTag() [constructor] cls.add_constructor([]) @@ -5582,7 +5682,7 @@ def register_Ns3AmpduTag_methods(root_module, cls): def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -5605,7 +5705,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -5635,7 +5735,7 @@ def register_Ns3Header_methods(root_module, cls): return def register_Ns3MgtAddBaRequestHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaRequestHeader::MgtAddBaRequestHeader(ns3::MgtAddBaRequestHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaRequestHeader::MgtAddBaRequestHeader(ns3::MgtAddBaRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtAddBaRequestHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaRequestHeader::MgtAddBaRequestHeader() [constructor] cls.add_constructor([]) @@ -5730,7 +5830,7 @@ def register_Ns3MgtAddBaRequestHeader_methods(root_module, cls): return def register_Ns3MgtAddBaResponseHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaResponseHeader::MgtAddBaResponseHeader(ns3::MgtAddBaResponseHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaResponseHeader::MgtAddBaResponseHeader(ns3::MgtAddBaResponseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtAddBaResponseHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtAddBaResponseHeader::MgtAddBaResponseHeader() [constructor] cls.add_constructor([]) @@ -5825,7 +5925,7 @@ def register_Ns3MgtAddBaResponseHeader_methods(root_module, cls): return def register_Ns3MgtAssocRequestHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtAssocRequestHeader::MgtAssocRequestHeader(ns3::MgtAssocRequestHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtAssocRequestHeader::MgtAssocRequestHeader(ns3::MgtAssocRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtAssocRequestHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtAssocRequestHeader::MgtAssocRequestHeader() [constructor] cls.add_constructor([]) @@ -5925,7 +6025,7 @@ def register_Ns3MgtAssocRequestHeader_methods(root_module, cls): return def register_Ns3MgtAssocResponseHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtAssocResponseHeader::MgtAssocResponseHeader(ns3::MgtAssocResponseHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtAssocResponseHeader::MgtAssocResponseHeader(ns3::MgtAssocResponseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtAssocResponseHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtAssocResponseHeader::MgtAssocResponseHeader() [constructor] cls.add_constructor([]) @@ -6050,7 +6150,7 @@ def register_Ns3MgtAssocResponseHeader_methods(root_module, cls): return def register_Ns3MgtDelBaHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtDelBaHeader::MgtDelBaHeader(ns3::MgtDelBaHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtDelBaHeader::MgtDelBaHeader(ns3::MgtDelBaHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtDelBaHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtDelBaHeader::MgtDelBaHeader() [constructor] cls.add_constructor([]) @@ -6111,7 +6211,7 @@ def register_Ns3MgtDelBaHeader_methods(root_module, cls): def register_Ns3MgtProbeRequestHeader_methods(root_module, cls): ## mgt-headers.h (module 'wifi'): ns3::MgtProbeRequestHeader::MgtProbeRequestHeader() [constructor] cls.add_constructor([]) - ## mgt-headers.h (module 'wifi'): ns3::MgtProbeRequestHeader::MgtProbeRequestHeader(ns3::MgtProbeRequestHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtProbeRequestHeader::MgtProbeRequestHeader(ns3::MgtProbeRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtProbeRequestHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): uint32_t ns3::MgtProbeRequestHeader::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -6191,7 +6291,7 @@ def register_Ns3MgtProbeRequestHeader_methods(root_module, cls): return def register_Ns3MgtProbeResponseHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::MgtProbeResponseHeader::MgtProbeResponseHeader(ns3::MgtProbeResponseHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtProbeResponseHeader::MgtProbeResponseHeader(ns3::MgtProbeResponseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtProbeResponseHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::MgtProbeResponseHeader::MgtProbeResponseHeader() [constructor] cls.add_constructor([]) @@ -6387,7 +6487,7 @@ def register_Ns3MinstrelWifiRemoteStation_methods(root_module, cls): return def register_Ns3NqosWifiMacHelper_methods(root_module, cls): - ## nqos-wifi-mac-helper.h (module 'wifi'): ns3::NqosWifiMacHelper::NqosWifiMacHelper(ns3::NqosWifiMacHelper const & arg0) [copy constructor] + ## nqos-wifi-mac-helper.h (module 'wifi'): ns3::NqosWifiMacHelper::NqosWifiMacHelper(ns3::NqosWifiMacHelper const & arg0) [constructor] cls.add_constructor([param('ns3::NqosWifiMacHelper const &', 'arg0')]) ## nqos-wifi-mac-helper.h (module 'wifi'): ns3::NqosWifiMacHelper::NqosWifiMacHelper() [constructor] cls.add_constructor([]) @@ -6443,7 +6543,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -6464,7 +6564,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -6473,7 +6573,7 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) @@ -6501,10 +6601,10 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): cls.add_method('Clear', 'void', []) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', - [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) + [param('std::string const &', 'filename'), param('std::ios_base::openmode', 'mode')]) ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Close() [member function] cls.add_method('Close', 'void', @@ -6513,11 +6613,11 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): cls.add_method('Init', 'void', [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) @@ -6562,7 +6662,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): def register_Ns3PropagationDelayModel_methods(root_module, cls): ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel::PropagationDelayModel() [constructor] cls.add_constructor([]) - ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [copy constructor] + ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel::PropagationDelayModel(ns3::PropagationDelayModel const & arg0) [constructor] cls.add_constructor([param('ns3::PropagationDelayModel const &', 'arg0')]) ## propagation-delay-model.h (module 'propagation'): int64_t ns3::PropagationDelayModel::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', @@ -6623,7 +6723,7 @@ def register_Ns3PropagationLossModel_methods(root_module, cls): return def register_Ns3QosWifiMacHelper_methods(root_module, cls): - ## qos-wifi-mac-helper.h (module 'wifi'): ns3::QosWifiMacHelper::QosWifiMacHelper(ns3::QosWifiMacHelper const & arg0) [copy constructor] + ## qos-wifi-mac-helper.h (module 'wifi'): ns3::QosWifiMacHelper::QosWifiMacHelper(ns3::QosWifiMacHelper const & arg0) [constructor] cls.add_constructor([param('ns3::QosWifiMacHelper const &', 'arg0')]) ## qos-wifi-mac-helper.h (module 'wifi'): ns3::QosWifiMacHelper::QosWifiMacHelper() [constructor] cls.add_constructor([]) @@ -6661,7 +6761,7 @@ def register_Ns3QosWifiMacHelper_methods(root_module, cls): return def register_Ns3QueueBase_methods(root_module, cls): - ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [copy constructor] + ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [constructor] cls.add_constructor([param('ns3::QueueBase const &', 'arg0')]) ## queue.h (module 'network'): ns3::QueueBase::QueueBase() [constructor] cls.add_constructor([]) @@ -6761,15 +6861,10 @@ def register_Ns3QueueBase_methods(root_module, cls): cls.add_method('SetMode', 'void', [param('ns3::QueueBase::QueueMode', 'mode')]) - ## queue.h (module 'network'): void ns3::QueueBase::DoNsLog(ns3::LogLevel const level, std::string str) const [member function] - cls.add_method('DoNsLog', - 'void', - [param('ns3::LogLevel const', 'level'), param('std::string', 'str')], - is_const=True, visibility='protected') return def register_Ns3RandomPropagationDelayModel_methods(root_module, cls): - ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [copy constructor] + ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel::RandomPropagationDelayModel(ns3::RandomPropagationDelayModel const & arg0) [constructor] cls.add_constructor([param('ns3::RandomPropagationDelayModel const &', 'arg0')]) ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel::RandomPropagationDelayModel() [constructor] cls.add_constructor([]) @@ -6916,7 +7011,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6928,7 +7023,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6940,7 +7035,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6952,7 +7047,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6964,7 +7059,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6976,7 +7071,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6988,7 +7083,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3InterferenceHelperEvent_Ns3Empty_Ns3DefaultDeleter__lt__ns3InterferenceHelperEvent__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::InterferenceHelper::Event, ns3::empty, ns3::DefaultDeleter< ns3::InterferenceHelper::Event > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -6997,10 +7092,34 @@ def register_Ns3SimpleRefCount__Ns3InterferenceHelperEvent_Ns3Empty_Ns3DefaultDe is_static=True) return +def register_Ns3SimpleRefCount__Ns3MacRxMiddle_Ns3Empty_Ns3DefaultDeleter__lt__ns3MacRxMiddle__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::MacRxMiddle, ns3::empty, ns3::DefaultDeleter< ns3::MacRxMiddle > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + +def register_Ns3SimpleRefCount__Ns3MacTxMiddle_Ns3Empty_Ns3DefaultDeleter__lt__ns3MacTxMiddle__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::MacTxMiddle, ns3::empty, ns3::DefaultDeleter< ns3::MacTxMiddle > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7012,7 +7131,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter< ns3::OutputStreamWrapper > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7024,7 +7143,7 @@ def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7033,10 +7152,22 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac is_static=True) return +def register_Ns3SimpleRefCount__Ns3QosBlockedDestinations_Ns3Empty_Ns3DefaultDeleter__lt__ns3QosBlockedDestinations__gt___methods(root_module, cls): + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] + cls.add_constructor([]) + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] + cls.add_constructor([param('ns3::SimpleRefCount< ns3::QosBlockedDestinations, ns3::empty, ns3::DefaultDeleter< ns3::QosBlockedDestinations > > const &', 'o')]) + ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] + cls.add_method('Cleanup', + 'void', + [], + is_static=True) + return + def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3QueueItem__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter< ns3::QueueItem > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7048,7 +7179,7 @@ def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumModel__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumModel, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumModel > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7060,7 +7191,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumSignalParameters__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumSignalParameters, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumSignalParameters > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7072,7 +7203,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultD def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumValue, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7084,7 +7215,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7096,7 +7227,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3WifiInformationElement_Ns3Empty_Ns3DefaultDeleter__lt__ns3WifiInformationElement__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::WifiInformationElement, ns3::empty, ns3::DefaultDeleter< ns3::WifiInformationElement > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7108,7 +7239,7 @@ def register_Ns3SimpleRefCount__Ns3WifiInformationElement_Ns3Empty_Ns3DefaultDel def register_Ns3SimpleRefCount__Ns3WifiMacQueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3WifiMacQueueItem__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::WifiMacQueueItem, ns3::empty, ns3::DefaultDeleter< ns3::WifiMacQueueItem > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -7118,7 +7249,7 @@ def register_Ns3SimpleRefCount__Ns3WifiMacQueueItem_Ns3Empty_Ns3DefaultDeleter__ return def register_Ns3SnrTag_methods(root_module, cls): - ## snr-tag.h (module 'wifi'): ns3::SnrTag::SnrTag(ns3::SnrTag const & arg0) [copy constructor] + ## snr-tag.h (module 'wifi'): ns3::SnrTag::SnrTag(ns3::SnrTag const & arg0) [constructor] cls.add_constructor([param('ns3::SnrTag const &', 'arg0')]) ## snr-tag.h (module 'wifi'): ns3::SnrTag::SnrTag() [constructor] cls.add_constructor([]) @@ -7166,22 +7297,8 @@ def register_Ns3SnrTag_methods(root_module, cls): return def register_Ns3SpectrumInterference_methods(root_module, cls): - ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [copy constructor] - cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference() [constructor] cls.add_constructor([]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] - cls.add_method('AbortRx', - 'void', - []) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] - cls.add_method('AddSignal', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) - ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] - cls.add_method('EndRx', - 'bool', - []) ## spectrum-interference.h (module 'spectrum'): static ns3::TypeId ns3::SpectrumInterference::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -7191,14 +7308,28 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): cls.add_method('SetErrorModel', 'void', [param('ns3::Ptr< ns3::SpectrumErrorModel >', 'e')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] - cls.add_method('SetNoisePowerSpectralDensity', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] cls.add_method('StartRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::SpectrumValue const >', 'rxPsd')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] + cls.add_method('AbortRx', + 'void', + []) + ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] + cls.add_method('EndRx', + 'bool', + []) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] + cls.add_method('AddSignal', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + cls.add_method('SetNoisePowerSpectralDensity', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) + ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [constructor] + cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -7208,20 +7339,20 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): def register_Ns3SpectrumModel_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumModel const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(std::vector > centerFreqs) [constructor] cls.add_constructor([param('std::vector< double >', 'centerFreqs')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::Bands bands) [constructor] cls.add_constructor([param('ns3::Bands', 'bands')]) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::Begin() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::End() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) ## spectrum-model.h (module 'spectrum'): size_t ns3::SpectrumModel::GetNumBands() const [member function] @@ -7274,7 +7405,7 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::SpectrumChannel >', 'c')], is_pure_virtual=True, is_virtual=True) - ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] + ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -7294,7 +7425,7 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): def register_Ns3SpectrumSignalParameters_methods(root_module, cls): ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters() [constructor] cls.add_constructor([]) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [copy constructor] + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [constructor] cls.add_constructor([param('ns3::SpectrumSignalParameters const &', 'p')]) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::Ptr ns3::SpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', @@ -7312,16 +7443,16 @@ def register_Ns3SpectrumSignalParameters_methods(root_module, cls): return def register_Ns3SpectrumValue_methods(root_module, cls): + cls.add_output_stream_operator() + cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_unary_numeric_operator('-') cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_output_stream_operator() + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('double', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::SpectrumValue const &', u'right')) @@ -7330,30 +7461,30 @@ def register_Ns3SpectrumValue_methods(root_module, cls): cls.add_inplace_numeric_operator('-=', param('double', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('/=', param('double', u'right')) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [copy constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumValue const &', 'arg0')]) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::SpectrumModel const >', 'sm')]) ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue() [constructor] cls.add_constructor([]) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsBegin() const [member function] cls.add_method('ConstBandsBegin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsEnd() const [member function] cls.add_method('ConstBandsEnd', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesBegin() const [member function] cls.add_method('ConstValuesBegin', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesEnd() const [member function] cls.add_method('ConstValuesEnd', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::Copy() const [member function] @@ -7361,7 +7492,7 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] + ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] cls.add_method('GetSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -7371,18 +7502,18 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::SpectrumModelUid_t', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesBegin() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesBegin() [member function] cls.add_method('ValuesBegin', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesEnd() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesEnd() [member function] cls.add_method('ValuesEnd', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) return def register_Ns3SpectrumWifiPhyHelper_methods(root_module, cls): - ## spectrum-wifi-helper.h (module 'wifi'): ns3::SpectrumWifiPhyHelper::SpectrumWifiPhyHelper(ns3::SpectrumWifiPhyHelper const & arg0) [copy constructor] + ## spectrum-wifi-helper.h (module 'wifi'): ns3::SpectrumWifiPhyHelper::SpectrumWifiPhyHelper(ns3::SpectrumWifiPhyHelper const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumWifiPhyHelper const &', 'arg0')]) ## spectrum-wifi-helper.h (module 'wifi'): ns3::SpectrumWifiPhyHelper::SpectrumWifiPhyHelper() [constructor] cls.add_constructor([]) @@ -7427,22 +7558,22 @@ def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls): return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -7625,7 +7756,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -7655,7 +7786,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -7817,7 +7948,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): return def register_Ns3VhtWifiMacHelper_methods(root_module, cls): - ## vht-wifi-mac-helper.h (module 'wifi'): ns3::VhtWifiMacHelper::VhtWifiMacHelper(ns3::VhtWifiMacHelper const & arg0) [copy constructor] + ## vht-wifi-mac-helper.h (module 'wifi'): ns3::VhtWifiMacHelper::VhtWifiMacHelper(ns3::VhtWifiMacHelper const & arg0) [constructor] cls.add_constructor([param('ns3::VhtWifiMacHelper const &', 'arg0')]) ## vht-wifi-mac-helper.h (module 'wifi'): ns3::VhtWifiMacHelper::VhtWifiMacHelper() [constructor] cls.add_constructor([]) @@ -7877,7 +8008,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): return def register_Ns3WifiActionHeader_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::WifiActionHeader(ns3::WifiActionHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::WifiActionHeader(ns3::WifiActionHeader const & arg0) [constructor] cls.add_constructor([param('ns3::WifiActionHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::WifiActionHeader() [constructor] cls.add_constructor([]) @@ -7926,9 +8057,9 @@ def register_Ns3WifiActionHeader_methods(root_module, cls): return def register_Ns3WifiActionHeaderActionValue_methods(root_module, cls): - ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::ActionValue::ActionValue() [constructor] + ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::ActionValue() [constructor] cls.add_constructor([]) - ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::ActionValue::ActionValue(ns3::WifiActionHeader::ActionValue const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::ActionValue(ns3::WifiActionHeader::ActionValue const & arg0) [constructor] cls.add_constructor([param('ns3::WifiActionHeader::ActionValue const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): ns3::WifiActionHeader::ActionValue::blockAck [variable] cls.add_instance_attribute('blockAck', 'ns3::WifiActionHeader::BlockAckActionValue', is_const=False) @@ -7945,7 +8076,7 @@ def register_Ns3WifiInformationElement_methods(root_module, cls): cls.add_binary_comparison_operator('==') ## wifi-information-element.h (module 'wifi'): ns3::WifiInformationElement::WifiInformationElement() [constructor] cls.add_constructor([]) - ## wifi-information-element.h (module 'wifi'): ns3::WifiInformationElement::WifiInformationElement(ns3::WifiInformationElement const & arg0) [copy constructor] + ## wifi-information-element.h (module 'wifi'): ns3::WifiInformationElement::WifiInformationElement(ns3::WifiInformationElement const & arg0) [constructor] cls.add_constructor([param('ns3::WifiInformationElement const &', 'arg0')]) ## wifi-information-element.h (module 'wifi'): ns3::Buffer::Iterator ns3::WifiInformationElement::Deserialize(ns3::Buffer::Iterator i) [member function] cls.add_method('Deserialize', @@ -7994,7 +8125,7 @@ def register_Ns3WifiInformationElement_methods(root_module, cls): def register_Ns3WifiInformationElementVector_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## wifi-information-element-vector.h (module 'wifi'): ns3::WifiInformationElementVector::WifiInformationElementVector(ns3::WifiInformationElementVector const & arg0) [copy constructor] + ## wifi-information-element-vector.h (module 'wifi'): ns3::WifiInformationElementVector::WifiInformationElementVector(ns3::WifiInformationElementVector const & arg0) [constructor] cls.add_constructor([param('ns3::WifiInformationElementVector const &', 'arg0')]) ## wifi-information-element-vector.h (module 'wifi'): ns3::WifiInformationElementVector::WifiInformationElementVector() [constructor] cls.add_constructor([]) @@ -8002,9 +8133,9 @@ def register_Ns3WifiInformationElementVector_methods(root_module, cls): cls.add_method('AddInformationElement', 'bool', [param('ns3::Ptr< ns3::WifiInformationElement >', 'element')]) - ## wifi-information-element-vector.h (module 'wifi'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::WifiInformationElementVector::Begin() [member function] + ## wifi-information-element-vector.h (module 'wifi'): ns3::WifiInformationElementVector::Iterator ns3::WifiInformationElementVector::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::WifiInformationElement >, std::vector< ns3::Ptr< ns3::WifiInformationElement > > >', + 'ns3::WifiInformationElementVector::Iterator', []) ## wifi-information-element-vector.h (module 'wifi'): uint32_t ns3::WifiInformationElementVector::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -8016,14 +8147,14 @@ def register_Ns3WifiInformationElementVector_methods(root_module, cls): 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) - ## wifi-information-element-vector.h (module 'wifi'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::WifiInformationElementVector::End() [member function] + ## wifi-information-element-vector.h (module 'wifi'): ns3::WifiInformationElementVector::Iterator ns3::WifiInformationElementVector::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::WifiInformationElement >, std::vector< ns3::Ptr< ns3::WifiInformationElement > > >', + 'ns3::WifiInformationElementVector::Iterator', []) ## wifi-information-element-vector.h (module 'wifi'): ns3::Ptr ns3::WifiInformationElementVector::FindFirst(ns3::WifiInformationElementId id) const [member function] cls.add_method('FindFirst', 'ns3::Ptr< ns3::WifiInformationElement >', - [param('ns3::WifiInformationElementId', 'id')], + [param('uint8_t', 'id')], is_const=True) ## wifi-information-element-vector.h (module 'wifi'): ns3::TypeId ns3::WifiInformationElementVector::GetInstanceTypeId() const [member function] cls.add_method('GetInstanceTypeId', @@ -8064,18 +8195,18 @@ def register_Ns3WifiInformationElementVector_methods(root_module, cls): def register_Ns3WifiMac_methods(root_module, cls): ## wifi-mac.h (module 'wifi'): ns3::WifiMac::WifiMac() [constructor] cls.add_constructor([]) - ## wifi-mac.h (module 'wifi'): ns3::WifiMac::WifiMac(ns3::WifiMac const & arg0) [copy constructor] + ## wifi-mac.h (module 'wifi'): ns3::WifiMac::WifiMac(ns3::WifiMac const & arg0) [constructor] cls.add_constructor([param('ns3::WifiMac const &', 'arg0')]) ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::ConfigureStandard(ns3::WifiPhyStandard standard) [member function] cls.add_method('ConfigureStandard', 'void', [param('ns3::WifiPhyStandard', 'standard')]) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')], is_pure_virtual=True, is_virtual=True) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to')], @@ -8175,23 +8306,23 @@ def register_Ns3WifiMac_methods(root_module, cls): 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyPromiscRx(ns3::Ptr packet) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyPromiscRx(ns3::Ptr packet) [member function] cls.add_method('NotifyPromiscRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyRx(ns3::Ptr packet) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyRx(ns3::Ptr packet) [member function] cls.add_method('NotifyRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyRxDrop(ns3::Ptr packet) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyRxDrop(ns3::Ptr packet) [member function] cls.add_method('NotifyRxDrop', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyTx(ns3::Ptr packet) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyTx(ns3::Ptr packet) [member function] cls.add_method('NotifyTx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyTxDrop(ns3::Ptr packet) [member function] + ## wifi-mac.h (module 'wifi'): void ns3::WifiMac::NotifyTxDrop(ns3::Ptr packet) [member function] cls.add_method('NotifyTxDrop', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -8312,7 +8443,7 @@ def register_Ns3WifiMac_methods(root_module, cls): return def register_Ns3WifiMacHeader_methods(root_module, cls): - ## wifi-mac-header.h (module 'wifi'): ns3::WifiMacHeader::WifiMacHeader(ns3::WifiMacHeader const & arg0) [copy constructor] + ## wifi-mac-header.h (module 'wifi'): ns3::WifiMacHeader::WifiMacHeader(ns3::WifiMacHeader const & arg0) [constructor] cls.add_constructor([param('ns3::WifiMacHeader const &', 'arg0')]) ## wifi-mac-header.h (module 'wifi'): ns3::WifiMacHeader::WifiMacHeader() [constructor] cls.add_constructor([]) @@ -8747,9 +8878,9 @@ def register_Ns3WifiMacHeader_methods(root_module, cls): return def register_Ns3WifiMacQueueItem_methods(root_module, cls): - ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueueItem::WifiMacQueueItem(ns3::Ptr p, ns3::WifiMacHeader const & header) [constructor] + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueueItem::WifiMacQueueItem(ns3::Ptr p, ns3::WifiMacHeader const & header) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::WifiMacHeader const &', 'header')]) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueueItem::GetPacket() const [member function] + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueueItem::GetPacket() const [member function] cls.add_method('GetPacket', 'ns3::Ptr< ns3::Packet const >', [], @@ -8777,7 +8908,7 @@ def register_Ns3WifiMacQueueItem_methods(root_module, cls): return def register_Ns3WifiMacTrailer_methods(root_module, cls): - ## wifi-mac-trailer.h (module 'wifi'): ns3::WifiMacTrailer::WifiMacTrailer(ns3::WifiMacTrailer const & arg0) [copy constructor] + ## wifi-mac-trailer.h (module 'wifi'): ns3::WifiMacTrailer::WifiMacTrailer(ns3::WifiMacTrailer const & arg0) [constructor] cls.add_constructor([param('ns3::WifiMacTrailer const &', 'arg0')]) ## wifi-mac-trailer.h (module 'wifi'): ns3::WifiMacTrailer::WifiMacTrailer() [constructor] cls.add_constructor([]) @@ -8814,7 +8945,7 @@ def register_Ns3WifiMacTrailer_methods(root_module, cls): return def register_Ns3WifiPhy_methods(root_module, cls): - ## wifi-phy.h (module 'wifi'): ns3::WifiPhy::WifiPhy(ns3::WifiPhy const & arg0) [copy constructor] + ## wifi-phy.h (module 'wifi'): ns3::WifiPhy::WifiPhy(ns3::WifiPhy const & arg0) [constructor] cls.add_constructor([param('ns3::WifiPhy const &', 'arg0')]) ## wifi-phy.h (module 'wifi'): ns3::WifiPhy::WifiPhy() [constructor] cls.add_constructor([]) @@ -8827,10 +8958,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'int64_t', [param('int64_t', 'stream')], is_virtual=True) - ## wifi-phy.h (module 'wifi'): ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] + ## wifi-phy.h (module 'wifi'): static ns3::Time ns3::WifiPhy::CalculatePlcpPreambleAndHeaderDuration(ns3::WifiTxVector txVector) [member function] cls.add_method('CalculatePlcpPreambleAndHeaderDuration', 'ns3::Time', - [param('ns3::WifiTxVector', 'txVector')]) + [param('ns3::WifiTxVector', 'txVector')], + is_static=True) ## wifi-phy.h (module 'wifi'): double ns3::WifiPhy::CalculateSnr(ns3::WifiTxVector txVector, double ber) const [member function] cls.add_method('CalculateSnr', 'double', @@ -8970,6 +9102,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'ns3::Ptr< ns3::ErrorRateModel >', [], is_const=True) + ## wifi-phy.h (module 'wifi'): ns3::Ptr ns3::WifiPhy::GetFrameCaptureModel() const [member function] + cls.add_method('GetFrameCaptureModel', + 'ns3::Ptr< ns3::FrameCaptureModel >', + [], + is_const=True) ## wifi-phy.h (module 'wifi'): uint16_t ns3::WifiPhy::GetFrequency() const [member function] cls.add_method('GetFrequency', 'uint16_t', @@ -9566,16 +9703,16 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'ns3::WifiMode', [], is_static=True) - ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::Is2_4Ghz(double frequency) const [member function] + ## wifi-phy.h (module 'wifi'): static bool ns3::WifiPhy::Is2_4Ghz(double frequency) [member function] cls.add_method('Is2_4Ghz', 'bool', [param('double', 'frequency')], - is_const=True) - ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::Is5Ghz(double frequency) const [member function] + is_static=True) + ## wifi-phy.h (module 'wifi'): static bool ns3::WifiPhy::Is5Ghz(double frequency) [member function] cls.add_method('Is5Ghz', 'bool', [param('double', 'frequency')], - is_const=True) + is_static=True) ## wifi-phy.h (module 'wifi'): bool ns3::WifiPhy::IsMcsSupported(ns3::WifiMode mcs) const [member function] cls.add_method('IsMcsSupported', 'bool', @@ -9619,35 +9756,35 @@ def register_Ns3WifiPhy_methods(root_module, cls): 'bool', [param('ns3::WifiTxVector', 'txVector')], is_static=True) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyMonitorSniffRx(ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu, ns3::SignalNoiseDbm signalNoise) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyMonitorSniffRx(ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu, ns3::SignalNoiseDbm signalNoise) [member function] cls.add_method('NotifyMonitorSniffRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduInfo', 'aMpdu'), param('ns3::SignalNoiseDbm', 'signalNoise')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyMonitorSniffTx(ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyMonitorSniffTx(ns3::Ptr packet, uint16_t channelFreqMhz, ns3::WifiTxVector txVector, ns3::MpduInfo aMpdu) [member function] cls.add_method('NotifyMonitorSniffTx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint16_t', 'channelFreqMhz'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduInfo', 'aMpdu')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxBegin(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxBegin(ns3::Ptr packet) [member function] cls.add_method('NotifyRxBegin', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxDrop(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxDrop(ns3::Ptr packet) [member function] cls.add_method('NotifyRxDrop', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxEnd(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyRxEnd(ns3::Ptr packet) [member function] cls.add_method('NotifyRxEnd', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxBegin(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxBegin(ns3::Ptr packet) [member function] cls.add_method('NotifyTxBegin', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxDrop(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxDrop(ns3::Ptr packet) [member function] cls.add_method('NotifyTxDrop', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxEnd(ns3::Ptr packet) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::NotifyTxEnd(ns3::Ptr packet) [member function] cls.add_method('NotifyTxEnd', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -9659,10 +9796,10 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('ResumeFromSleep', 'void', []) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SendPacket(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::MpduType mpdutype=::ns3::NORMAL_MPDU) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SendPacket(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::MpduType mpdutype=::ns3::MpduType::NORMAL_MPDU) [member function] cls.add_method('SendPacket', 'void', - [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduType', 'mpdutype', default_value='::ns3::NORMAL_MPDU')]) + [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector'), param('ns3::MpduType', 'mpdutype', default_value='::ns3::MpduType::NORMAL_MPDU')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetCcaMode1Threshold(double threshold) [member function] cls.add_method('SetCcaMode1Threshold', 'void', @@ -9675,18 +9812,22 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('SetChannelWidth', 'void', [param('uint8_t', 'channelwidth')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetDevice(ns3::Ptr device) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetDevice(ns3::Ptr const device) [member function] cls.add_method('SetDevice', 'void', - [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + [param('ns3::Ptr< ns3::NetDevice > const', 'device')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetEdThreshold(double threshold) [member function] cls.add_method('SetEdThreshold', 'void', [param('double', 'threshold')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetErrorRateModel(ns3::Ptr rate) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetErrorRateModel(ns3::Ptr const rate) [member function] cls.add_method('SetErrorRateModel', 'void', - [param('ns3::Ptr< ns3::ErrorRateModel >', 'rate')]) + [param('ns3::Ptr< ns3::ErrorRateModel > const', 'rate')]) + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrameCaptureModel(ns3::Ptr const rate) [member function] + cls.add_method('SetFrameCaptureModel', + 'void', + [param('ns3::Ptr< ns3::FrameCaptureModel > const', 'rate')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetFrequency(uint16_t freq) [member function] cls.add_method('SetFrequency', 'void', @@ -9711,10 +9852,10 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('SetMaxSupportedTxSpatialStreams', 'void', [param('uint8_t', 'streams')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetMobility(ns3::Ptr mobility) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetMobility(ns3::Ptr const mobility) [member function] cls.add_method('SetMobility', 'void', - [param('ns3::Ptr< ns3::MobilityModel >', 'mobility')]) + [param('ns3::Ptr< ns3::MobilityModel > const', 'mobility')]) ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetNTxPower(uint32_t n) [member function] cls.add_method('SetNTxPower', 'void', @@ -9723,11 +9864,11 @@ def register_Ns3WifiPhy_methods(root_module, cls): cls.add_method('SetNumberOfAntennas', 'void', [param('uint8_t', 'antennas')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetReceiveErrorCallback(ns3::WifiPhy::RxErrorCallback callback) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetReceiveOkCallback(ns3::Callback, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + ## wifi-phy.h (module 'wifi'): void ns3::WifiPhy::SetReceiveOkCallback(ns3::WifiPhy::RxOkCallback callback) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -9812,7 +9953,7 @@ def register_Ns3WifiPhy_methods(root_module, cls): return def register_Ns3WifiPhyStateHelper_methods(root_module, cls): - ## wifi-phy-state-helper.h (module 'wifi'): ns3::WifiPhyStateHelper::WifiPhyStateHelper(ns3::WifiPhyStateHelper const & arg0) [copy constructor] + ## wifi-phy-state-helper.h (module 'wifi'): ns3::WifiPhyStateHelper::WifiPhyStateHelper(ns3::WifiPhyStateHelper const & arg0) [constructor] cls.add_constructor([param('ns3::WifiPhyStateHelper const &', 'arg0')]) ## wifi-phy-state-helper.h (module 'wifi'): ns3::WifiPhyStateHelper::WifiPhyStateHelper() [constructor] cls.add_constructor([]) @@ -9880,14 +10021,18 @@ def register_Ns3WifiPhyStateHelper_methods(root_module, cls): cls.add_method('RegisterListener', 'void', [param('ns3::WifiPhyListener *', 'listener')]) - ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SetReceiveErrorCallback(ns3::WifiPhy::RxErrorCallback callback) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SetReceiveOkCallback(ns3::Callback, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SetReceiveOkCallback(ns3::WifiPhy::RxOkCallback callback) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SwitchFromRxAbort() [member function] + cls.add_method('SwitchFromRxAbort', + 'void', + []) ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SwitchFromRxEndError(ns3::Ptr packet, double snr) [member function] cls.add_method('SwitchFromRxEndError', 'void', @@ -9916,7 +10061,7 @@ def register_Ns3WifiPhyStateHelper_methods(root_module, cls): cls.add_method('SwitchToSleep', 'void', []) - ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SwitchToTx(ns3::Time txDuration, ns3::Ptr packet, double txPowerDbm, ns3::WifiTxVector txVector) [member function] + ## wifi-phy-state-helper.h (module 'wifi'): void ns3::WifiPhyStateHelper::SwitchToTx(ns3::Time txDuration, ns3::Ptr packet, double txPowerDbm, ns3::WifiTxVector txVector) [member function] cls.add_method('SwitchToTx', 'void', [param('ns3::Time', 'txDuration'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('double', 'txPowerDbm'), param('ns3::WifiTxVector', 'txVector')]) @@ -9927,7 +10072,7 @@ def register_Ns3WifiPhyStateHelper_methods(root_module, cls): return def register_Ns3WifiRemoteStationManager_methods(root_module, cls): - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationManager::WifiRemoteStationManager(ns3::WifiRemoteStationManager const & arg0) [copy constructor] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationManager::WifiRemoteStationManager(ns3::WifiRemoteStationManager const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRemoteStationManager const &', 'arg0')]) ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiRemoteStationManager::WifiRemoteStationManager() [constructor] cls.add_constructor([]) @@ -10002,7 +10147,7 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'uint8_t', [param('ns3::Mac48Address', 'address')], is_const=True) - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetCtsToSelfTxVector(ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetCtsToSelfTxVector(ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('GetCtsToSelfTxVector', 'ns3::WifiTxVector', [param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10010,7 +10155,7 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): cls.add_method('GetCtsTxVector', 'ns3::WifiTxVector', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMode', 'rtsMode')]) - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetDataTxVector(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetDataTxVector(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('GetDataTxVector', 'ns3::WifiTxVector', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10034,11 +10179,11 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'ns3::WifiRemoteStationManager::ProtectionMode', [], is_const=True) - ## wifi-remote-station-manager.h (module 'wifi'): uint32_t ns3::WifiRemoteStationManager::GetFragmentOffset(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): uint32_t ns3::WifiRemoteStationManager::GetFragmentOffset(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] cls.add_method('GetFragmentOffset', 'uint32_t', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint32_t', 'fragmentNumber')]) - ## wifi-remote-station-manager.h (module 'wifi'): uint32_t ns3::WifiRemoteStationManager::GetFragmentSize(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): uint32_t ns3::WifiRemoteStationManager::GetFragmentSize(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] cls.add_method('GetFragmentSize', 'uint32_t', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint32_t', 'fragmentNumber')]) @@ -10119,7 +10264,7 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetRtsTxVector(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): ns3::WifiTxVector ns3::WifiRemoteStationManager::GetRtsTxVector(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('GetRtsTxVector', 'ns3::WifiTxVector', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10198,7 +10343,7 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'bool', [param('ns3::Mac48Address', 'address')], is_const=True) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::IsLastFragment(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::IsLastFragment(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, uint32_t fragmentNumber) [member function] cls.add_method('IsLastFragment', 'bool', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('uint32_t', 'fragmentNumber')]) @@ -10211,23 +10356,23 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): cls.add_method('NeedCtsToSelf', 'bool', [param('ns3::WifiTxVector', 'txVector')]) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedDataRetransmission(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedDataRetransmission(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('NeedDataRetransmission', 'bool', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedFragmentation(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedFragmentation(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('NeedFragmentation', 'bool', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedRts(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, ns3::WifiTxVector txVector) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedRts(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet, ns3::WifiTxVector txVector) [member function] cls.add_method('NeedRts', 'bool', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiTxVector', 'txVector')]) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedRtsRetransmission(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::NeedRtsRetransmission(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('NeedRtsRetransmission', 'bool', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::PrepareForQueue(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::PrepareForQueue(ns3::Mac48Address address, ns3::WifiMacHeader const * header, ns3::Ptr packet) [member function] cls.add_method('PrepareForQueue', 'void', [param('ns3::Mac48Address', 'address'), param('ns3::WifiMacHeader const *', 'header'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10367,15 +10512,15 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::SetupMac(ns3::Ptr mac) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::SetupMac(ns3::Ptr const mac) [member function] cls.add_method('SetupMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')], + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')], is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::SetupPhy(ns3::Ptr phy) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## wifi-remote-station-manager.h (module 'wifi'): void ns3::WifiRemoteStationManager::UpdateFragmentationThreshold() [member function] cls.add_method('UpdateFragmentationThreshold', @@ -10611,22 +10756,22 @@ def register_Ns3WifiRemoteStationManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], is_pure_virtual=True, visibility='private', is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedDataRetransmission', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], visibility='private', is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedFragmentation(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedFragmentation(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedFragmentation', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], visibility='private', is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRts', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], visibility='private', is_virtual=True) - ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedRtsRetransmission(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## wifi-remote-station-manager.h (module 'wifi'): bool ns3::WifiRemoteStationManager::DoNeedRtsRetransmission(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRtsRetransmission', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -10686,36 +10831,36 @@ def register_Ns3WifiSpectrumPhyInterface_methods(root_module, cls): is_static=True) ## wifi-spectrum-phy-interface.h (module 'wifi'): ns3::WifiSpectrumPhyInterface::WifiSpectrumPhyInterface() [constructor] cls.add_constructor([]) - ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetSpectrumWifiPhy(ns3::Ptr phy) [member function] + ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetSpectrumWifiPhy(ns3::Ptr const phy) [member function] cls.add_method('SetSpectrumWifiPhy', 'void', - [param('ns3::Ptr< ns3::SpectrumWifiPhy >', 'phy')]) + [param('ns3::Ptr< ns3::SpectrumWifiPhy > const', 'phy')]) ## wifi-spectrum-phy-interface.h (module 'wifi'): ns3::Ptr ns3::WifiSpectrumPhyInterface::GetDevice() const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', [], is_const=True, is_virtual=True) - ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetDevice(ns3::Ptr d) [member function] + ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetDevice(ns3::Ptr const d) [member function] cls.add_method('SetDevice', 'void', - [param('ns3::Ptr< ns3::NetDevice >', 'd')], + [param('ns3::Ptr< ns3::NetDevice > const', 'd')], is_virtual=True) - ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetMobility(ns3::Ptr m) [member function] + ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetMobility(ns3::Ptr const m) [member function] cls.add_method('SetMobility', 'void', - [param('ns3::Ptr< ns3::MobilityModel >', 'm')], + [param('ns3::Ptr< ns3::MobilityModel > const', 'm')], is_virtual=True) ## wifi-spectrum-phy-interface.h (module 'wifi'): ns3::Ptr ns3::WifiSpectrumPhyInterface::GetMobility() [member function] cls.add_method('GetMobility', 'ns3::Ptr< ns3::MobilityModel >', [], is_virtual=True) - ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetChannel(ns3::Ptr c) [member function] + ## wifi-spectrum-phy-interface.h (module 'wifi'): void ns3::WifiSpectrumPhyInterface::SetChannel(ns3::Ptr const c) [member function] cls.add_method('SetChannel', 'void', - [param('ns3::Ptr< ns3::SpectrumChannel >', 'c')], + [param('ns3::Ptr< ns3::SpectrumChannel > const', 'c')], is_virtual=True) - ## wifi-spectrum-phy-interface.h (module 'wifi'): ns3::Ptr ns3::WifiSpectrumPhyInterface::GetRxSpectrumModel() const [member function] + ## wifi-spectrum-phy-interface.h (module 'wifi'): ns3::Ptr ns3::WifiSpectrumPhyInterface::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -10740,7 +10885,7 @@ def register_Ns3WifiSpectrumPhyInterface_methods(root_module, cls): def register_Ns3WifiSpectrumSignalParameters_methods(root_module, cls): ## wifi-spectrum-signal-parameters.h (module 'wifi'): ns3::WifiSpectrumSignalParameters::WifiSpectrumSignalParameters() [constructor] cls.add_constructor([]) - ## wifi-spectrum-signal-parameters.h (module 'wifi'): ns3::WifiSpectrumSignalParameters::WifiSpectrumSignalParameters(ns3::WifiSpectrumSignalParameters const & p) [copy constructor] + ## wifi-spectrum-signal-parameters.h (module 'wifi'): ns3::WifiSpectrumSignalParameters::WifiSpectrumSignalParameters(ns3::WifiSpectrumSignalParameters const & p) [constructor] cls.add_constructor([param('ns3::WifiSpectrumSignalParameters const &', 'p')]) ## wifi-spectrum-signal-parameters.h (module 'wifi'): ns3::Ptr ns3::WifiSpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', @@ -10752,7 +10897,7 @@ def register_Ns3WifiSpectrumSignalParameters_methods(root_module, cls): return def register_Ns3WifiTxCurrentModel_methods(root_module, cls): - ## wifi-tx-current-model.h (module 'wifi'): ns3::WifiTxCurrentModel::WifiTxCurrentModel(ns3::WifiTxCurrentModel const & arg0) [copy constructor] + ## wifi-tx-current-model.h (module 'wifi'): ns3::WifiTxCurrentModel::WifiTxCurrentModel(ns3::WifiTxCurrentModel const & arg0) [constructor] cls.add_constructor([param('ns3::WifiTxCurrentModel const &', 'arg0')]) ## wifi-tx-current-model.h (module 'wifi'): ns3::WifiTxCurrentModel::WifiTxCurrentModel() [constructor] cls.add_constructor([]) @@ -10769,7 +10914,7 @@ def register_Ns3WifiTxCurrentModel_methods(root_module, cls): return def register_Ns3YansWifiPhy_methods(root_module, cls): - ## yans-wifi-phy.h (module 'wifi'): ns3::YansWifiPhy::YansWifiPhy(ns3::YansWifiPhy const & arg0) [copy constructor] + ## yans-wifi-phy.h (module 'wifi'): ns3::YansWifiPhy::YansWifiPhy(ns3::YansWifiPhy const & arg0) [constructor] cls.add_constructor([param('ns3::YansWifiPhy const &', 'arg0')]) ## yans-wifi-phy.h (module 'wifi'): ns3::YansWifiPhy::YansWifiPhy() [constructor] cls.add_constructor([]) @@ -10783,10 +10928,10 @@ def register_Ns3YansWifiPhy_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## yans-wifi-phy.h (module 'wifi'): void ns3::YansWifiPhy::SetChannel(ns3::Ptr channel) [member function] + ## yans-wifi-phy.h (module 'wifi'): void ns3::YansWifiPhy::SetChannel(ns3::Ptr const channel) [member function] cls.add_method('SetChannel', 'void', - [param('ns3::Ptr< ns3::YansWifiChannel >', 'channel')]) + [param('ns3::Ptr< ns3::YansWifiChannel > const', 'channel')]) ## yans-wifi-phy.h (module 'wifi'): void ns3::YansWifiPhy::StartTx(ns3::Ptr packet, ns3::WifiTxVector txVector, ns3::Time txDuration) [member function] cls.add_method('StartTx', 'void', @@ -10871,7 +11016,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3AarfWifiManager_methods(root_module, cls): - ## aarf-wifi-manager.h (module 'wifi'): ns3::AarfWifiManager::AarfWifiManager(ns3::AarfWifiManager const & arg0) [copy constructor] + ## aarf-wifi-manager.h (module 'wifi'): ns3::AarfWifiManager::AarfWifiManager(ns3::AarfWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::AarfWifiManager const &', 'arg0')]) ## aarf-wifi-manager.h (module 'wifi'): ns3::AarfWifiManager::AarfWifiManager() [constructor] cls.add_constructor([]) @@ -10953,7 +11098,7 @@ def register_Ns3AarfWifiManager_methods(root_module, cls): return def register_Ns3AarfcdWifiManager_methods(root_module, cls): - ## aarfcd-wifi-manager.h (module 'wifi'): ns3::AarfcdWifiManager::AarfcdWifiManager(ns3::AarfcdWifiManager const & arg0) [copy constructor] + ## aarfcd-wifi-manager.h (module 'wifi'): ns3::AarfcdWifiManager::AarfcdWifiManager(ns3::AarfcdWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::AarfcdWifiManager const &', 'arg0')]) ## aarfcd-wifi-manager.h (module 'wifi'): ns3::AarfcdWifiManager::AarfcdWifiManager() [constructor] cls.add_constructor([]) @@ -10992,7 +11137,7 @@ def register_Ns3AarfcdWifiManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], visibility='private', is_virtual=True) - ## aarfcd-wifi-manager.h (module 'wifi'): bool ns3::AarfcdWifiManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## aarfcd-wifi-manager.h (module 'wifi'): bool ns3::AarfcdWifiManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRts', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -11040,7 +11185,7 @@ def register_Ns3AarfcdWifiManager_methods(root_module, cls): return def register_Ns3AmpduSubframeHeader_methods(root_module, cls): - ## ampdu-subframe-header.h (module 'wifi'): ns3::AmpduSubframeHeader::AmpduSubframeHeader(ns3::AmpduSubframeHeader const & arg0) [copy constructor] + ## ampdu-subframe-header.h (module 'wifi'): ns3::AmpduSubframeHeader::AmpduSubframeHeader(ns3::AmpduSubframeHeader const & arg0) [constructor] cls.add_constructor([param('ns3::AmpduSubframeHeader const &', 'arg0')]) ## ampdu-subframe-header.h (module 'wifi'): ns3::AmpduSubframeHeader::AmpduSubframeHeader() [constructor] cls.add_constructor([]) @@ -11113,7 +11258,7 @@ def register_Ns3AmpduSubframeHeader_methods(root_module, cls): return def register_Ns3AmrrWifiManager_methods(root_module, cls): - ## amrr-wifi-manager.h (module 'wifi'): ns3::AmrrWifiManager::AmrrWifiManager(ns3::AmrrWifiManager const & arg0) [copy constructor] + ## amrr-wifi-manager.h (module 'wifi'): ns3::AmrrWifiManager::AmrrWifiManager(ns3::AmrrWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::AmrrWifiManager const &', 'arg0')]) ## amrr-wifi-manager.h (module 'wifi'): ns3::AmrrWifiManager::AmrrWifiManager() [constructor] cls.add_constructor([]) @@ -11195,7 +11340,7 @@ def register_Ns3AmrrWifiManager_methods(root_module, cls): return def register_Ns3AmsduSubframeHeader_methods(root_module, cls): - ## amsdu-subframe-header.h (module 'wifi'): ns3::AmsduSubframeHeader::AmsduSubframeHeader(ns3::AmsduSubframeHeader const & arg0) [copy constructor] + ## amsdu-subframe-header.h (module 'wifi'): ns3::AmsduSubframeHeader::AmsduSubframeHeader(ns3::AmsduSubframeHeader const & arg0) [constructor] cls.add_constructor([param('ns3::AmsduSubframeHeader const &', 'arg0')]) ## amsdu-subframe-header.h (module 'wifi'): ns3::AmsduSubframeHeader::AmsduSubframeHeader() [constructor] cls.add_constructor([]) @@ -11259,7 +11404,7 @@ def register_Ns3AmsduSubframeHeader_methods(root_module, cls): return def register_Ns3AntennaModel_methods(root_module, cls): - ## antenna-model.h (module 'antenna'): ns3::AntennaModel::AntennaModel(ns3::AntennaModel const & arg0) [copy constructor] + ## antenna-model.h (module 'antenna'): ns3::AntennaModel::AntennaModel(ns3::AntennaModel const & arg0) [constructor] cls.add_constructor([param('ns3::AntennaModel const &', 'arg0')]) ## antenna-model.h (module 'antenna'): ns3::AntennaModel::AntennaModel() [constructor] cls.add_constructor([]) @@ -11276,7 +11421,7 @@ def register_Ns3AntennaModel_methods(root_module, cls): return def register_Ns3AparfWifiManager_methods(root_module, cls): - ## aparf-wifi-manager.h (module 'wifi'): ns3::AparfWifiManager::AparfWifiManager(ns3::AparfWifiManager const & arg0) [copy constructor] + ## aparf-wifi-manager.h (module 'wifi'): ns3::AparfWifiManager::AparfWifiManager(ns3::AparfWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::AparfWifiManager const &', 'arg0')]) ## aparf-wifi-manager.h (module 'wifi'): ns3::AparfWifiManager::AparfWifiManager() [constructor] cls.add_constructor([]) @@ -11300,10 +11445,10 @@ def register_Ns3AparfWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## aparf-wifi-manager.h (module 'wifi'): void ns3::AparfWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## aparf-wifi-manager.h (module 'wifi'): void ns3::AparfWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## aparf-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::AparfWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -11363,7 +11508,7 @@ def register_Ns3AparfWifiManager_methods(root_module, cls): return def register_Ns3ArfWifiManager_methods(root_module, cls): - ## arf-wifi-manager.h (module 'wifi'): ns3::ArfWifiManager::ArfWifiManager(ns3::ArfWifiManager const & arg0) [copy constructor] + ## arf-wifi-manager.h (module 'wifi'): ns3::ArfWifiManager::ArfWifiManager(ns3::ArfWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::ArfWifiManager const &', 'arg0')]) ## arf-wifi-manager.h (module 'wifi'): ns3::ArfWifiManager::ArfWifiManager() [constructor] cls.add_constructor([]) @@ -11445,15 +11590,15 @@ def register_Ns3ArfWifiManager_methods(root_module, cls): return def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls): - ## athstats-helper.h (module 'wifi'): ns3::AthstatsWifiTraceSink::AthstatsWifiTraceSink(ns3::AthstatsWifiTraceSink const & arg0) [copy constructor] + ## athstats-helper.h (module 'wifi'): ns3::AthstatsWifiTraceSink::AthstatsWifiTraceSink(ns3::AthstatsWifiTraceSink const & arg0) [constructor] cls.add_constructor([param('ns3::AthstatsWifiTraceSink const &', 'arg0')]) ## athstats-helper.h (module 'wifi'): ns3::AthstatsWifiTraceSink::AthstatsWifiTraceSink() [constructor] cls.add_constructor([]) - ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::DevRxTrace(std::string context, ns3::Ptr p) [member function] + ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::DevRxTrace(std::string context, ns3::Ptr p) [member function] cls.add_method('DevRxTrace', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::DevTxTrace(std::string context, ns3::Ptr p) [member function] + ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::DevTxTrace(std::string context, ns3::Ptr p) [member function] cls.add_method('DevTxTrace', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')]) @@ -11466,11 +11611,11 @@ def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls): cls.add_method('Open', 'void', [param('std::string const &', 'name')]) - ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyRxErrorTrace(std::string context, ns3::Ptr packet, double snr) [member function] + ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyRxErrorTrace(std::string context, ns3::Ptr packet, double snr) [member function] cls.add_method('PhyRxErrorTrace', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('double', 'snr')]) - ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyRxOkTrace(std::string context, ns3::Ptr packet, double snr, ns3::WifiMode mode, ns3::WifiPreamble preamble) [member function] + ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyRxOkTrace(std::string context, ns3::Ptr packet, double snr, ns3::WifiMode mode, ns3::WifiPreamble preamble) [member function] cls.add_method('PhyRxOkTrace', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('double', 'snr'), param('ns3::WifiMode', 'mode'), param('ns3::WifiPreamble', 'preamble')]) @@ -11478,7 +11623,7 @@ def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls): cls.add_method('PhyStateTrace', 'void', [param('std::string', 'context'), param('ns3::Time', 'start'), param('ns3::Time', 'duration'), param('ns3::WifiPhy::State', 'state')]) - ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyTxTrace(std::string context, ns3::Ptr packet, ns3::WifiMode mode, ns3::WifiPreamble preamble, uint8_t txPower) [member function] + ## athstats-helper.h (module 'wifi'): void ns3::AthstatsWifiTraceSink::PhyTxTrace(std::string context, ns3::Ptr packet, ns3::WifiMode mode, ns3::WifiPreamble preamble, uint8_t txPower) [member function] cls.add_method('PhyTxTrace', 'void', [param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMode', 'mode'), param('ns3::WifiPreamble', 'preamble'), param('uint8_t', 'txPower')]) @@ -11501,7 +11646,7 @@ def register_Ns3AthstatsWifiTraceSink_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -11528,7 +11673,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -11570,7 +11715,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -11579,28 +11724,195 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_const=True, is_virtual=True) return +def register_Ns3BlockAckManager_methods(root_module, cls): + ## block-ack-manager.h (module 'wifi'): ns3::BlockAckManager::BlockAckManager() [constructor] + cls.add_constructor([]) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::AlreadyExists(uint16_t currentSeq, ns3::Mac48Address recipient, uint8_t tid) const [member function] + cls.add_method('AlreadyExists', + 'bool', + [param('uint16_t', 'currentSeq'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::CompleteAmpduExchange(ns3::Mac48Address recipient, uint8_t tid) [member function] + cls.add_method('CompleteAmpduExchange', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::CreateAgreement(ns3::MgtAddBaRequestHeader const * reqHdr, ns3::Mac48Address recipient) [member function] + cls.add_method('CreateAgreement', + 'void', + [param('ns3::MgtAddBaRequestHeader const *', 'reqHdr'), param('ns3::Mac48Address', 'recipient')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::DestroyAgreement(ns3::Mac48Address recipient, uint8_t tid) [member function] + cls.add_method('DestroyAgreement', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::ExistsAgreement(ns3::Mac48Address recipient, uint8_t tid) const [member function] + cls.add_method('ExistsAgreement', + 'bool', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::ExistsAgreementInState(ns3::Mac48Address recipient, uint8_t tid, ns3::OriginatorBlockAckAgreement::State state) const [member function] + cls.add_method('ExistsAgreementInState', + 'bool', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('ns3::OriginatorBlockAckAgreement::State', 'state')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNBufferedPackets(ns3::Mac48Address recipient, uint8_t tid) const [member function] + cls.add_method('GetNBufferedPackets', + 'uint32_t', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNRetryNeededPackets(ns3::Mac48Address recipient, uint8_t tid) const [member function] + cls.add_method('GetNRetryNeededPackets', + 'uint32_t', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::GetNextPacket(ns3::WifiMacHeader & hdr) [member function] + cls.add_method('GetNextPacket', + 'ns3::Ptr< ns3::Packet const >', + [param('ns3::WifiMacHeader &', 'hdr')]) + ## block-ack-manager.h (module 'wifi'): uint32_t ns3::BlockAckManager::GetNextPacketSize() const [member function] + cls.add_method('GetNextPacketSize', + 'uint32_t', + [], + is_const=True) + ## block-ack-manager.h (module 'wifi'): uint16_t ns3::BlockAckManager::GetSeqNumOfNextRetryPacket(ns3::Mac48Address recipient, uint8_t tid) const [member function] + cls.add_method('GetSeqNumOfNextRetryPacket', + 'uint16_t', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): static ns3::TypeId ns3::BlockAckManager::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasBar(ns3::Bar & bar) [member function] + cls.add_method('HasBar', + 'bool', + [param('ns3::Bar &', 'bar')]) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasOtherFragments(uint16_t sequenceNumber) const [member function] + cls.add_method('HasOtherFragments', + 'bool', + [param('uint16_t', 'sequenceNumber')], + is_const=True) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::HasPackets() const [member function] + cls.add_method('HasPackets', + 'bool', + [], + is_const=True) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::NeedBarRetransmission(uint8_t tid, uint16_t seqNumber, ns3::Mac48Address recipient) [member function] + cls.add_method('NeedBarRetransmission', + 'bool', + [param('uint8_t', 'tid'), param('uint16_t', 'seqNumber'), param('ns3::Mac48Address', 'recipient')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyAgreementEstablished(ns3::Mac48Address recipient, uint8_t tid, uint16_t startingSeq) [member function] + cls.add_method('NotifyAgreementEstablished', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'startingSeq')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyAgreementUnsuccessful(ns3::Mac48Address recipient, uint8_t tid) [member function] + cls.add_method('NotifyAgreementUnsuccessful', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyGotBlockAck(ns3::CtrlBAckResponseHeader const * blockAck, ns3::Mac48Address recipient, double rxSnr, ns3::WifiMode txMode, double dataSnr) [member function] + cls.add_method('NotifyGotBlockAck', + 'void', + [param('ns3::CtrlBAckResponseHeader const *', 'blockAck'), param('ns3::Mac48Address', 'recipient'), param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode'), param('double', 'dataSnr')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::NotifyMpduTransmission(ns3::Mac48Address recipient, uint8_t tid, uint16_t nextSeqNumber, ns3::WifiMacHeader::QosAckPolicy policy) [member function] + cls.add_method('NotifyMpduTransmission', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'nextSeqNumber'), param('ns3::WifiMacHeader::QosAckPolicy', 'policy')]) + ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::PeekNextPacket(ns3::WifiMacHeader & hdr) [member function] + cls.add_method('PeekNextPacket', + 'ns3::Ptr< ns3::Packet const >', + [param('ns3::WifiMacHeader &', 'hdr')]) + ## block-ack-manager.h (module 'wifi'): ns3::Ptr ns3::BlockAckManager::PeekNextPacketByTidAndAddress(ns3::WifiMacHeader & hdr, ns3::Mac48Address recipient, uint8_t tid, ns3::Time * timestamp) [member function] + cls.add_method('PeekNextPacketByTidAndAddress', + 'ns3::Ptr< ns3::Packet const >', + [param('ns3::WifiMacHeader &', 'hdr'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('ns3::Time *', 'timestamp')]) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::RemovePacket(uint8_t tid, ns3::Mac48Address recipient, uint16_t seqnumber) [member function] + cls.add_method('RemovePacket', + 'bool', + [param('uint8_t', 'tid'), param('ns3::Mac48Address', 'recipient'), param('uint16_t', 'seqnumber')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckInactivityCallback(ns3::Callback callback) [member function] + cls.add_method('SetBlockAckInactivityCallback', + 'void', + [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, bool, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckThreshold(uint8_t nPackets) [member function] + cls.add_method('SetBlockAckThreshold', + 'void', + [param('uint8_t', 'nPackets')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockAckType(ns3::BlockAckType bAckType) [member function] + cls.add_method('SetBlockAckType', + 'void', + [param('ns3::BlockAckType', 'bAckType')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetBlockDestinationCallback(ns3::Callback callback) [member function] + cls.add_method('SetBlockDestinationCallback', + 'void', + [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetMaxPacketDelay(ns3::Time maxDelay) [member function] + cls.add_method('SetMaxPacketDelay', + 'void', + [param('ns3::Time', 'maxDelay')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetQueue(ns3::Ptr > const queue) [member function] + cls.add_method('SetQueue', + 'void', + [param('ns3::Ptr< ns3::WifiQueue< ns3::WifiMacQueueItem > > const', 'queue')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxFailedCallback(ns3::BlockAckManager::TxFailed callback) [member function] + cls.add_method('SetTxFailedCallback', + 'void', + [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxMiddle(ns3::Ptr const txMiddle) [member function] + cls.add_method('SetTxMiddle', + 'void', + [param('ns3::Ptr< ns3::MacTxMiddle > const', 'txMiddle')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxOkCallback(ns3::BlockAckManager::TxOk callback) [member function] + cls.add_method('SetTxOkCallback', + 'void', + [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetUnblockDestinationCallback(ns3::Callback callback) [member function] + cls.add_method('SetUnblockDestinationCallback', + 'void', + [param('ns3::Callback< void, ns3::Mac48Address, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetWifiRemoteStationManager(ns3::Ptr const manager) [member function] + cls.add_method('SetWifiRemoteStationManager', + 'void', + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'manager')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::StorePacket(ns3::Ptr packet, ns3::WifiMacHeader const & hdr, ns3::Time tStamp) [member function] + cls.add_method('StorePacket', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr'), param('ns3::Time', 'tStamp')]) + ## block-ack-manager.h (module 'wifi'): bool ns3::BlockAckManager::SwitchToBlockAckIfNeeded(ns3::Mac48Address recipient, uint8_t tid, uint16_t startingSeq) [member function] + cls.add_method('SwitchToBlockAckIfNeeded', + 'bool', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('uint16_t', 'startingSeq')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::TearDownBlockAck(ns3::Mac48Address recipient, uint8_t tid) [member function] + cls.add_method('TearDownBlockAck', + 'void', + [param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid')]) + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::UpdateAgreement(ns3::MgtAddBaResponseHeader const * respHdr, ns3::Mac48Address recipient) [member function] + cls.add_method('UpdateAgreement', + 'void', + [param('ns3::MgtAddBaResponseHeader const *', 'respHdr'), param('ns3::Mac48Address', 'recipient')]) + return + def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -11611,7 +11923,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -11621,7 +11933,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -11635,21 +11947,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -11659,10 +11971,145 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned long']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'double']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Mac48Address']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiTxVector']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::MpduInfo']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::SignalNoiseDbm']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiMacHeader const*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiMacHeader const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Time']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::DataRate']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiPhy::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiMode']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::WifiPreamble']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'int']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -11673,12 +12120,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -11690,7 +12137,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3CaraWifiManager_methods(root_module, cls): - ## cara-wifi-manager.h (module 'wifi'): ns3::CaraWifiManager::CaraWifiManager(ns3::CaraWifiManager const & arg0) [copy constructor] + ## cara-wifi-manager.h (module 'wifi'): ns3::CaraWifiManager::CaraWifiManager(ns3::CaraWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::CaraWifiManager const &', 'arg0')]) ## cara-wifi-manager.h (module 'wifi'): ns3::CaraWifiManager::CaraWifiManager() [constructor] cls.add_constructor([]) @@ -11729,7 +12176,7 @@ def register_Ns3CaraWifiManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], visibility='private', is_virtual=True) - ## cara-wifi-manager.h (module 'wifi'): bool ns3::CaraWifiManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] + ## cara-wifi-manager.h (module 'wifi'): bool ns3::CaraWifiManager::DoNeedRts(ns3::WifiRemoteStation * station, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRts', 'bool', [param('ns3::WifiRemoteStation *', 'station'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -11777,7 +12224,7 @@ def register_Ns3CaraWifiManager_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -11837,7 +12284,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3ConstantRateWifiManager_methods(root_module, cls): - ## constant-rate-wifi-manager.h (module 'wifi'): ns3::ConstantRateWifiManager::ConstantRateWifiManager(ns3::ConstantRateWifiManager const & arg0) [copy constructor] + ## constant-rate-wifi-manager.h (module 'wifi'): ns3::ConstantRateWifiManager::ConstantRateWifiManager(ns3::ConstantRateWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::ConstantRateWifiManager const &', 'arg0')]) ## constant-rate-wifi-manager.h (module 'wifi'): ns3::ConstantRateWifiManager::ConstantRateWifiManager() [constructor] cls.add_constructor([]) @@ -11904,7 +12351,7 @@ def register_Ns3ConstantRateWifiManager_methods(root_module, cls): return def register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, cls): - ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [copy constructor] + ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel(ns3::ConstantSpeedPropagationDelayModel const & arg0) [constructor] cls.add_constructor([param('ns3::ConstantSpeedPropagationDelayModel const &', 'arg0')]) ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel() [constructor] cls.add_constructor([]) @@ -12008,7 +12455,7 @@ def register_Ns3Cost231PropagationLossModel_methods(root_module, cls): return def register_Ns3CtrlBAckRequestHeader_methods(root_module, cls): - ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckRequestHeader::CtrlBAckRequestHeader(ns3::CtrlBAckRequestHeader const & arg0) [copy constructor] + ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckRequestHeader::CtrlBAckRequestHeader(ns3::CtrlBAckRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::CtrlBAckRequestHeader const &', 'arg0')]) ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckRequestHeader::CtrlBAckRequestHeader() [constructor] cls.add_constructor([]) @@ -12096,7 +12543,7 @@ def register_Ns3CtrlBAckRequestHeader_methods(root_module, cls): return def register_Ns3CtrlBAckResponseHeader_methods(root_module, cls): - ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckResponseHeader::CtrlBAckResponseHeader(ns3::CtrlBAckResponseHeader const & arg0) [copy constructor] + ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckResponseHeader::CtrlBAckResponseHeader(ns3::CtrlBAckResponseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::CtrlBAckResponseHeader const &', 'arg0')]) ## ctrl-headers.h (module 'wifi'): ns3::CtrlBAckResponseHeader::CtrlBAckResponseHeader() [constructor] cls.add_constructor([]) @@ -12222,23 +12669,23 @@ def register_Ns3CtrlBAckResponseHeader_methods(root_module, cls): def register_Ns3DataRateChecker_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')]) return def register_Ns3DataRateValue_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'value')]) + ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::Ptr ns3::DataRateValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12248,7 +12695,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): 'ns3::DataRate', [], is_const=True) - ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12260,7 +12707,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): return def register_Ns3DcaTxop_methods(root_module, cls): - ## dca-txop.h (module 'wifi'): ns3::DcaTxop::DcaTxop(ns3::DcaTxop const & arg0) [copy constructor] + ## dca-txop.h (module 'wifi'): ns3::DcaTxop::DcaTxop(ns3::DcaTxop const & arg0) [constructor] cls.add_constructor([param('ns3::DcaTxop const &', 'arg0')]) ## dca-txop.h (module 'wifi'): ns3::DcaTxop::DcaTxop() [constructor] cls.add_constructor([]) @@ -12363,7 +12810,7 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'void', [], is_virtual=True) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::Queue(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::Queue(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] cls.add_method('Queue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr')], @@ -12372,14 +12819,14 @@ def register_Ns3DcaTxop_methods(root_module, cls): cls.add_method('SetAifsn', 'void', [param('uint32_t', 'aifsn')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetLow(ns3::Ptr low) [member function] + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetLow(ns3::Ptr const low) [member function] cls.add_method('SetLow', 'void', - [param('ns3::Ptr< ns3::MacLow >', 'low')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetManager(ns3::DcfManager * manager) [member function] + [param('ns3::Ptr< ns3::MacLow > const', 'low')]) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetManager(ns3::Ptr const manager) [member function] cls.add_method('SetManager', 'void', - [param('ns3::DcfManager *', 'manager')]) + [param('ns3::Ptr< ns3::DcfManager > const', 'manager')]) ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetMaxCw(uint32_t maxCw) [member function] cls.add_method('SetMaxCw', 'void', @@ -12388,15 +12835,19 @@ def register_Ns3DcaTxop_methods(root_module, cls): cls.add_method('SetMinCw', 'void', [param('uint32_t', 'minCw')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxFailedCallback(ns3::Callback callback) [member function] + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxDroppedCallback(ns3::DcaTxop::TxDropped callback) [member function] + cls.add_method('SetTxDroppedCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxFailedCallback(ns3::DcaTxop::TxFailed callback) [member function] cls.add_method('SetTxFailedCallback', 'void', [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxMiddle(ns3::MacTxMiddle * txMiddle) [member function] + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxMiddle(ns3::Ptr const txMiddle) [member function] cls.add_method('SetTxMiddle', 'void', - [param('ns3::MacTxMiddle *', 'txMiddle')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxOkCallback(ns3::Callback callback) [member function] + [param('ns3::Ptr< ns3::MacTxMiddle > const', 'txMiddle')]) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetTxOkCallback(ns3::DcaTxop::TxOk callback) [member function] cls.add_method('SetTxOkCallback', 'void', [param('ns3::Callback< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -12404,10 +12855,10 @@ def register_Ns3DcaTxop_methods(root_module, cls): cls.add_method('SetTxopLimit', 'void', [param('ns3::Time', 'txopLimit')]) - ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetWifiRemoteStationManager(ns3::Ptr remoteManager) [member function] + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::SetWifiRemoteStationManager(ns3::Ptr const remoteManager) [member function] cls.add_method('SetWifiRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'remoteManager')], + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'remoteManager')], is_virtual=True) ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::StartNextFragment() [member function] cls.add_method('StartNextFragment', @@ -12454,7 +12905,7 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'bool', [], is_const=True, visibility='protected', is_virtual=True) - ## dca-txop.h (module 'wifi'): bool ns3::DcaTxop::NeedDataRetransmission(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] + ## dca-txop.h (module 'wifi'): bool ns3::DcaTxop::NeedDataRetransmission(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] cls.add_method('NeedDataRetransmission', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr')], @@ -12464,7 +12915,7 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'bool', [], is_const=True, visibility='protected', is_virtual=True) - ## dca-txop.h (module 'wifi'): bool ns3::DcaTxop::NeedRtsRetransmission(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] + ## dca-txop.h (module 'wifi'): bool ns3::DcaTxop::NeedRtsRetransmission(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] cls.add_method('NeedRtsRetransmission', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr')], @@ -12504,17 +12955,22 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) + ## dca-txop.h (module 'wifi'): void ns3::DcaTxop::TxDroppedPacket(ns3::Ptr item) [member function] + cls.add_method('TxDroppedPacket', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem const >', 'item')], + visibility='protected') return def register_Ns3DcfManager_methods(root_module, cls): - ## dcf-manager.h (module 'wifi'): ns3::DcfManager::DcfManager(ns3::DcfManager const & arg0) [copy constructor] + ## dcf-manager.h (module 'wifi'): ns3::DcfManager::DcfManager(ns3::DcfManager const & arg0) [constructor] cls.add_constructor([param('ns3::DcfManager const &', 'arg0')]) ## dcf-manager.h (module 'wifi'): ns3::DcfManager::DcfManager() [constructor] cls.add_constructor([]) - ## dcf-manager.h (module 'wifi'): void ns3::DcfManager::Add(ns3::DcfState * dcf) [member function] + ## dcf-manager.h (module 'wifi'): void ns3::DcfManager::Add(ns3::Ptr dcf) [member function] cls.add_method('Add', 'void', - [param('ns3::DcfState *', 'dcf')]) + [param('ns3::Ptr< ns3::DcfState >', 'dcf')]) ## dcf-manager.h (module 'wifi'): ns3::Time ns3::DcfManager::GetEifsNoDifs() const [member function] cls.add_method('GetEifsNoDifs', 'ns3::Time', @@ -12580,10 +13036,10 @@ def register_Ns3DcfManager_methods(root_module, cls): cls.add_method('RemovePhyListener', 'void', [param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) - ## dcf-manager.h (module 'wifi'): void ns3::DcfManager::RequestAccess(ns3::DcfState * state) [member function] + ## dcf-manager.h (module 'wifi'): void ns3::DcfManager::RequestAccess(ns3::Ptr state) [member function] cls.add_method('RequestAccess', 'void', - [param('ns3::DcfState *', 'state')]) + [param('ns3::Ptr< ns3::DcfState >', 'state')]) ## dcf-manager.h (module 'wifi'): void ns3::DcfManager::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] cls.add_method('SetEifsNoDifs', 'void', @@ -12606,39 +13062,164 @@ def register_Ns3DcfManager_methods(root_module, cls): [param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) return -def register_Ns3DeterministicRandomVariable_methods(root_module, cls): - ## random-variable-stream.h (module 'core'): static ns3::TypeId ns3::DeterministicRandomVariable::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', +def register_Ns3DcfState_methods(root_module, cls): + ## dcf-state.h (module 'wifi'): ns3::DcfState::DcfState(ns3::DcfState const & arg0) [constructor] + cls.add_constructor([param('ns3::DcfState const &', 'arg0')]) + ## dcf-state.h (module 'wifi'): ns3::DcfState::DcfState(ns3::Ptr txop) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::DcaTxop >', 'txop')]) + ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetAifsn() const [member function] + cls.add_method('GetAifsn', + 'uint32_t', [], - is_static=True) - ## random-variable-stream.h (module 'core'): ns3::DeterministicRandomVariable::DeterministicRandomVariable() [constructor] - cls.add_constructor([]) - ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] - cls.add_method('SetValueArray', - 'void', - [param('double *', 'values'), param('uint64_t', 'length')]) - ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] - cls.add_method('GetValue', - 'double', + is_const=True) + ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCw() const [member function] + cls.add_method('GetCw', + 'uint32_t', [], - is_virtual=True) - ## random-variable-stream.h (module 'core'): uint32_t ns3::DeterministicRandomVariable::GetInteger() [member function] - cls.add_method('GetInteger', + is_const=True) + ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCwMax() const [member function] + cls.add_method('GetCwMax', 'uint32_t', [], - is_virtual=True) - return - -def register_Ns3DeviceEnergyModel_methods(root_module, cls): - ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DeviceEnergyModel const &', 'arg0')]) - ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel() [constructor] - cls.add_constructor([]) - ## device-energy-model.h (module 'energy'): void ns3::DeviceEnergyModel::ChangeState(int newState) [member function] - cls.add_method('ChangeState', - 'void', - [param('int', 'newState')], + is_const=True) + ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetCwMin() const [member function] + cls.add_method('GetCwMin', + 'uint32_t', + [], + is_const=True) + ## dcf-state.h (module 'wifi'): ns3::Time ns3::DcfState::GetTxopLimit() const [member function] + cls.add_method('GetTxopLimit', + 'ns3::Time', + [], + is_const=True) + ## dcf-state.h (module 'wifi'): static ns3::TypeId ns3::DcfState::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## dcf-state.h (module 'wifi'): bool ns3::DcfState::IsAccessRequested() const [member function] + cls.add_method('IsAccessRequested', + 'bool', + [], + is_const=True) + ## dcf-state.h (module 'wifi'): bool ns3::DcfState::IsEdca() const [member function] + cls.add_method('IsEdca', + 'bool', + [], + is_const=True) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::ResetCw() [member function] + cls.add_method('ResetCw', + 'void', + []) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetAifsn(uint32_t aifsn) [member function] + cls.add_method('SetAifsn', + 'void', + [param('uint32_t', 'aifsn')]) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetCwMax(uint32_t maxCw) [member function] + cls.add_method('SetCwMax', + 'void', + [param('uint32_t', 'maxCw')]) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetCwMin(uint32_t minCw) [member function] + cls.add_method('SetCwMin', + 'void', + [param('uint32_t', 'minCw')]) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::SetTxopLimit(ns3::Time txopLimit) [member function] + cls.add_method('SetTxopLimit', + 'void', + [param('ns3::Time', 'txopLimit')]) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::StartBackoffNow(uint32_t nSlots) [member function] + cls.add_method('StartBackoffNow', + 'void', + [param('uint32_t', 'nSlots')]) + ## dcf-state.h (module 'wifi'): void ns3::DcfState::UpdateFailedCw() [member function] + cls.add_method('UpdateFailedCw', + 'void', + []) + ## dcf-state.h (module 'wifi'): uint32_t ns3::DcfState::GetBackoffSlots() const [member function] + cls.add_method('GetBackoffSlots', + 'uint32_t', + [], + is_const=True, visibility='protected') + ## dcf-state.h (module 'wifi'): ns3::Time ns3::DcfState::GetBackoffStart() const [member function] + cls.add_method('GetBackoffStart', + 'ns3::Time', + [], + is_const=True, visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyAccessGranted() [member function] + cls.add_method('NotifyAccessGranted', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyAccessRequested() [member function] + cls.add_method('NotifyAccessRequested', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyChannelSwitching() [member function] + cls.add_method('NotifyChannelSwitching', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyCollision() [member function] + cls.add_method('NotifyCollision', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyInternalCollision() [member function] + cls.add_method('NotifyInternalCollision', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifySleep() [member function] + cls.add_method('NotifySleep', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::NotifyWakeUp() [member function] + cls.add_method('NotifyWakeUp', + 'void', + [], + visibility='protected') + ## dcf-state.h (module 'wifi'): void ns3::DcfState::UpdateBackoffSlotsNow(uint32_t nSlots, ns3::Time backoffUpdateBound) [member function] + cls.add_method('UpdateBackoffSlotsNow', + 'void', + [param('uint32_t', 'nSlots'), param('ns3::Time', 'backoffUpdateBound')], + visibility='protected') + return + +def register_Ns3DeterministicRandomVariable_methods(root_module, cls): + ## random-variable-stream.h (module 'core'): static ns3::TypeId ns3::DeterministicRandomVariable::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## random-variable-stream.h (module 'core'): ns3::DeterministicRandomVariable::DeterministicRandomVariable() [constructor] + cls.add_constructor([]) + ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] + cls.add_method('SetValueArray', + 'void', + [param('double *', 'values'), param('uint64_t', 'length')]) + ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] + cls.add_method('GetValue', + 'double', + [], + is_virtual=True) + ## random-variable-stream.h (module 'core'): uint32_t ns3::DeterministicRandomVariable::GetInteger() [member function] + cls.add_method('GetInteger', + 'uint32_t', + [], + is_virtual=True) + return + +def register_Ns3DeviceEnergyModel_methods(root_module, cls): + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [constructor] + cls.add_constructor([param('ns3::DeviceEnergyModel const &', 'arg0')]) + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel() [constructor] + cls.add_constructor([]) + ## device-energy-model.h (module 'energy'): void ns3::DeviceEnergyModel::ChangeState(int newState) [member function] + cls.add_method('ChangeState', + 'void', + [param('int', 'newState')], is_pure_virtual=True, is_virtual=True) ## device-energy-model.h (module 'energy'): double ns3::DeviceEnergyModel::GetCurrentA() const [member function] cls.add_method('GetCurrentA', @@ -12680,16 +13261,16 @@ def register_Ns3DeviceEnergyModel_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12699,7 +13280,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12712,7 +13293,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): def register_Ns3DsssParameterSet_methods(root_module, cls): cls.add_output_stream_operator() - ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSet::DsssParameterSet(ns3::DsssParameterSet const & arg0) [copy constructor] + ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSet::DsssParameterSet(ns3::DsssParameterSet const & arg0) [constructor] cls.add_constructor([param('ns3::DsssParameterSet const &', 'arg0')]) ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSet::DsssParameterSet() [constructor] cls.add_constructor([]) @@ -12764,23 +13345,23 @@ def register_Ns3DsssParameterSet_methods(root_module, cls): def register_Ns3DsssParameterSetChecker_methods(root_module, cls): ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetChecker::DsssParameterSetChecker() [constructor] cls.add_constructor([]) - ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetChecker::DsssParameterSetChecker(ns3::DsssParameterSetChecker const & arg0) [copy constructor] + ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetChecker::DsssParameterSetChecker(ns3::DsssParameterSetChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DsssParameterSetChecker const &', 'arg0')]) return def register_Ns3DsssParameterSetValue_methods(root_module, cls): ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetValue::DsssParameterSetValue() [constructor] cls.add_constructor([]) - ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetValue::DsssParameterSetValue(ns3::DsssParameterSetValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DsssParameterSetValue const &', 'arg0')]) ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetValue::DsssParameterSetValue(ns3::DsssParameterSet const & value) [constructor] cls.add_constructor([param('ns3::DsssParameterSet const &', 'value')]) + ## dsss-parameter-set.h (module 'wifi'): ns3::DsssParameterSetValue::DsssParameterSetValue(ns3::DsssParameterSetValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DsssParameterSetValue const &', 'arg0')]) ## dsss-parameter-set.h (module 'wifi'): ns3::Ptr ns3::DsssParameterSetValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## dsss-parameter-set.h (module 'wifi'): bool ns3::DsssParameterSetValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## dsss-parameter-set.h (module 'wifi'): bool ns3::DsssParameterSetValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12790,7 +13371,7 @@ def register_Ns3DsssParameterSetValue_methods(root_module, cls): 'ns3::DsssParameterSet', [], is_const=True) - ## dsss-parameter-set.h (module 'wifi'): std::string ns3::DsssParameterSetValue::SerializeToString(ns3::Ptr checker) const [member function] + ## dsss-parameter-set.h (module 'wifi'): std::string ns3::DsssParameterSetValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -12803,7 +13384,7 @@ def register_Ns3DsssParameterSetValue_methods(root_module, cls): def register_Ns3EdcaParameterSet_methods(root_module, cls): cls.add_output_stream_operator() - ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSet::EdcaParameterSet(ns3::EdcaParameterSet const & arg0) [copy constructor] + ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSet::EdcaParameterSet(ns3::EdcaParameterSet const & arg0) [constructor] cls.add_constructor([param('ns3::EdcaParameterSet const &', 'arg0')]) ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSet::EdcaParameterSet() [constructor] cls.add_constructor([]) @@ -13076,23 +13657,23 @@ def register_Ns3EdcaParameterSet_methods(root_module, cls): def register_Ns3EdcaParameterSetChecker_methods(root_module, cls): ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetChecker::EdcaParameterSetChecker() [constructor] cls.add_constructor([]) - ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetChecker::EdcaParameterSetChecker(ns3::EdcaParameterSetChecker const & arg0) [copy constructor] + ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetChecker::EdcaParameterSetChecker(ns3::EdcaParameterSetChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EdcaParameterSetChecker const &', 'arg0')]) return def register_Ns3EdcaParameterSetValue_methods(root_module, cls): ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetValue::EdcaParameterSetValue() [constructor] cls.add_constructor([]) - ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetValue::EdcaParameterSetValue(ns3::EdcaParameterSetValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::EdcaParameterSetValue const &', 'arg0')]) ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetValue::EdcaParameterSetValue(ns3::EdcaParameterSet const & value) [constructor] cls.add_constructor([param('ns3::EdcaParameterSet const &', 'value')]) + ## edca-parameter-set.h (module 'wifi'): ns3::EdcaParameterSetValue::EdcaParameterSetValue(ns3::EdcaParameterSetValue const & arg0) [constructor] + cls.add_constructor([param('ns3::EdcaParameterSetValue const &', 'arg0')]) ## edca-parameter-set.h (module 'wifi'): ns3::Ptr ns3::EdcaParameterSetValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## edca-parameter-set.h (module 'wifi'): bool ns3::EdcaParameterSetValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## edca-parameter-set.h (module 'wifi'): bool ns3::EdcaParameterSetValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13102,7 +13683,7 @@ def register_Ns3EdcaParameterSetValue_methods(root_module, cls): 'ns3::EdcaParameterSet', [], is_const=True) - ## edca-parameter-set.h (module 'wifi'): std::string ns3::EdcaParameterSetValue::SerializeToString(ns3::Ptr checker) const [member function] + ## edca-parameter-set.h (module 'wifi'): std::string ns3::EdcaParameterSetValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13114,7 +13695,7 @@ def register_Ns3EdcaParameterSetValue_methods(root_module, cls): return def register_Ns3EdcaTxopN_methods(root_module, cls): - ## edca-txop-n.h (module 'wifi'): ns3::EdcaTxopN::EdcaTxopN(ns3::EdcaTxopN const & arg0) [copy constructor] + ## edca-txop-n.h (module 'wifi'): ns3::EdcaTxopN::EdcaTxopN(ns3::EdcaTxopN const & arg0) [constructor] cls.add_constructor([param('ns3::EdcaTxopN const &', 'arg0')]) ## edca-txop-n.h (module 'wifi'): ns3::EdcaTxopN::EdcaTxopN() [constructor] cls.add_constructor([]) @@ -13134,7 +13715,7 @@ def register_Ns3EdcaTxopN_methods(root_module, cls): cls.add_method('CompleteConfig', 'void', []) - ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::CompleteMpduTx(ns3::Ptr packet, ns3::WifiMacHeader hdr, ns3::Time tstamp) [member function] + ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::CompleteMpduTx(ns3::Ptr packet, ns3::WifiMacHeader hdr, ns3::Time tstamp) [member function] cls.add_method('CompleteMpduTx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader', 'hdr'), param('ns3::Time', 'tstamp')]) @@ -13272,7 +13853,7 @@ def register_Ns3EdcaTxopN_methods(root_module, cls): 'void', [], is_virtual=True) - ## edca-txop-n.h (module 'wifi'): ns3::Ptr ns3::EdcaTxopN::PeekNextRetransmitPacket(ns3::WifiMacHeader & header, ns3::Mac48Address recipient, uint8_t tid, ns3::Time * timestamp) [member function] + ## edca-txop-n.h (module 'wifi'): ns3::Ptr ns3::EdcaTxopN::PeekNextRetransmitPacket(ns3::WifiMacHeader & header, ns3::Mac48Address recipient, uint8_t tid, ns3::Time * timestamp) [member function] cls.add_method('PeekNextRetransmitPacket', 'ns3::Ptr< ns3::Packet const >', [param('ns3::WifiMacHeader &', 'header'), param('ns3::Mac48Address', 'recipient'), param('uint8_t', 'tid'), param('ns3::Time *', 'timestamp')]) @@ -13280,7 +13861,7 @@ def register_Ns3EdcaTxopN_methods(root_module, cls): cls.add_method('PeekNextSequenceNumberFor', 'uint16_t', [param('ns3::WifiMacHeader *', 'hdr')]) - ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::PushFront(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] + ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::PushFront(ns3::Ptr packet, ns3::WifiMacHeader const & hdr) [member function] cls.add_method('PushFront', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const &', 'hdr')]) @@ -13313,22 +13894,22 @@ def register_Ns3EdcaTxopN_methods(root_module, cls): cls.add_method('SetBlockAckThreshold', 'void', [param('uint8_t', 'threshold')]) - ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetMpduAggregator(ns3::Ptr aggr) [member function] + ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetMpduAggregator(ns3::Ptr const aggr) [member function] cls.add_method('SetMpduAggregator', 'void', - [param('ns3::Ptr< ns3::MpduAggregator >', 'aggr')]) - ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetMsduAggregator(ns3::Ptr aggr) [member function] + [param('ns3::Ptr< ns3::MpduAggregator > const', 'aggr')]) + ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetMsduAggregator(ns3::Ptr const aggr) [member function] cls.add_method('SetMsduAggregator', 'void', - [param('ns3::Ptr< ns3::MsduAggregator >', 'aggr')]) + [param('ns3::Ptr< ns3::MsduAggregator > const', 'aggr')]) ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetTypeOfStation(ns3::TypeOfStation type) [member function] cls.add_method('SetTypeOfStation', 'void', [param('ns3::TypeOfStation', 'type')]) - ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetWifiRemoteStationManager(ns3::Ptr remoteManager) [member function] + ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::SetWifiRemoteStationManager(ns3::Ptr const remoteManager) [member function] cls.add_method('SetWifiRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'remoteManager')], + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'remoteManager')], is_virtual=True) ## edca-txop-n.h (module 'wifi'): void ns3::EdcaTxopN::StartAccessIfNeeded() [member function] cls.add_method('StartAccessIfNeeded', @@ -13414,7 +13995,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -13441,7 +14022,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -13478,7 +14059,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -13487,12 +14068,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13500,7 +14081,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnergyHarvester_methods(root_module, cls): - ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [copy constructor] + ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [constructor] cls.add_constructor([param('ns3::EnergyHarvester const &', 'arg0')]) ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester() [constructor] cls.add_constructor([]) @@ -13545,7 +14126,7 @@ def register_Ns3EnergyHarvester_methods(root_module, cls): return def register_Ns3EnergySource_methods(root_module, cls): - ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [copy constructor] + ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySource const &', 'arg0')]) ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource() [constructor] cls.add_constructor([]) @@ -13640,7 +14221,7 @@ def register_Ns3EnergySource_methods(root_module, cls): return def register_Ns3EnergySourceContainer_methods(root_module, cls): - ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [copy constructor] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceContainer const &', 'arg0')]) ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer() [constructor] cls.add_constructor([]) @@ -13662,14 +14243,14 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'sourceName')]) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::Begin() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::End() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) ## energy-source-container.h (module 'energy'): ns3::Ptr ns3::EnergySourceContainer::Get(uint32_t i) const [member function] @@ -13700,7 +14281,7 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -13745,7 +14326,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -13756,7 +14337,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13766,7 +14347,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13817,7 +14398,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): def register_Ns3ErpInformation_methods(root_module, cls): cls.add_output_stream_operator() - ## erp-information.h (module 'wifi'): ns3::ErpInformation::ErpInformation(ns3::ErpInformation const & arg0) [copy constructor] + ## erp-information.h (module 'wifi'): ns3::ErpInformation::ErpInformation(ns3::ErpInformation const & arg0) [constructor] cls.add_constructor([param('ns3::ErpInformation const &', 'arg0')]) ## erp-information.h (module 'wifi'): ns3::ErpInformation::ErpInformation() [constructor] cls.add_constructor([]) @@ -13887,23 +14468,23 @@ def register_Ns3ErpInformation_methods(root_module, cls): def register_Ns3ErpInformationChecker_methods(root_module, cls): ## erp-information.h (module 'wifi'): ns3::ErpInformationChecker::ErpInformationChecker() [constructor] cls.add_constructor([]) - ## erp-information.h (module 'wifi'): ns3::ErpInformationChecker::ErpInformationChecker(ns3::ErpInformationChecker const & arg0) [copy constructor] + ## erp-information.h (module 'wifi'): ns3::ErpInformationChecker::ErpInformationChecker(ns3::ErpInformationChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ErpInformationChecker const &', 'arg0')]) return def register_Ns3ErpInformationValue_methods(root_module, cls): ## erp-information.h (module 'wifi'): ns3::ErpInformationValue::ErpInformationValue() [constructor] cls.add_constructor([]) - ## erp-information.h (module 'wifi'): ns3::ErpInformationValue::ErpInformationValue(ns3::ErpInformationValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ErpInformationValue const &', 'arg0')]) ## erp-information.h (module 'wifi'): ns3::ErpInformationValue::ErpInformationValue(ns3::ErpInformation const & value) [constructor] cls.add_constructor([param('ns3::ErpInformation const &', 'value')]) + ## erp-information.h (module 'wifi'): ns3::ErpInformationValue::ErpInformationValue(ns3::ErpInformationValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ErpInformationValue const &', 'arg0')]) ## erp-information.h (module 'wifi'): ns3::Ptr ns3::ErpInformationValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## erp-information.h (module 'wifi'): bool ns3::ErpInformationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## erp-information.h (module 'wifi'): bool ns3::ErpInformationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13913,7 +14494,7 @@ def register_Ns3ErpInformationValue_methods(root_module, cls): 'ns3::ErpInformation', [], is_const=True) - ## erp-information.h (module 'wifi'): std::string ns3::ErpInformationValue::SerializeToString(ns3::Ptr checker) const [member function] + ## erp-information.h (module 'wifi'): std::string ns3::ErpInformationValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13927,7 +14508,7 @@ def register_Ns3ErpInformationValue_methods(root_module, cls): def register_Ns3ErrorRateModel_methods(root_module, cls): ## error-rate-model.h (module 'wifi'): ns3::ErrorRateModel::ErrorRateModel() [constructor] cls.add_constructor([]) - ## error-rate-model.h (module 'wifi'): ns3::ErrorRateModel::ErrorRateModel(ns3::ErrorRateModel const & arg0) [copy constructor] + ## error-rate-model.h (module 'wifi'): ns3::ErrorRateModel::ErrorRateModel(ns3::ErrorRateModel const & arg0) [constructor] cls.add_constructor([param('ns3::ErrorRateModel const &', 'arg0')]) ## error-rate-model.h (module 'wifi'): double ns3::ErrorRateModel::CalculateSnr(ns3::WifiTxVector txVector, double ber) const [member function] cls.add_method('CalculateSnr', @@ -13947,7 +14528,7 @@ def register_Ns3ErrorRateModel_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -14009,7 +14590,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): return def register_Ns3ExtendedSupportedRatesIE_methods(root_module, cls): - ## supported-rates.h (module 'wifi'): ns3::ExtendedSupportedRatesIE::ExtendedSupportedRatesIE(ns3::ExtendedSupportedRatesIE const & arg0) [copy constructor] + ## supported-rates.h (module 'wifi'): ns3::ExtendedSupportedRatesIE::ExtendedSupportedRatesIE(ns3::ExtendedSupportedRatesIE const & arg0) [constructor] cls.add_constructor([param('ns3::ExtendedSupportedRatesIE const &', 'arg0')]) ## supported-rates.h (module 'wifi'): ns3::ExtendedSupportedRatesIE::ExtendedSupportedRatesIE() [constructor] cls.add_constructor([]) @@ -14075,6 +14656,23 @@ def register_Ns3FixedRssLossModel_methods(root_module, cls): visibility='private', is_virtual=True) return +def register_Ns3FrameCaptureModel_methods(root_module, cls): + ## frame-capture-model.h (module 'wifi'): ns3::FrameCaptureModel::FrameCaptureModel() [constructor] + cls.add_constructor([]) + ## frame-capture-model.h (module 'wifi'): ns3::FrameCaptureModel::FrameCaptureModel(ns3::FrameCaptureModel const & arg0) [constructor] + cls.add_constructor([param('ns3::FrameCaptureModel const &', 'arg0')]) + ## frame-capture-model.h (module 'wifi'): bool ns3::FrameCaptureModel::CaptureNewFrame(ns3::Ptr currentEvent, ns3::Ptr newEvent) const [member function] + cls.add_method('CaptureNewFrame', + 'bool', + [param('ns3::Ptr< ns3::InterferenceHelper::Event >', 'currentEvent'), param('ns3::Ptr< ns3::InterferenceHelper::Event >', 'newEvent')], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## frame-capture-model.h (module 'wifi'): static ns3::TypeId ns3::FrameCaptureModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + def register_Ns3FriisPropagationLossModel_methods(root_module, cls): ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::FriisPropagationLossModel::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -14162,7 +14760,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3HeCapabilities_methods(root_module, cls): cls.add_output_stream_operator() - ## he-capabilities.h (module 'wifi'): ns3::HeCapabilities::HeCapabilities(ns3::HeCapabilities const & arg0) [copy constructor] + ## he-capabilities.h (module 'wifi'): ns3::HeCapabilities::HeCapabilities(ns3::HeCapabilities const & arg0) [constructor] cls.add_constructor([param('ns3::HeCapabilities const &', 'arg0')]) ## he-capabilities.h (module 'wifi'): ns3::HeCapabilities::HeCapabilities() [constructor] cls.add_constructor([]) @@ -14292,23 +14890,23 @@ def register_Ns3HeCapabilities_methods(root_module, cls): def register_Ns3HeCapabilitiesChecker_methods(root_module, cls): ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesChecker::HeCapabilitiesChecker() [constructor] cls.add_constructor([]) - ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesChecker::HeCapabilitiesChecker(ns3::HeCapabilitiesChecker const & arg0) [copy constructor] + ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesChecker::HeCapabilitiesChecker(ns3::HeCapabilitiesChecker const & arg0) [constructor] cls.add_constructor([param('ns3::HeCapabilitiesChecker const &', 'arg0')]) return def register_Ns3HeCapabilitiesValue_methods(root_module, cls): ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesValue::HeCapabilitiesValue() [constructor] cls.add_constructor([]) - ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesValue::HeCapabilitiesValue(ns3::HeCapabilitiesValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::HeCapabilitiesValue const &', 'arg0')]) ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesValue::HeCapabilitiesValue(ns3::HeCapabilities const & value) [constructor] cls.add_constructor([param('ns3::HeCapabilities const &', 'value')]) + ## he-capabilities.h (module 'wifi'): ns3::HeCapabilitiesValue::HeCapabilitiesValue(ns3::HeCapabilitiesValue const & arg0) [constructor] + cls.add_constructor([param('ns3::HeCapabilitiesValue const &', 'arg0')]) ## he-capabilities.h (module 'wifi'): ns3::Ptr ns3::HeCapabilitiesValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## he-capabilities.h (module 'wifi'): bool ns3::HeCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## he-capabilities.h (module 'wifi'): bool ns3::HeCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14318,7 +14916,7 @@ def register_Ns3HeCapabilitiesValue_methods(root_module, cls): 'ns3::HeCapabilities', [], is_const=True) - ## he-capabilities.h (module 'wifi'): std::string ns3::HeCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] + ## he-capabilities.h (module 'wifi'): std::string ns3::HeCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14331,7 +14929,7 @@ def register_Ns3HeCapabilitiesValue_methods(root_module, cls): def register_Ns3HtCapabilities_methods(root_module, cls): cls.add_output_stream_operator() - ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilities::HtCapabilities(ns3::HtCapabilities const & arg0) [copy constructor] + ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilities::HtCapabilities(ns3::HtCapabilities const & arg0) [constructor] cls.add_constructor([param('ns3::HtCapabilities const &', 'arg0')]) ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilities::HtCapabilities() [constructor] cls.add_constructor([]) @@ -14395,6 +14993,11 @@ def register_Ns3HtCapabilities_methods(root_module, cls): 'uint8_t', [], is_const=True) + ## ht-capabilities.h (module 'wifi'): uint8_t ns3::HtCapabilities::GetMinMpduStartSpace() const [member function] + cls.add_method('GetMinMpduStartSpace', + 'uint8_t', + [], + is_const=True) ## ht-capabilities.h (module 'wifi'): uint8_t ns3::HtCapabilities::GetRxHighestSupportedAntennas() const [member function] cls.add_method('GetRxHighestSupportedAntennas', 'uint8_t', @@ -14568,23 +15171,23 @@ def register_Ns3HtCapabilities_methods(root_module, cls): def register_Ns3HtCapabilitiesChecker_methods(root_module, cls): ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesChecker::HtCapabilitiesChecker() [constructor] cls.add_constructor([]) - ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesChecker::HtCapabilitiesChecker(ns3::HtCapabilitiesChecker const & arg0) [copy constructor] + ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesChecker::HtCapabilitiesChecker(ns3::HtCapabilitiesChecker const & arg0) [constructor] cls.add_constructor([param('ns3::HtCapabilitiesChecker const &', 'arg0')]) return def register_Ns3HtCapabilitiesValue_methods(root_module, cls): ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesValue::HtCapabilitiesValue() [constructor] cls.add_constructor([]) - ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesValue::HtCapabilitiesValue(ns3::HtCapabilitiesValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::HtCapabilitiesValue const &', 'arg0')]) ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesValue::HtCapabilitiesValue(ns3::HtCapabilities const & value) [constructor] cls.add_constructor([param('ns3::HtCapabilities const &', 'value')]) + ## ht-capabilities.h (module 'wifi'): ns3::HtCapabilitiesValue::HtCapabilitiesValue(ns3::HtCapabilitiesValue const & arg0) [constructor] + cls.add_constructor([param('ns3::HtCapabilitiesValue const &', 'arg0')]) ## ht-capabilities.h (module 'wifi'): ns3::Ptr ns3::HtCapabilitiesValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ht-capabilities.h (module 'wifi'): bool ns3::HtCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ht-capabilities.h (module 'wifi'): bool ns3::HtCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14594,7 +15197,7 @@ def register_Ns3HtCapabilitiesValue_methods(root_module, cls): 'ns3::HtCapabilities', [], is_const=True) - ## ht-capabilities.h (module 'wifi'): std::string ns3::HtCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ht-capabilities.h (module 'wifi'): std::string ns3::HtCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14607,7 +15210,7 @@ def register_Ns3HtCapabilitiesValue_methods(root_module, cls): def register_Ns3HtOperation_methods(root_module, cls): cls.add_output_stream_operator() - ## ht-operation.h (module 'wifi'): ns3::HtOperation::HtOperation(ns3::HtOperation const & arg0) [copy constructor] + ## ht-operation.h (module 'wifi'): ns3::HtOperation::HtOperation(ns3::HtOperation const & arg0) [constructor] cls.add_constructor([param('ns3::HtOperation const &', 'arg0')]) ## ht-operation.h (module 'wifi'): ns3::HtOperation::HtOperation() [constructor] cls.add_constructor([]) @@ -14861,23 +15464,23 @@ def register_Ns3HtOperation_methods(root_module, cls): def register_Ns3HtOperationChecker_methods(root_module, cls): ## ht-operation.h (module 'wifi'): ns3::HtOperationChecker::HtOperationChecker() [constructor] cls.add_constructor([]) - ## ht-operation.h (module 'wifi'): ns3::HtOperationChecker::HtOperationChecker(ns3::HtOperationChecker const & arg0) [copy constructor] + ## ht-operation.h (module 'wifi'): ns3::HtOperationChecker::HtOperationChecker(ns3::HtOperationChecker const & arg0) [constructor] cls.add_constructor([param('ns3::HtOperationChecker const &', 'arg0')]) return def register_Ns3HtOperationValue_methods(root_module, cls): ## ht-operation.h (module 'wifi'): ns3::HtOperationValue::HtOperationValue() [constructor] cls.add_constructor([]) - ## ht-operation.h (module 'wifi'): ns3::HtOperationValue::HtOperationValue(ns3::HtOperationValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::HtOperationValue const &', 'arg0')]) ## ht-operation.h (module 'wifi'): ns3::HtOperationValue::HtOperationValue(ns3::HtOperation const & value) [constructor] cls.add_constructor([param('ns3::HtOperation const &', 'value')]) + ## ht-operation.h (module 'wifi'): ns3::HtOperationValue::HtOperationValue(ns3::HtOperationValue const & arg0) [constructor] + cls.add_constructor([param('ns3::HtOperationValue const &', 'arg0')]) ## ht-operation.h (module 'wifi'): ns3::Ptr ns3::HtOperationValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ht-operation.h (module 'wifi'): bool ns3::HtOperationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ht-operation.h (module 'wifi'): bool ns3::HtOperationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14887,7 +15490,7 @@ def register_Ns3HtOperationValue_methods(root_module, cls): 'ns3::HtOperation', [], is_const=True) - ## ht-operation.h (module 'wifi'): std::string ns3::HtOperationValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ht-operation.h (module 'wifi'): std::string ns3::HtOperationValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -14899,7 +15502,7 @@ def register_Ns3HtOperationValue_methods(root_module, cls): return def register_Ns3HtWifiMacHelper_methods(root_module, cls): - ## ht-wifi-mac-helper.h (module 'wifi'): ns3::HtWifiMacHelper::HtWifiMacHelper(ns3::HtWifiMacHelper const & arg0) [copy constructor] + ## ht-wifi-mac-helper.h (module 'wifi'): ns3::HtWifiMacHelper::HtWifiMacHelper(ns3::HtWifiMacHelper const & arg0) [constructor] cls.add_constructor([param('ns3::HtWifiMacHelper const &', 'arg0')]) ## ht-wifi-mac-helper.h (module 'wifi'): ns3::HtWifiMacHelper::HtWifiMacHelper() [constructor] cls.add_constructor([]) @@ -14916,7 +15519,7 @@ def register_Ns3HtWifiMacHelper_methods(root_module, cls): return def register_Ns3IdealWifiManager_methods(root_module, cls): - ## ideal-wifi-manager.h (module 'wifi'): ns3::IdealWifiManager::IdealWifiManager(ns3::IdealWifiManager const & arg0) [copy constructor] + ## ideal-wifi-manager.h (module 'wifi'): ns3::IdealWifiManager::IdealWifiManager(ns3::IdealWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::IdealWifiManager const &', 'arg0')]) ## ideal-wifi-manager.h (module 'wifi'): ns3::IdealWifiManager::IdealWifiManager() [constructor] cls.add_constructor([]) @@ -14925,15 +15528,10 @@ def register_Ns3IdealWifiManager_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## ideal-wifi-manager.h (module 'wifi'): void ns3::IdealWifiManager::SetHeSupported(bool enable) [member function] - cls.add_method('SetHeSupported', - 'void', - [param('bool', 'enable')], - is_virtual=True) - ## ideal-wifi-manager.h (module 'wifi'): void ns3::IdealWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## ideal-wifi-manager.h (module 'wifi'): void ns3::IdealWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## ideal-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::IdealWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -15005,16 +15603,16 @@ def register_Ns3IdealWifiManager_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15024,7 +15622,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15038,23 +15636,23 @@ def register_Ns3IntegerValue_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15064,7 +15662,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15078,23 +15676,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15104,7 +15702,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15118,23 +15716,23 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15144,7 +15742,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15158,23 +15756,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15184,7 +15782,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15254,7 +15852,7 @@ def register_Ns3ItuR1411NlosOverRooftopPropagationLossModel_methods(root_module, return def register_Ns3JakesProcess_methods(root_module, cls): - ## jakes-process.h (module 'propagation'): ns3::JakesProcess::JakesProcess(ns3::JakesProcess const & arg0) [copy constructor] + ## jakes-process.h (module 'propagation'): ns3::JakesProcess::JakesProcess(ns3::JakesProcess const & arg0) [constructor] cls.add_constructor([param('ns3::JakesProcess const &', 'arg0')]) ## jakes-process.h (module 'propagation'): ns3::JakesProcess::JakesProcess() [constructor] cls.add_constructor([]) @@ -15330,7 +15928,7 @@ def register_Ns3Kun2600MhzPropagationLossModel_methods(root_module, cls): return def register_Ns3LinearWifiTxCurrentModel_methods(root_module, cls): - ## wifi-tx-current-model.h (module 'wifi'): ns3::LinearWifiTxCurrentModel::LinearWifiTxCurrentModel(ns3::LinearWifiTxCurrentModel const & arg0) [copy constructor] + ## wifi-tx-current-model.h (module 'wifi'): ns3::LinearWifiTxCurrentModel::LinearWifiTxCurrentModel(ns3::LinearWifiTxCurrentModel const & arg0) [constructor] cls.add_constructor([param('ns3::LinearWifiTxCurrentModel const &', 'arg0')]) ## wifi-tx-current-model.h (module 'wifi'): ns3::LinearWifiTxCurrentModel::LinearWifiTxCurrentModel() [constructor] cls.add_constructor([]) @@ -15447,23 +16045,23 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15473,7 +16071,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15485,25 +16083,25 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): return def register_Ns3MacLow_methods(root_module, cls): - ## mac-low.h (module 'wifi'): ns3::MacLow::MacLow(ns3::MacLow const & arg0) [copy constructor] + ## mac-low.h (module 'wifi'): ns3::MacLow::MacLow(ns3::MacLow const & arg0) [constructor] cls.add_constructor([param('ns3::MacLow const &', 'arg0')]) ## mac-low.h (module 'wifi'): ns3::MacLow::MacLow() [constructor] cls.add_constructor([]) - ## mac-low.h (module 'wifi'): ns3::Ptr ns3::MacLow::AggregateToAmpdu(ns3::Ptr packet, ns3::WifiMacHeader const hdr) [member function] + ## mac-low.h (module 'wifi'): ns3::Ptr ns3::MacLow::AggregateToAmpdu(ns3::Ptr packet, ns3::WifiMacHeader const hdr) [member function] cls.add_method('AggregateToAmpdu', 'ns3::Ptr< ns3::Packet >', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const', 'hdr')]) - ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateOverallTxFragmentTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & params, uint32_t fragmentSize) const [member function] + ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateOverallTxFragmentTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & params, uint32_t fragmentSize) const [member function] cls.add_method('CalculateOverallTxFragmentTime', 'ns3::Time', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr'), param('ns3::MacLowTransmissionParameters const &', 'params'), param('uint32_t', 'fragmentSize')], is_const=True) - ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateOverallTxTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & params) const [member function] + ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateOverallTxTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & params) const [member function] cls.add_method('CalculateOverallTxTime', 'ns3::Time', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr'), param('ns3::MacLowTransmissionParameters const &', 'params')], is_const=True) - ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateTransmissionTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & parameters) const [member function] + ## mac-low.h (module 'wifi'): ns3::Time ns3::MacLow::CalculateTransmissionTime(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters const & parameters) const [member function] cls.add_method('CalculateTransmissionTime', 'ns3::Time', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr'), param('ns3::MacLowTransmissionParameters const &', 'parameters')], @@ -15559,7 +16157,7 @@ def register_Ns3MacLow_methods(root_module, cls): 'bool', [], is_const=True) - ## mac-low.h (module 'wifi'): ns3::WifiTxVector ns3::MacLow::GetDataTxVector(ns3::Ptr packet, ns3::WifiMacHeader const * hdr) const [member function] + ## mac-low.h (module 'wifi'): ns3::WifiTxVector ns3::MacLow::GetDataTxVector(ns3::Ptr packet, ns3::WifiMacHeader const * hdr) const [member function] cls.add_method('GetDataTxVector', 'ns3::WifiTxVector', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr')], @@ -15655,10 +16253,10 @@ def register_Ns3MacLow_methods(root_module, cls): cls.add_method('SetCtsToSelfSupported', 'void', [param('bool', 'enable')]) - ## mac-low.h (module 'wifi'): void ns3::MacLow::SetPhy(ns3::Ptr phy) [member function] + ## mac-low.h (module 'wifi'): void ns3::MacLow::SetPhy(ns3::Ptr const phy) [member function] cls.add_method('SetPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')]) ## mac-low.h (module 'wifi'): void ns3::MacLow::SetPifs(ns3::Time pifs) [member function] cls.add_method('SetPifs', 'void', @@ -15671,7 +16269,7 @@ def register_Ns3MacLow_methods(root_module, cls): cls.add_method('SetRifs', 'void', [param('ns3::Time', 'rifs')]) - ## mac-low.h (module 'wifi'): void ns3::MacLow::SetRxCallback(ns3::Callback, ns3::WifiMacHeader const*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] + ## mac-low.h (module 'wifi'): void ns3::MacLow::SetRxCallback(ns3::Callback, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] cls.add_method('SetRxCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::WifiMacHeader const *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -15683,16 +16281,16 @@ def register_Ns3MacLow_methods(root_module, cls): cls.add_method('SetSlotTime', 'void', [param('ns3::Time', 'slotTime')]) - ## mac-low.h (module 'wifi'): void ns3::MacLow::SetWifiRemoteStationManager(ns3::Ptr manager) [member function] + ## mac-low.h (module 'wifi'): void ns3::MacLow::SetWifiRemoteStationManager(ns3::Ptr const manager) [member function] cls.add_method('SetWifiRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'manager')]) - ## mac-low.h (module 'wifi'): void ns3::MacLow::StartTransmission(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters parameters, ns3::Ptr dca) [member function] + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'manager')]) + ## mac-low.h (module 'wifi'): void ns3::MacLow::StartTransmission(ns3::Ptr packet, ns3::WifiMacHeader const * hdr, ns3::MacLowTransmissionParameters parameters, ns3::Ptr dca) [member function] cls.add_method('StartTransmission', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr'), param('ns3::MacLowTransmissionParameters', 'parameters'), param('ns3::Ptr< ns3::DcaTxop >', 'dca')], is_virtual=True) - ## mac-low.h (module 'wifi'): bool ns3::MacLow::StopMpduAggregation(ns3::Ptr peekedPacket, ns3::WifiMacHeader peekedHdr, ns3::Ptr aggregatedPacket, uint16_t size) const [member function] + ## mac-low.h (module 'wifi'): bool ns3::MacLow::StopMpduAggregation(ns3::Ptr peekedPacket, ns3::WifiMacHeader peekedHdr, ns3::Ptr aggregatedPacket, uint16_t size) const [member function] cls.add_method('StopMpduAggregation', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'peekedPacket'), param('ns3::WifiMacHeader', 'peekedHdr'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket'), param('uint16_t', 'size')], @@ -15704,6 +16302,41 @@ def register_Ns3MacLow_methods(root_module, cls): visibility='private', is_virtual=True) return +def register_Ns3MacRxMiddle_methods(root_module, cls): + ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle::MacRxMiddle(ns3::MacRxMiddle const & arg0) [constructor] + cls.add_constructor([param('ns3::MacRxMiddle const &', 'arg0')]) + ## mac-rx-middle.h (module 'wifi'): ns3::MacRxMiddle::MacRxMiddle() [constructor] + cls.add_constructor([]) + ## mac-rx-middle.h (module 'wifi'): void ns3::MacRxMiddle::Receive(ns3::Ptr packet, ns3::WifiMacHeader const * hdr) [member function] + cls.add_method('Receive', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr')]) + ## mac-rx-middle.h (module 'wifi'): void ns3::MacRxMiddle::SetForwardCallback(ns3::MacRxMiddle::ForwardUpCallback callback) [member function] + cls.add_method('SetForwardCallback', + 'void', + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::WifiMacHeader const *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + return + +def register_Ns3MacTxMiddle_methods(root_module, cls): + ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle::MacTxMiddle(ns3::MacTxMiddle const & arg0) [constructor] + cls.add_constructor([param('ns3::MacTxMiddle const &', 'arg0')]) + ## mac-tx-middle.h (module 'wifi'): ns3::MacTxMiddle::MacTxMiddle() [constructor] + cls.add_constructor([]) + ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::GetNextSeqNumberByTidAndAddress(uint8_t tid, ns3::Mac48Address addr) const [member function] + cls.add_method('GetNextSeqNumberByTidAndAddress', + 'uint16_t', + [param('uint8_t', 'tid'), param('ns3::Mac48Address', 'addr')], + is_const=True) + ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::GetNextSequenceNumberFor(ns3::WifiMacHeader const * hdr) [member function] + cls.add_method('GetNextSequenceNumberFor', + 'uint16_t', + [param('ns3::WifiMacHeader const *', 'hdr')]) + ## mac-tx-middle.h (module 'wifi'): uint16_t ns3::MacTxMiddle::PeekNextSequenceNumberFor(ns3::WifiMacHeader const * hdr) [member function] + cls.add_method('PeekNextSequenceNumberFor', + 'uint16_t', + [param('ns3::WifiMacHeader const *', 'hdr')]) + return + def register_Ns3MatrixPropagationLossModel_methods(root_module, cls): ## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::MatrixPropagationLossModel::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -15735,7 +16368,7 @@ def register_Ns3MatrixPropagationLossModel_methods(root_module, cls): def register_Ns3MgtBeaconHeader_methods(root_module, cls): ## mgt-headers.h (module 'wifi'): ns3::MgtBeaconHeader::MgtBeaconHeader() [constructor] cls.add_constructor([]) - ## mgt-headers.h (module 'wifi'): ns3::MgtBeaconHeader::MgtBeaconHeader(ns3::MgtBeaconHeader const & arg0) [copy constructor] + ## mgt-headers.h (module 'wifi'): ns3::MgtBeaconHeader::MgtBeaconHeader(ns3::MgtBeaconHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MgtBeaconHeader const &', 'arg0')]) ## mgt-headers.h (module 'wifi'): static ns3::TypeId ns3::MgtBeaconHeader::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -15745,7 +16378,7 @@ def register_Ns3MgtBeaconHeader_methods(root_module, cls): return def register_Ns3MinstrelHtWifiManager_methods(root_module, cls): - ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::MinstrelHtWifiManager::MinstrelHtWifiManager(ns3::MinstrelHtWifiManager const & arg0) [copy constructor] + ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::MinstrelHtWifiManager::MinstrelHtWifiManager(ns3::MinstrelHtWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::MinstrelHtWifiManager const &', 'arg0')]) ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::MinstrelHtWifiManager::MinstrelHtWifiManager() [constructor] cls.add_constructor([]) @@ -15763,15 +16396,15 @@ def register_Ns3MinstrelHtWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## minstrel-ht-wifi-manager.h (module 'wifi'): void ns3::MinstrelHtWifiManager::SetupMac(ns3::Ptr mac) [member function] + ## minstrel-ht-wifi-manager.h (module 'wifi'): void ns3::MinstrelHtWifiManager::SetupMac(ns3::Ptr const mac) [member function] cls.add_method('SetupMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')], + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')], is_virtual=True) - ## minstrel-ht-wifi-manager.h (module 'wifi'): void ns3::MinstrelHtWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## minstrel-ht-wifi-manager.h (module 'wifi'): void ns3::MinstrelHtWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## minstrel-ht-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::MinstrelHtWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -15793,7 +16426,7 @@ def register_Ns3MinstrelHtWifiManager_methods(root_module, cls): 'void', [], visibility='private', is_virtual=True) - ## minstrel-ht-wifi-manager.h (module 'wifi'): bool ns3::MinstrelHtWifiManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] + ## minstrel-ht-wifi-manager.h (module 'wifi'): bool ns3::MinstrelHtWifiManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedDataRetransmission', 'bool', [param('ns3::WifiRemoteStation *', 'st'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -15846,7 +16479,7 @@ def register_Ns3MinstrelHtWifiManager_methods(root_module, cls): return def register_Ns3MinstrelWifiManager_methods(root_module, cls): - ## minstrel-wifi-manager.h (module 'wifi'): ns3::MinstrelWifiManager::MinstrelWifiManager(ns3::MinstrelWifiManager const & arg0) [copy constructor] + ## minstrel-wifi-manager.h (module 'wifi'): ns3::MinstrelWifiManager::MinstrelWifiManager(ns3::MinstrelWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::MinstrelWifiManager const &', 'arg0')]) ## minstrel-wifi-manager.h (module 'wifi'): ns3::MinstrelWifiManager::MinstrelWifiManager() [constructor] cls.add_constructor([]) @@ -15898,15 +16531,15 @@ def register_Ns3MinstrelWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## minstrel-wifi-manager.h (module 'wifi'): void ns3::MinstrelWifiManager::SetupMac(ns3::Ptr mac) [member function] + ## minstrel-wifi-manager.h (module 'wifi'): void ns3::MinstrelWifiManager::SetupMac(ns3::Ptr const mac) [member function] cls.add_method('SetupMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')], + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')], is_virtual=True) - ## minstrel-wifi-manager.h (module 'wifi'): void ns3::MinstrelWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## minstrel-wifi-manager.h (module 'wifi'): void ns3::MinstrelWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## minstrel-wifi-manager.h (module 'wifi'): void ns3::MinstrelWifiManager::UpdatePacketCounters(ns3::MinstrelWifiRemoteStation * station) [member function] cls.add_method('UpdatePacketCounters', @@ -15939,7 +16572,7 @@ def register_Ns3MinstrelWifiManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], visibility='private', is_virtual=True) - ## minstrel-wifi-manager.h (module 'wifi'): bool ns3::MinstrelWifiManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] + ## minstrel-wifi-manager.h (module 'wifi'): bool ns3::MinstrelWifiManager::DoNeedDataRetransmission(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedDataRetransmission', 'bool', [param('ns3::WifiRemoteStation *', 'st'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -15987,7 +16620,7 @@ def register_Ns3MinstrelWifiManager_methods(root_module, cls): return def register_Ns3MobilityModel_methods(root_module, cls): - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor] + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [constructor] cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] cls.add_constructor([]) @@ -15995,7 +16628,7 @@ def register_Ns3MobilityModel_methods(root_module, cls): cls.add_method('AssignStreams', 'int64_t', [param('int64_t', 'stream')]) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] cls.add_method('GetDistanceFrom', 'double', [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], @@ -16005,7 +16638,7 @@ def register_Ns3MobilityModel_methods(root_module, cls): 'ns3::Vector', [], is_const=True) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] cls.add_method('GetRelativeSpeed', 'double', [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], @@ -16054,24 +16687,24 @@ def register_Ns3MobilityModel_methods(root_module, cls): def register_Ns3MpduAggregator_methods(root_module, cls): ## mpdu-aggregator.h (module 'wifi'): ns3::MpduAggregator::MpduAggregator() [constructor] cls.add_constructor([]) - ## mpdu-aggregator.h (module 'wifi'): ns3::MpduAggregator::MpduAggregator(ns3::MpduAggregator const & arg0) [copy constructor] + ## mpdu-aggregator.h (module 'wifi'): ns3::MpduAggregator::MpduAggregator(ns3::MpduAggregator const & arg0) [constructor] cls.add_constructor([param('ns3::MpduAggregator const &', 'arg0')]) ## mpdu-aggregator.h (module 'wifi'): void ns3::MpduAggregator::AddHeaderAndPad(ns3::Ptr packet, bool last, bool isSingleMpdu) const [member function] cls.add_method('AddHeaderAndPad', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('bool', 'last'), param('bool', 'isSingleMpdu')], is_pure_virtual=True, is_const=True, is_virtual=True) - ## mpdu-aggregator.h (module 'wifi'): bool ns3::MpduAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] + ## mpdu-aggregator.h (module 'wifi'): bool ns3::MpduAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] cls.add_method('Aggregate', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_pure_virtual=True, is_const=True, is_virtual=True) - ## mpdu-aggregator.h (module 'wifi'): void ns3::MpduAggregator::AggregateSingleMpdu(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] + ## mpdu-aggregator.h (module 'wifi'): void ns3::MpduAggregator::AggregateSingleMpdu(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] cls.add_method('AggregateSingleMpdu', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_pure_virtual=True, is_const=True, is_virtual=True) - ## mpdu-aggregator.h (module 'wifi'): uint32_t ns3::MpduAggregator::CalculatePadding(ns3::Ptr packet) const [member function] + ## mpdu-aggregator.h (module 'wifi'): uint32_t ns3::MpduAggregator::CalculatePadding(ns3::Ptr packet) const [member function] cls.add_method('CalculatePadding', 'uint32_t', [param('ns3::Ptr< ns3::Packet const >', 'packet')], @@ -16081,9 +16714,9 @@ def register_Ns3MpduAggregator_methods(root_module, cls): 'bool', [param('uint32_t', 'packetSize'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket'), param('uint8_t', 'blockAckSize')], is_pure_virtual=True, is_const=True, is_virtual=True) - ## mpdu-aggregator.h (module 'wifi'): static std::list, ns3::AmpduSubframeHeader>, std::allocator, ns3::AmpduSubframeHeader> > > ns3::MpduAggregator::Deaggregate(ns3::Ptr aggregatedPacket) [member function] + ## mpdu-aggregator.h (module 'wifi'): static ns3::MpduAggregator::DeaggregatedMpdus ns3::MpduAggregator::Deaggregate(ns3::Ptr aggregatedPacket) [member function] cls.add_method('Deaggregate', - 'std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmpduSubframeHeader > >', + 'ns3::MpduAggregator::DeaggregatedMpdus', [param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_static=True) ## mpdu-aggregator.h (module 'wifi'): uint32_t ns3::MpduAggregator::GetMaxAmpduSize() const [member function] @@ -16104,7 +16737,7 @@ def register_Ns3MpduAggregator_methods(root_module, cls): return def register_Ns3MpduStandardAggregator_methods(root_module, cls): - ## mpdu-standard-aggregator.h (module 'wifi'): ns3::MpduStandardAggregator::MpduStandardAggregator(ns3::MpduStandardAggregator const & arg0) [copy constructor] + ## mpdu-standard-aggregator.h (module 'wifi'): ns3::MpduStandardAggregator::MpduStandardAggregator(ns3::MpduStandardAggregator const & arg0) [constructor] cls.add_constructor([param('ns3::MpduStandardAggregator const &', 'arg0')]) ## mpdu-standard-aggregator.h (module 'wifi'): ns3::MpduStandardAggregator::MpduStandardAggregator() [constructor] cls.add_constructor([]) @@ -16113,17 +16746,17 @@ def register_Ns3MpduStandardAggregator_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('bool', 'last'), param('bool', 'isSingleMpdu')], is_const=True, is_virtual=True) - ## mpdu-standard-aggregator.h (module 'wifi'): bool ns3::MpduStandardAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] + ## mpdu-standard-aggregator.h (module 'wifi'): bool ns3::MpduStandardAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] cls.add_method('Aggregate', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_const=True, is_virtual=True) - ## mpdu-standard-aggregator.h (module 'wifi'): void ns3::MpduStandardAggregator::AggregateSingleMpdu(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] + ## mpdu-standard-aggregator.h (module 'wifi'): void ns3::MpduStandardAggregator::AggregateSingleMpdu(ns3::Ptr packet, ns3::Ptr aggregatedPacket) const [member function] cls.add_method('AggregateSingleMpdu', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_const=True, is_virtual=True) - ## mpdu-standard-aggregator.h (module 'wifi'): uint32_t ns3::MpduStandardAggregator::CalculatePadding(ns3::Ptr packet) const [member function] + ## mpdu-standard-aggregator.h (module 'wifi'): uint32_t ns3::MpduStandardAggregator::CalculatePadding(ns3::Ptr packet) const [member function] cls.add_method('CalculatePadding', 'uint32_t', [param('ns3::Ptr< ns3::Packet const >', 'packet')], @@ -16153,16 +16786,16 @@ def register_Ns3MpduStandardAggregator_methods(root_module, cls): def register_Ns3MsduAggregator_methods(root_module, cls): ## msdu-aggregator.h (module 'wifi'): ns3::MsduAggregator::MsduAggregator() [constructor] cls.add_constructor([]) - ## msdu-aggregator.h (module 'wifi'): ns3::MsduAggregator::MsduAggregator(ns3::MsduAggregator const & arg0) [copy constructor] + ## msdu-aggregator.h (module 'wifi'): ns3::MsduAggregator::MsduAggregator(ns3::MsduAggregator const & arg0) [constructor] cls.add_constructor([param('ns3::MsduAggregator const &', 'arg0')]) - ## msdu-aggregator.h (module 'wifi'): bool ns3::MsduAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket, ns3::Mac48Address src, ns3::Mac48Address dest) const [member function] + ## msdu-aggregator.h (module 'wifi'): bool ns3::MsduAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket, ns3::Mac48Address src, ns3::Mac48Address dest) const [member function] cls.add_method('Aggregate', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dest')], is_pure_virtual=True, is_const=True, is_virtual=True) - ## msdu-aggregator.h (module 'wifi'): static std::list, ns3::AmsduSubframeHeader>, std::allocator, ns3::AmsduSubframeHeader> > > ns3::MsduAggregator::Deaggregate(ns3::Ptr aggregatedPacket) [member function] + ## msdu-aggregator.h (module 'wifi'): static ns3::MsduAggregator::DeaggregatedMsdus ns3::MsduAggregator::Deaggregate(ns3::Ptr aggregatedPacket) [member function] cls.add_method('Deaggregate', - 'std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader > >', + 'ns3::MsduAggregator::DeaggregatedMsdus', [param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket')], is_static=True) ## msdu-aggregator.h (module 'wifi'): uint32_t ns3::MsduAggregator::GetMaxAmsduSize() const [member function] @@ -16183,11 +16816,11 @@ def register_Ns3MsduAggregator_methods(root_module, cls): return def register_Ns3MsduStandardAggregator_methods(root_module, cls): - ## msdu-standard-aggregator.h (module 'wifi'): ns3::MsduStandardAggregator::MsduStandardAggregator(ns3::MsduStandardAggregator const & arg0) [copy constructor] + ## msdu-standard-aggregator.h (module 'wifi'): ns3::MsduStandardAggregator::MsduStandardAggregator(ns3::MsduStandardAggregator const & arg0) [constructor] cls.add_constructor([param('ns3::MsduStandardAggregator const &', 'arg0')]) ## msdu-standard-aggregator.h (module 'wifi'): ns3::MsduStandardAggregator::MsduStandardAggregator() [constructor] cls.add_constructor([]) - ## msdu-standard-aggregator.h (module 'wifi'): bool ns3::MsduStandardAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket, ns3::Mac48Address src, ns3::Mac48Address dest) const [member function] + ## msdu-standard-aggregator.h (module 'wifi'): bool ns3::MsduStandardAggregator::Aggregate(ns3::Ptr packet, ns3::Ptr aggregatedPacket, ns3::Mac48Address src, ns3::Mac48Address dest) const [member function] cls.add_method('Aggregate', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::Packet >', 'aggregatedPacket'), param('ns3::Mac48Address', 'src'), param('ns3::Mac48Address', 'dest')], @@ -16232,7 +16865,7 @@ def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls): def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -16344,12 +16977,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -16362,7 +16995,7 @@ def register_Ns3NetDevice_methods(root_module, cls): return def register_Ns3NistErrorRateModel_methods(root_module, cls): - ## nist-error-rate-model.h (module 'wifi'): ns3::NistErrorRateModel::NistErrorRateModel(ns3::NistErrorRateModel const & arg0) [copy constructor] + ## nist-error-rate-model.h (module 'wifi'): ns3::NistErrorRateModel::NistErrorRateModel(ns3::NistErrorRateModel const & arg0) [constructor] cls.add_constructor([param('ns3::NistErrorRateModel const &', 'arg0')]) ## nist-error-rate-model.h (module 'wifi'): ns3::NistErrorRateModel::NistErrorRateModel() [constructor] cls.add_constructor([]) @@ -16382,7 +17015,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -16423,7 +17056,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -16482,19 +17115,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -16558,23 +17191,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -16584,7 +17217,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -16621,7 +17254,7 @@ def register_Ns3OkumuraHataPropagationLossModel_methods(root_module, cls): return def register_Ns3OnoeWifiManager_methods(root_module, cls): - ## onoe-wifi-manager.h (module 'wifi'): ns3::OnoeWifiManager::OnoeWifiManager(ns3::OnoeWifiManager const & arg0) [copy constructor] + ## onoe-wifi-manager.h (module 'wifi'): ns3::OnoeWifiManager::OnoeWifiManager(ns3::OnoeWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::OnoeWifiManager const &', 'arg0')]) ## onoe-wifi-manager.h (module 'wifi'): ns3::OnoeWifiManager::OnoeWifiManager() [constructor] cls.add_constructor([]) @@ -16703,10 +17336,10 @@ def register_Ns3OnoeWifiManager_methods(root_module, cls): return def register_Ns3OutputStreamWrapper_methods(root_module, cls): - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy constructor] + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [constructor] cls.add_constructor([param('ns3::OutputStreamWrapper const &', 'arg0')]) - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::_Ios_Openmode filemode) [constructor] - cls.add_constructor([param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode')]) + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::ios_base::openmode filemode) [constructor] + cls.add_constructor([param('std::string', 'filename'), param('std::ios_base::openmode', 'filemode')]) ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::ostream * os) [constructor] cls.add_constructor([param('std::ostream *', 'os')]) ## output-stream-wrapper.h (module 'network'): std::ostream * ns3::OutputStreamWrapper::GetStream() [member function] @@ -16719,7 +17352,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -16727,7 +17360,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor] cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) - ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] + ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] cls.add_method('AddAtEnd', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -16912,7 +17545,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -16949,7 +17582,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): return def register_Ns3ParfWifiManager_methods(root_module, cls): - ## parf-wifi-manager.h (module 'wifi'): ns3::ParfWifiManager::ParfWifiManager(ns3::ParfWifiManager const & arg0) [copy constructor] + ## parf-wifi-manager.h (module 'wifi'): ns3::ParfWifiManager::ParfWifiManager(ns3::ParfWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::ParfWifiManager const &', 'arg0')]) ## parf-wifi-manager.h (module 'wifi'): ns3::ParfWifiManager::ParfWifiManager() [constructor] cls.add_constructor([]) @@ -16973,10 +17606,10 @@ def register_Ns3ParfWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## parf-wifi-manager.h (module 'wifi'): void ns3::ParfWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## parf-wifi-manager.h (module 'wifi'): void ns3::ParfWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## parf-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::ParfWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -17035,49 +17668,145 @@ def register_Ns3ParfWifiManager_methods(root_module, cls): is_const=True, visibility='private', is_virtual=True) return -def register_Ns3QueueItem_methods(root_module, cls): - cls.add_output_stream_operator() - ## queue-item.h (module 'network'): ns3::QueueItem::QueueItem(ns3::Ptr p) [constructor] - cls.add_constructor([param('ns3::Ptr< ns3::Packet >', 'p')]) - ## queue-item.h (module 'network'): ns3::Ptr ns3::QueueItem::GetPacket() const [member function] - cls.add_method('GetPacket', - 'ns3::Ptr< ns3::Packet >', - [], - is_const=True) - ## queue-item.h (module 'network'): uint32_t ns3::QueueItem::GetSize() const [member function] - cls.add_method('GetSize', - 'uint32_t', - [], - is_const=True, is_virtual=True) - ## queue-item.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function] - cls.add_method('GetUint8Value', +def register_Ns3QosBlockedDestinations_methods(root_module, cls): + ## qos-blocked-destinations.h (module 'wifi'): ns3::QosBlockedDestinations::QosBlockedDestinations(ns3::QosBlockedDestinations const & arg0) [constructor] + cls.add_constructor([param('ns3::QosBlockedDestinations const &', 'arg0')]) + ## qos-blocked-destinations.h (module 'wifi'): ns3::QosBlockedDestinations::QosBlockedDestinations() [constructor] + cls.add_constructor([]) + ## qos-blocked-destinations.h (module 'wifi'): void ns3::QosBlockedDestinations::Block(ns3::Mac48Address dest, uint8_t tid) [member function] + cls.add_method('Block', + 'void', + [param('ns3::Mac48Address', 'dest'), param('uint8_t', 'tid')]) + ## qos-blocked-destinations.h (module 'wifi'): bool ns3::QosBlockedDestinations::IsBlocked(ns3::Mac48Address dest, uint8_t tid) const [member function] + cls.add_method('IsBlocked', 'bool', - [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')], - is_const=True, is_virtual=True) - ## queue-item.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function] - cls.add_method('Print', + [param('ns3::Mac48Address', 'dest'), param('uint8_t', 'tid')], + is_const=True) + ## qos-blocked-destinations.h (module 'wifi'): void ns3::QosBlockedDestinations::Unblock(ns3::Mac48Address dest, uint8_t tid) [member function] + cls.add_method('Unblock', 'void', - [param('std::ostream &', 'os')], - is_const=True, is_virtual=True) + [param('ns3::Mac48Address', 'dest'), param('uint8_t', 'tid')]) return -def register_Ns3RegularWifiMac_methods(root_module, cls): - ## regular-wifi-mac.h (module 'wifi'): static ns3::TypeId ns3::RegularWifiMac::GetTypeId() [member function] +def register_Ns3Queue__Ns3WifiMacQueueItem_methods(root_module, cls): + ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) - ## regular-wifi-mac.h (module 'wifi'): ns3::RegularWifiMac::RegularWifiMac() [constructor] + ## queue.h (module 'network'): ns3::Queue::Queue() [constructor] cls.add_constructor([]) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetSlot(ns3::Time slotTime) [member function] - cls.add_method('SetSlot', - 'void', - [param('ns3::Time', 'slotTime')], - is_virtual=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetSifs(ns3::Time sifs) [member function] - cls.add_method('SetSifs', - 'void', - [param('ns3::Time', 'sifs')], + ## queue.h (module 'network'): bool ns3::Queue::Enqueue(ns3::Ptr item) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + is_pure_virtual=True, is_virtual=True) + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_pure_virtual=True, is_virtual=True) + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] + cls.add_method('Remove', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_pure_virtual=True, is_virtual=True) + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] + cls.add_method('Peek', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] + cls.add_method('Flush', + 'void', + []) + ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + cls.add_constructor([param('ns3::Queue< ns3::WifiMacQueueItem > const &', 'arg0')]) + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] + cls.add_method('Head', + 'ns3::Queue< ns3::WifiMacQueueItem > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Tail() const [member function] + cls.add_method('Tail', + 'ns3::Queue< ns3::WifiMacQueueItem > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(ns3::Queue::ConstIterator pos, ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('std::list< ns3::Ptr< ns3::WifiMacQueueItem > > const_iterator', 'pos'), param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoDequeue', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('std::list< ns3::Ptr< ns3::WifiMacQueueItem > > const_iterator', 'pos')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoRemove', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('std::list< ns3::Ptr< ns3::WifiMacQueueItem > > const_iterator', 'pos')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(ns3::Queue::ConstIterator pos) const [member function] + cls.add_method('DoPeek', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [param('std::list< ns3::Ptr< ns3::WifiMacQueueItem > > const_iterator', 'pos')], + is_const=True, visibility='protected') + ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] + cls.add_method('DropBeforeEnqueue', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + visibility='protected') + ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] + cls.add_method('DropAfterDequeue', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + visibility='protected') + return + +def register_Ns3QueueItem_methods(root_module, cls): + cls.add_output_stream_operator() + ## queue-item.h (module 'network'): ns3::QueueItem::QueueItem(ns3::Ptr p) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::Packet >', 'p')]) + ## queue-item.h (module 'network'): ns3::Ptr ns3::QueueItem::GetPacket() const [member function] + cls.add_method('GetPacket', + 'ns3::Ptr< ns3::Packet >', + [], + is_const=True) + ## queue-item.h (module 'network'): uint32_t ns3::QueueItem::GetSize() const [member function] + cls.add_method('GetSize', + 'uint32_t', + [], + is_const=True, is_virtual=True) + ## queue-item.h (module 'network'): bool ns3::QueueItem::GetUint8Value(ns3::QueueItem::Uint8Values field, uint8_t & value) const [member function] + cls.add_method('GetUint8Value', + 'bool', + [param('ns3::QueueItem::Uint8Values', 'field'), param('uint8_t &', 'value')], + is_const=True, is_virtual=True) + ## queue-item.h (module 'network'): void ns3::QueueItem::Print(std::ostream & os) const [member function] + cls.add_method('Print', + 'void', + [param('std::ostream &', 'os')], + is_const=True, is_virtual=True) + return + +def register_Ns3RegularWifiMac_methods(root_module, cls): + ## regular-wifi-mac.h (module 'wifi'): static ns3::TypeId ns3::RegularWifiMac::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## regular-wifi-mac.h (module 'wifi'): ns3::RegularWifiMac::RegularWifiMac() [constructor] + cls.add_constructor([]) + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetSlot(ns3::Time slotTime) [member function] + cls.add_method('SetSlot', + 'void', + [param('ns3::Time', 'slotTime')], + is_virtual=True) + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetSifs(ns3::Time sifs) [member function] + cls.add_method('SetSifs', + 'void', + [param('ns3::Time', 'sifs')], is_virtual=True) ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function] cls.add_method('SetEifsNoDifs', @@ -17201,7 +17930,7 @@ def register_Ns3RegularWifiMac_methods(root_module, cls): 'void', [], is_virtual=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')], @@ -17211,15 +17940,15 @@ def register_Ns3RegularWifiMac_methods(root_module, cls): 'bool', [], is_const=True, is_virtual=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to')], is_pure_virtual=True, is_virtual=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetWifiPhy(ns3::Ptr phy) [member function] + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetWifiPhy(ns3::Ptr const phy) [member function] cls.add_method('SetWifiPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## regular-wifi-mac.h (module 'wifi'): ns3::Ptr ns3::RegularWifiMac::GetWifiPhy() const [member function] cls.add_method('GetWifiPhy', @@ -17231,10 +17960,10 @@ def register_Ns3RegularWifiMac_methods(root_module, cls): 'void', [], is_virtual=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetWifiRemoteStationManager(ns3::Ptr const stationManager) [member function] cls.add_method('SetWifiRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'stationManager')], is_virtual=True) ## regular-wifi-mac.h (module 'wifi'): ns3::Ptr ns3::RegularWifiMac::GetWifiRemoteStationManager() const [member function] cls.add_method('GetWifiRemoteStationManager', @@ -17256,7 +17985,7 @@ def register_Ns3RegularWifiMac_methods(root_module, cls): 'ns3::HeCapabilities', [], is_const=True) - ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetForwardUpCallback(ns3::Callback, ns3::Mac48Address, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> upCallback) [member function] + ## regular-wifi-mac.h (module 'wifi'): void ns3::RegularWifiMac::SetForwardUpCallback(ns3::RegularWifiMac::ForwardUpCallback upCallback) [member function] cls.add_method('SetForwardUpCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::Mac48Address, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'upCallback')], @@ -17434,7 +18163,7 @@ def register_Ns3RegularWifiMac_methods(root_module, cls): return def register_Ns3RraaWifiManager_methods(root_module, cls): - ## rraa-wifi-manager.h (module 'wifi'): ns3::RraaWifiManager::RraaWifiManager(ns3::RraaWifiManager const & arg0) [copy constructor] + ## rraa-wifi-manager.h (module 'wifi'): ns3::RraaWifiManager::RraaWifiManager(ns3::RraaWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::RraaWifiManager const &', 'arg0')]) ## rraa-wifi-manager.h (module 'wifi'): ns3::RraaWifiManager::RraaWifiManager() [constructor] cls.add_constructor([]) @@ -17458,15 +18187,15 @@ def register_Ns3RraaWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## rraa-wifi-manager.h (module 'wifi'): void ns3::RraaWifiManager::SetupMac(ns3::Ptr mac) [member function] + ## rraa-wifi-manager.h (module 'wifi'): void ns3::RraaWifiManager::SetupMac(ns3::Ptr const mac) [member function] cls.add_method('SetupMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')], + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')], is_virtual=True) - ## rraa-wifi-manager.h (module 'wifi'): void ns3::RraaWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## rraa-wifi-manager.h (module 'wifi'): void ns3::RraaWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## rraa-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::RraaWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -17483,7 +18212,7 @@ def register_Ns3RraaWifiManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], visibility='private', is_virtual=True) - ## rraa-wifi-manager.h (module 'wifi'): bool ns3::RraaWifiManager::DoNeedRts(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] + ## rraa-wifi-manager.h (module 'wifi'): bool ns3::RraaWifiManager::DoNeedRts(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRts', 'bool', [param('ns3::WifiRemoteStation *', 'st'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -17531,7 +18260,7 @@ def register_Ns3RraaWifiManager_methods(root_module, cls): return def register_Ns3RrpaaWifiManager_methods(root_module, cls): - ## rrpaa-wifi-manager.h (module 'wifi'): ns3::RrpaaWifiManager::RrpaaWifiManager(ns3::RrpaaWifiManager const & arg0) [copy constructor] + ## rrpaa-wifi-manager.h (module 'wifi'): ns3::RrpaaWifiManager::RrpaaWifiManager(ns3::RrpaaWifiManager const & arg0) [constructor] cls.add_constructor([param('ns3::RrpaaWifiManager const &', 'arg0')]) ## rrpaa-wifi-manager.h (module 'wifi'): ns3::RrpaaWifiManager::RrpaaWifiManager() [constructor] cls.add_constructor([]) @@ -17559,15 +18288,15 @@ def register_Ns3RrpaaWifiManager_methods(root_module, cls): 'void', [param('bool', 'enable')], is_virtual=True) - ## rrpaa-wifi-manager.h (module 'wifi'): void ns3::RrpaaWifiManager::SetupMac(ns3::Ptr mac) [member function] + ## rrpaa-wifi-manager.h (module 'wifi'): void ns3::RrpaaWifiManager::SetupMac(ns3::Ptr const mac) [member function] cls.add_method('SetupMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')], + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')], is_virtual=True) - ## rrpaa-wifi-manager.h (module 'wifi'): void ns3::RrpaaWifiManager::SetupPhy(ns3::Ptr phy) [member function] + ## rrpaa-wifi-manager.h (module 'wifi'): void ns3::RrpaaWifiManager::SetupPhy(ns3::Ptr const phy) [member function] cls.add_method('SetupPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')], + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')], is_virtual=True) ## rrpaa-wifi-manager.h (module 'wifi'): ns3::WifiRemoteStation * ns3::RrpaaWifiManager::DoCreateStation() const [member function] cls.add_method('DoCreateStation', @@ -17584,7 +18313,7 @@ def register_Ns3RrpaaWifiManager_methods(root_module, cls): 'ns3::WifiTxVector', [param('ns3::WifiRemoteStation *', 'station')], visibility='private', is_virtual=True) - ## rrpaa-wifi-manager.h (module 'wifi'): bool ns3::RrpaaWifiManager::DoNeedRts(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] + ## rrpaa-wifi-manager.h (module 'wifi'): bool ns3::RrpaaWifiManager::DoNeedRts(ns3::WifiRemoteStation * st, ns3::Ptr packet, bool normally) [member function] cls.add_method('DoNeedRts', 'bool', [param('ns3::WifiRemoteStation *', 'st'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('bool', 'normally')], @@ -17631,10 +18360,36 @@ def register_Ns3RrpaaWifiManager_methods(root_module, cls): is_const=True, visibility='private', is_virtual=True) return +def register_Ns3SimpleFrameCaptureModel_methods(root_module, cls): + ## simple-frame-capture-model.h (module 'wifi'): ns3::SimpleFrameCaptureModel::SimpleFrameCaptureModel(ns3::SimpleFrameCaptureModel const & arg0) [constructor] + cls.add_constructor([param('ns3::SimpleFrameCaptureModel const &', 'arg0')]) + ## simple-frame-capture-model.h (module 'wifi'): ns3::SimpleFrameCaptureModel::SimpleFrameCaptureModel() [constructor] + cls.add_constructor([]) + ## simple-frame-capture-model.h (module 'wifi'): bool ns3::SimpleFrameCaptureModel::CaptureNewFrame(ns3::Ptr currentEvent, ns3::Ptr newEvent) const [member function] + cls.add_method('CaptureNewFrame', + 'bool', + [param('ns3::Ptr< ns3::InterferenceHelper::Event >', 'currentEvent'), param('ns3::Ptr< ns3::InterferenceHelper::Event >', 'newEvent')], + is_const=True, is_virtual=True) + ## simple-frame-capture-model.h (module 'wifi'): double ns3::SimpleFrameCaptureModel::GetMargin() const [member function] + cls.add_method('GetMargin', + 'double', + [], + is_const=True) + ## simple-frame-capture-model.h (module 'wifi'): static ns3::TypeId ns3::SimpleFrameCaptureModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## simple-frame-capture-model.h (module 'wifi'): void ns3::SimpleFrameCaptureModel::SetMargin(double margin) [member function] + cls.add_method('SetMargin', + 'void', + [param('double', 'margin')]) + return + def register_Ns3SpectrumChannel_methods(root_module, cls): ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel() [constructor] cls.add_constructor([]) - ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [copy constructor] + ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumChannel const &', 'arg0')]) ## spectrum-channel.h (module 'spectrum'): void ns3::SpectrumChannel::AddPropagationLossModel(ns3::Ptr loss) [member function] cls.add_method('AddPropagationLossModel', @@ -17669,7 +18424,7 @@ def register_Ns3SpectrumChannel_methods(root_module, cls): return def register_Ns3SpectrumWifiPhy_methods(root_module, cls): - ## spectrum-wifi-phy.h (module 'wifi'): ns3::SpectrumWifiPhy::SpectrumWifiPhy(ns3::SpectrumWifiPhy const & arg0) [copy constructor] + ## spectrum-wifi-phy.h (module 'wifi'): ns3::SpectrumWifiPhy::SpectrumWifiPhy(ns3::SpectrumWifiPhy const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumWifiPhy const &', 'arg0')]) ## spectrum-wifi-phy.h (module 'wifi'): ns3::SpectrumWifiPhy::SpectrumWifiPhy() [constructor] cls.add_constructor([]) @@ -17685,11 +18440,21 @@ def register_Ns3SpectrumWifiPhy_methods(root_module, cls): cls.add_method('CreateWifiSpectrumPhyInterface', 'void', [param('ns3::Ptr< ns3::NetDevice >', 'device')]) + ## spectrum-wifi-phy.h (module 'wifi'): double ns3::SpectrumWifiPhy::GetBandBandwidth() const [member function] + cls.add_method('GetBandBandwidth', + 'double', + [], + is_const=True) ## spectrum-wifi-phy.h (module 'wifi'): ns3::Ptr ns3::SpectrumWifiPhy::GetChannel() const [member function] cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', [], is_const=True, is_virtual=True) + ## spectrum-wifi-phy.h (module 'wifi'): uint32_t ns3::SpectrumWifiPhy::GetGuardBandwidth() const [member function] + cls.add_method('GetGuardBandwidth', + 'uint32_t', + [], + is_const=True) ## spectrum-wifi-phy.h (module 'wifi'): std::vector > ns3::SpectrumWifiPhy::GetOperationalChannelList() const [member function] cls.add_method('GetOperationalChannelList', 'std::vector< unsigned char >', @@ -17700,7 +18465,7 @@ def register_Ns3SpectrumWifiPhy_methods(root_module, cls): 'ns3::Ptr< ns3::AntennaModel >', [], is_const=True) - ## spectrum-wifi-phy.h (module 'wifi'): ns3::Ptr ns3::SpectrumWifiPhy::GetRxSpectrumModel() const [member function] + ## spectrum-wifi-phy.h (module 'wifi'): ns3::Ptr ns3::SpectrumWifiPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -17715,14 +18480,14 @@ def register_Ns3SpectrumWifiPhy_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## spectrum-wifi-phy.h (module 'wifi'): void ns3::SpectrumWifiPhy::SetAntenna(ns3::Ptr antenna) [member function] + ## spectrum-wifi-phy.h (module 'wifi'): void ns3::SpectrumWifiPhy::SetAntenna(ns3::Ptr const antenna) [member function] cls.add_method('SetAntenna', 'void', - [param('ns3::Ptr< ns3::AntennaModel >', 'antenna')]) - ## spectrum-wifi-phy.h (module 'wifi'): void ns3::SpectrumWifiPhy::SetChannel(ns3::Ptr channel) [member function] + [param('ns3::Ptr< ns3::AntennaModel > const', 'antenna')]) + ## spectrum-wifi-phy.h (module 'wifi'): void ns3::SpectrumWifiPhy::SetChannel(ns3::Ptr const channel) [member function] cls.add_method('SetChannel', 'void', - [param('ns3::Ptr< ns3::SpectrumChannel >', 'channel')]) + [param('ns3::Ptr< ns3::SpectrumChannel > const', 'channel')]) ## spectrum-wifi-phy.h (module 'wifi'): void ns3::SpectrumWifiPhy::StartRx(ns3::Ptr rxParams) [member function] cls.add_method('StartRx', 'void', @@ -17746,7 +18511,7 @@ def register_Ns3SpectrumWifiPhy_methods(root_module, cls): def register_Ns3Ssid_methods(root_module, cls): cls.add_output_stream_operator() - ## ssid.h (module 'wifi'): ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor] + ## ssid.h (module 'wifi'): ns3::Ssid::Ssid(ns3::Ssid const & arg0) [constructor] cls.add_constructor([param('ns3::Ssid const &', 'arg0')]) ## ssid.h (module 'wifi'): ns3::Ssid::Ssid() [constructor] cls.add_constructor([]) @@ -17794,23 +18559,23 @@ def register_Ns3Ssid_methods(root_module, cls): def register_Ns3SsidChecker_methods(root_module, cls): ## ssid.h (module 'wifi'): ns3::SsidChecker::SsidChecker() [constructor] cls.add_constructor([]) - ## ssid.h (module 'wifi'): ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [copy constructor] + ## ssid.h (module 'wifi'): ns3::SsidChecker::SsidChecker(ns3::SsidChecker const & arg0) [constructor] cls.add_constructor([param('ns3::SsidChecker const &', 'arg0')]) return def register_Ns3SsidValue_methods(root_module, cls): ## ssid.h (module 'wifi'): ns3::SsidValue::SsidValue() [constructor] cls.add_constructor([]) - ## ssid.h (module 'wifi'): ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::SsidValue const &', 'arg0')]) ## ssid.h (module 'wifi'): ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor] cls.add_constructor([param('ns3::Ssid const &', 'value')]) + ## ssid.h (module 'wifi'): ns3::SsidValue::SsidValue(ns3::SsidValue const & arg0) [constructor] + cls.add_constructor([param('ns3::SsidValue const &', 'arg0')]) ## ssid.h (module 'wifi'): ns3::Ptr ns3::SsidValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ssid.h (module 'wifi'): bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ssid.h (module 'wifi'): bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -17820,7 +18585,7 @@ def register_Ns3SsidValue_methods(root_module, cls): 'ns3::Ssid', [], is_const=True) - ## ssid.h (module 'wifi'): std::string ns3::SsidValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ssid.h (module 'wifi'): std::string ns3::SsidValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -17839,7 +18604,7 @@ def register_Ns3StaWifiMac_methods(root_module, cls): is_static=True) ## sta-wifi-mac.h (module 'wifi'): ns3::StaWifiMac::StaWifiMac() [constructor] cls.add_constructor([]) - ## sta-wifi-mac.h (module 'wifi'): void ns3::StaWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + ## sta-wifi-mac.h (module 'wifi'): void ns3::StaWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to')], @@ -17870,23 +18635,23 @@ def register_Ns3StaWifiMac_methods(root_module, cls): def register_Ns3StringChecker_methods(root_module, cls): ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [constructor] cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) return def register_Ns3StringValue_methods(root_module, cls): ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -17896,7 +18661,7 @@ def register_Ns3StringValue_methods(root_module, cls): 'std::string', [], is_const=True) - ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -17911,7 +18676,7 @@ def register_Ns3SupportedRates_methods(root_module, cls): cls.add_output_stream_operator() ## supported-rates.h (module 'wifi'): ns3::SupportedRates::SupportedRates() [constructor] cls.add_constructor([]) - ## supported-rates.h (module 'wifi'): ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor] + ## supported-rates.h (module 'wifi'): ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [constructor] cls.add_constructor([param('ns3::SupportedRates const &', 'arg0')]) ## supported-rates.h (module 'wifi'): void ns3::SupportedRates::AddBssMembershipSelectorRate(uint32_t bs) [member function] cls.add_method('AddBssMembershipSelectorRate', @@ -17979,16 +18744,16 @@ def register_Ns3SupportedRates_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -17998,7 +18763,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18012,23 +18777,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18038,7 +18803,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18052,16 +18817,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18071,7 +18836,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18085,23 +18850,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18111,7 +18876,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18125,23 +18890,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18151,7 +18916,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18164,7 +18929,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): def register_Ns3VhtCapabilities_methods(root_module, cls): cls.add_output_stream_operator() - ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilities::VhtCapabilities(ns3::VhtCapabilities const & arg0) [copy constructor] + ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilities::VhtCapabilities(ns3::VhtCapabilities const & arg0) [constructor] cls.add_constructor([param('ns3::VhtCapabilities const &', 'arg0')]) ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilities::VhtCapabilities() [constructor] cls.add_constructor([]) @@ -18356,23 +19121,23 @@ def register_Ns3VhtCapabilities_methods(root_module, cls): def register_Ns3VhtCapabilitiesChecker_methods(root_module, cls): ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesChecker::VhtCapabilitiesChecker() [constructor] cls.add_constructor([]) - ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesChecker::VhtCapabilitiesChecker(ns3::VhtCapabilitiesChecker const & arg0) [copy constructor] + ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesChecker::VhtCapabilitiesChecker(ns3::VhtCapabilitiesChecker const & arg0) [constructor] cls.add_constructor([param('ns3::VhtCapabilitiesChecker const &', 'arg0')]) return def register_Ns3VhtCapabilitiesValue_methods(root_module, cls): ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesValue::VhtCapabilitiesValue() [constructor] cls.add_constructor([]) - ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesValue::VhtCapabilitiesValue(ns3::VhtCapabilitiesValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::VhtCapabilitiesValue const &', 'arg0')]) ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesValue::VhtCapabilitiesValue(ns3::VhtCapabilities const & value) [constructor] cls.add_constructor([param('ns3::VhtCapabilities const &', 'value')]) + ## vht-capabilities.h (module 'wifi'): ns3::VhtCapabilitiesValue::VhtCapabilitiesValue(ns3::VhtCapabilitiesValue const & arg0) [constructor] + cls.add_constructor([param('ns3::VhtCapabilitiesValue const &', 'arg0')]) ## vht-capabilities.h (module 'wifi'): ns3::Ptr ns3::VhtCapabilitiesValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vht-capabilities.h (module 'wifi'): bool ns3::VhtCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vht-capabilities.h (module 'wifi'): bool ns3::VhtCapabilitiesValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18382,7 +19147,7 @@ def register_Ns3VhtCapabilitiesValue_methods(root_module, cls): 'ns3::VhtCapabilities', [], is_const=True) - ## vht-capabilities.h (module 'wifi'): std::string ns3::VhtCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vht-capabilities.h (module 'wifi'): std::string ns3::VhtCapabilitiesValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18395,7 +19160,7 @@ def register_Ns3VhtCapabilitiesValue_methods(root_module, cls): def register_Ns3VhtOperation_methods(root_module, cls): cls.add_output_stream_operator() - ## vht-operation.h (module 'wifi'): ns3::VhtOperation::VhtOperation(ns3::VhtOperation const & arg0) [copy constructor] + ## vht-operation.h (module 'wifi'): ns3::VhtOperation::VhtOperation(ns3::VhtOperation const & arg0) [constructor] cls.add_constructor([param('ns3::VhtOperation const &', 'arg0')]) ## vht-operation.h (module 'wifi'): ns3::VhtOperation::VhtOperation() [constructor] cls.add_constructor([]) @@ -18478,23 +19243,23 @@ def register_Ns3VhtOperation_methods(root_module, cls): def register_Ns3VhtOperationChecker_methods(root_module, cls): ## vht-operation.h (module 'wifi'): ns3::VhtOperationChecker::VhtOperationChecker() [constructor] cls.add_constructor([]) - ## vht-operation.h (module 'wifi'): ns3::VhtOperationChecker::VhtOperationChecker(ns3::VhtOperationChecker const & arg0) [copy constructor] + ## vht-operation.h (module 'wifi'): ns3::VhtOperationChecker::VhtOperationChecker(ns3::VhtOperationChecker const & arg0) [constructor] cls.add_constructor([param('ns3::VhtOperationChecker const &', 'arg0')]) return def register_Ns3VhtOperationValue_methods(root_module, cls): ## vht-operation.h (module 'wifi'): ns3::VhtOperationValue::VhtOperationValue() [constructor] cls.add_constructor([]) - ## vht-operation.h (module 'wifi'): ns3::VhtOperationValue::VhtOperationValue(ns3::VhtOperationValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::VhtOperationValue const &', 'arg0')]) ## vht-operation.h (module 'wifi'): ns3::VhtOperationValue::VhtOperationValue(ns3::VhtOperation const & value) [constructor] cls.add_constructor([param('ns3::VhtOperation const &', 'value')]) + ## vht-operation.h (module 'wifi'): ns3::VhtOperationValue::VhtOperationValue(ns3::VhtOperationValue const & arg0) [constructor] + cls.add_constructor([param('ns3::VhtOperationValue const &', 'arg0')]) ## vht-operation.h (module 'wifi'): ns3::Ptr ns3::VhtOperationValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vht-operation.h (module 'wifi'): bool ns3::VhtOperationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vht-operation.h (module 'wifi'): bool ns3::VhtOperationValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18504,7 +19269,7 @@ def register_Ns3VhtOperationValue_methods(root_module, cls): 'ns3::VhtOperation', [], is_const=True) - ## vht-operation.h (module 'wifi'): std::string ns3::VhtOperationValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vht-operation.h (module 'wifi'): std::string ns3::VhtOperationValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18518,23 +19283,23 @@ def register_Ns3VhtOperationValue_methods(root_module, cls): def register_Ns3WifiModeChecker_methods(root_module, cls): ## wifi-mode.h (module 'wifi'): ns3::WifiModeChecker::WifiModeChecker() [constructor] cls.add_constructor([]) - ## wifi-mode.h (module 'wifi'): ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [copy constructor] + ## wifi-mode.h (module 'wifi'): ns3::WifiModeChecker::WifiModeChecker(ns3::WifiModeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::WifiModeChecker const &', 'arg0')]) return def register_Ns3WifiModeValue_methods(root_module, cls): ## wifi-mode.h (module 'wifi'): ns3::WifiModeValue::WifiModeValue() [constructor] cls.add_constructor([]) - ## wifi-mode.h (module 'wifi'): ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')]) ## wifi-mode.h (module 'wifi'): ns3::WifiModeValue::WifiModeValue(ns3::WifiMode const & value) [constructor] cls.add_constructor([param('ns3::WifiMode const &', 'value')]) + ## wifi-mode.h (module 'wifi'): ns3::WifiModeValue::WifiModeValue(ns3::WifiModeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::WifiModeValue const &', 'arg0')]) ## wifi-mode.h (module 'wifi'): ns3::Ptr ns3::WifiModeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## wifi-mode.h (module 'wifi'): bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## wifi-mode.h (module 'wifi'): bool ns3::WifiModeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18544,7 +19309,7 @@ def register_Ns3WifiModeValue_methods(root_module, cls): 'ns3::WifiMode', [], is_const=True) - ## wifi-mode.h (module 'wifi'): std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## wifi-mode.h (module 'wifi'): std::string ns3::WifiModeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18563,18 +19328,18 @@ def register_Ns3WifiNetDevice_methods(root_module, cls): is_static=True) ## wifi-net-device.h (module 'wifi'): ns3::WifiNetDevice::WifiNetDevice() [constructor] cls.add_constructor([]) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetMac(ns3::Ptr mac) [member function] + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetMac(ns3::Ptr const mac) [member function] cls.add_method('SetMac', 'void', - [param('ns3::Ptr< ns3::WifiMac >', 'mac')]) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetPhy(ns3::Ptr phy) [member function] + [param('ns3::Ptr< ns3::WifiMac > const', 'mac')]) + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetPhy(ns3::Ptr const phy) [member function] cls.add_method('SetPhy', 'void', - [param('ns3::Ptr< ns3::WifiPhy >', 'phy')]) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetRemoteStationManager(ns3::Ptr manager) [member function] + [param('ns3::Ptr< ns3::WifiPhy > const', 'phy')]) + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetRemoteStationManager(ns3::Ptr const manager) [member function] cls.add_method('SetRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'manager')]) + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'manager')]) ## wifi-net-device.h (module 'wifi'): ns3::Ptr ns3::WifiNetDevice::GetMac() const [member function] cls.add_method('GetMac', 'ns3::Ptr< ns3::WifiMac >', @@ -18675,17 +19440,17 @@ def register_Ns3WifiNetDevice_methods(root_module, cls): 'ns3::Ptr< ns3::Node >', [], is_const=True, is_virtual=True) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetNode(ns3::Ptr node) [member function] + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetNode(ns3::Ptr const node) [member function] cls.add_method('SetNode', 'void', - [param('ns3::Ptr< ns3::Node >', 'node')], + [param('ns3::Ptr< ns3::Node > const', 'node')], is_virtual=True) ## wifi-net-device.h (module 'wifi'): bool ns3::WifiNetDevice::NeedsArp() const [member function] cls.add_method('NeedsArp', 'bool', [], is_const=True, is_virtual=True) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -18700,7 +19465,7 @@ def register_Ns3WifiNetDevice_methods(root_module, cls): 'bool', [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], is_virtual=True) - ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## wifi-net-device.h (module 'wifi'): void ns3::WifiNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -18732,8 +19497,89 @@ def register_Ns3WifiNetDevice_methods(root_module, cls): visibility='protected') return +def register_Ns3WifiMacQueue_methods(root_module, cls): + ## mac-low.h (module 'wifi'): ns3::WifiQueue::WifiQueue(ns3::WifiQueue const & arg0) [constructor] + cls.add_constructor([param('ns3::WifiQueue< ns3::WifiMacQueueItem > const &', 'arg0')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue::WifiQueue() [constructor] + cls.add_constructor([]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::DequeueByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('DequeueByTidAndAddress', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::DequeueFirstAvailable(ns3::Ptr const blockedPackets) [member function] + cls.add_method('DequeueFirstAvailable', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::Enqueue(ns3::Ptr item) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::Time ns3::WifiQueue::GetMaxDelay() const [member function] + cls.add_method('GetMaxDelay', + 'ns3::Time', + [], + is_const=True) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNBytes() [member function] + cls.add_method('GetNBytes', + 'uint32_t', + []) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNPackets() [member function] + cls.add_method('GetNPackets', + 'uint32_t', + []) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNPacketsByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('GetNPacketsByTidAndAddress', + 'uint32_t', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): static ns3::TypeId ns3::WifiQueue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::IsEmpty() [member function] + cls.add_method('IsEmpty', + 'bool', + []) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Peek() const [member function] + cls.add_method('Peek', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [], + is_const=True, is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::PeekByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('PeekByTidAndAddress', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::PeekFirstAvailable(ns3::Ptr const blockedPackets) [member function] + cls.add_method('PeekFirstAvailable', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::PushFront(ns3::Ptr item) [member function] + cls.add_method('PushFront', + 'bool', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Remove() [member function] + cls.add_method('Remove', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::Remove(ns3::Ptr packet) [member function] + cls.add_method('Remove', + 'bool', + [param('ns3::Ptr< ns3::Packet const >', 'packet')]) + ## wifi-mac-queue.h (module 'wifi'): void ns3::WifiQueue::SetMaxDelay(ns3::Time delay) [member function] + cls.add_method('SetMaxDelay', + 'void', + [param('ns3::Time', 'delay')]) + return + def register_Ns3WifiRadioEnergyModel_methods(root_module, cls): - ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel::WifiRadioEnergyModel(ns3::WifiRadioEnergyModel const & arg0) [copy constructor] + ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel::WifiRadioEnergyModel(ns3::WifiRadioEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRadioEnergyModel const &', 'arg0')]) ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel::WifiRadioEnergyModel() [constructor] cls.add_constructor([]) @@ -18805,18 +19651,18 @@ def register_Ns3WifiRadioEnergyModel_methods(root_module, cls): cls.add_method('SetCcaBusyCurrentA', 'void', [param('double', 'ccaBusyCurrentA')]) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergyDepletionCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergyDepletionCallback(ns3::WifiRadioEnergyModel::WifiRadioEnergyDepletionCallback callback) [member function] cls.add_method('SetEnergyDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergyRechargedCallback(ns3::Callback callback) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergyRechargedCallback(ns3::WifiRadioEnergyModel::WifiRadioEnergyRechargedCallback callback) [member function] cls.add_method('SetEnergyRechargedCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergySource(ns3::Ptr source) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetEnergySource(ns3::Ptr const source) [member function] cls.add_method('SetEnergySource', 'void', - [param('ns3::Ptr< ns3::EnergySource >', 'source')], + [param('ns3::Ptr< ns3::EnergySource > const', 'source')], is_virtual=True) ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetIdleCurrentA(double idleCurrentA) [member function] cls.add_method('SetIdleCurrentA', @@ -18842,10 +19688,10 @@ def register_Ns3WifiRadioEnergyModel_methods(root_module, cls): cls.add_method('SetTxCurrentFromModel', 'void', [param('double', 'txPowerDbm')]) - ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetTxCurrentModel(ns3::Ptr model) [member function] + ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::SetTxCurrentModel(ns3::Ptr const model) [member function] cls.add_method('SetTxCurrentModel', 'void', - [param('ns3::Ptr< ns3::WifiTxCurrentModel >', 'model')]) + [param('ns3::Ptr< ns3::WifiTxCurrentModel > const', 'model')]) ## wifi-radio-energy-model.h (module 'wifi'): void ns3::WifiRadioEnergyModel::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -18859,7 +19705,7 @@ def register_Ns3WifiRadioEnergyModel_methods(root_module, cls): return def register_Ns3YansErrorRateModel_methods(root_module, cls): - ## yans-error-rate-model.h (module 'wifi'): ns3::YansErrorRateModel::YansErrorRateModel(ns3::YansErrorRateModel const & arg0) [copy constructor] + ## yans-error-rate-model.h (module 'wifi'): ns3::YansErrorRateModel::YansErrorRateModel(ns3::YansErrorRateModel const & arg0) [constructor] cls.add_constructor([param('ns3::YansErrorRateModel const &', 'arg0')]) ## yans-error-rate-model.h (module 'wifi'): ns3::YansErrorRateModel::YansErrorRateModel() [constructor] cls.add_constructor([]) @@ -18876,7 +19722,7 @@ def register_Ns3YansErrorRateModel_methods(root_module, cls): return def register_Ns3YansWifiChannel_methods(root_module, cls): - ## yans-wifi-channel.h (module 'wifi'): ns3::YansWifiChannel::YansWifiChannel(ns3::YansWifiChannel const & arg0) [copy constructor] + ## yans-wifi-channel.h (module 'wifi'): ns3::YansWifiChannel::YansWifiChannel(ns3::YansWifiChannel const & arg0) [constructor] cls.add_constructor([param('ns3::YansWifiChannel const &', 'arg0')]) ## yans-wifi-channel.h (module 'wifi'): ns3::YansWifiChannel::YansWifiChannel() [constructor] cls.add_constructor([]) @@ -18903,41 +19749,41 @@ def register_Ns3YansWifiChannel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::Send(ns3::Ptr sender, ns3::Ptr packet, double txPowerDbm, ns3::Time duration) const [member function] + ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::Send(ns3::Ptr sender, ns3::Ptr packet, double txPowerDbm, ns3::Time duration) const [member function] cls.add_method('Send', 'void', [param('ns3::Ptr< ns3::YansWifiPhy >', 'sender'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('double', 'txPowerDbm'), param('ns3::Time', 'duration')], is_const=True) - ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::SetPropagationDelayModel(ns3::Ptr delay) [member function] + ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::SetPropagationDelayModel(ns3::Ptr const delay) [member function] cls.add_method('SetPropagationDelayModel', 'void', - [param('ns3::Ptr< ns3::PropagationDelayModel >', 'delay')]) - ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::SetPropagationLossModel(ns3::Ptr loss) [member function] + [param('ns3::Ptr< ns3::PropagationDelayModel > const', 'delay')]) + ## yans-wifi-channel.h (module 'wifi'): void ns3::YansWifiChannel::SetPropagationLossModel(ns3::Ptr const loss) [member function] cls.add_method('SetPropagationLossModel', 'void', - [param('ns3::Ptr< ns3::PropagationLossModel >', 'loss')]) + [param('ns3::Ptr< ns3::PropagationLossModel > const', 'loss')]) return def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18947,7 +19793,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -18976,7 +19822,7 @@ def register_Ns3AdhocWifiMac_methods(root_module, cls): 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_virtual=True) - ## adhoc-wifi-mac.h (module 'wifi'): void ns3::AdhocWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + ## adhoc-wifi-mac.h (module 'wifi'): void ns3::AdhocWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to')], @@ -18996,22 +19842,22 @@ def register_Ns3ApWifiMac_methods(root_module, cls): is_static=True) ## ap-wifi-mac.h (module 'wifi'): ns3::ApWifiMac::ApWifiMac() [constructor] cls.add_constructor([]) - ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::SetWifiRemoteStationManager(ns3::Ptr stationManager) [member function] + ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::SetWifiRemoteStationManager(ns3::Ptr const stationManager) [member function] cls.add_method('SetWifiRemoteStationManager', 'void', - [param('ns3::Ptr< ns3::WifiRemoteStationManager >', 'stationManager')], + [param('ns3::Ptr< ns3::WifiRemoteStationManager > const', 'stationManager')], is_virtual=True) ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::SetLinkUpCallback(ns3::Callback linkUp) [member function] cls.add_method('SetLinkUpCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'linkUp')], is_virtual=True) - ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] + ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to')], is_virtual=True) - ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] + ## ap-wifi-mac.h (module 'wifi'): void ns3::ApWifiMac::Enqueue(ns3::Ptr packet, ns3::Mac48Address to, ns3::Mac48Address from) [member function] cls.add_method('Enqueue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')], @@ -19095,6 +19941,644 @@ def register_Ns3ApWifiMac_methods(root_module, cls): visibility='private', is_virtual=True) return +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Bool_Unsigned_int_Double_Ns3Time_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, bool, unsigned int, double, ns3::Time, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(bool arg0, unsigned int arg1, double arg2, ns3::Time arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('bool', 'arg0'), param('unsigned int', 'arg1'), param('double', 'arg2'), param('ns3::Time', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Const_ns3WifiMacHeader___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::WifiMacHeader const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::WifiMacHeader const & arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::WifiMacHeader const &', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Double_Double_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, double, double, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(double arg0, double arg1, ns3::Mac48Address arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('double', 'arg0'), param('double', 'arg1'), param('ns3::Mac48Address', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(double arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('double', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(double arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('double', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(int arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('int', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3DataRate_Ns3DataRate_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::DataRate, ns3::DataRate, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::DataRate arg0, ns3::DataRate arg1, ns3::Mac48Address arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::DataRate', 'arg0'), param('ns3::DataRate', 'arg1'), param('ns3::Mac48Address', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::Mac48Address arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Mac48Address', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::MobilityModel const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::MobilityModel const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3WifiMode_Ns3WifiPreamble_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::WifiMode, ns3::WifiPreamble, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::WifiMode arg2, ns3::WifiPreamble arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('double', 'arg1'), param('ns3::WifiMode', 'arg2'), param('ns3::WifiPreamble', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Mac48Address arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::Mac48Address', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3WifiMode_Ns3WifiPreamble_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::WifiMode, ns3::WifiPreamble, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::WifiMode arg1, ns3::WifiPreamble arg2, unsigned char arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::WifiMode', 'arg1'), param('ns3::WifiPreamble', 'arg2'), param('unsigned char', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3WifiTxVector_Ns3MpduInfo_Ns3SignalNoiseDbm_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::SignalNoiseDbm, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, short unsigned int arg1, ns3::WifiTxVector arg2, ns3::MpduInfo arg3, ns3::SignalNoiseDbm arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('short unsigned int', 'arg1'), param('ns3::WifiTxVector', 'arg2'), param('ns3::MpduInfo', 'arg3'), param('ns3::SignalNoiseDbm', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3WifiTxVector_Ns3MpduInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned short, ns3::WifiTxVector, ns3::MpduInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, short unsigned int arg1, ns3::WifiTxVector arg2, ns3::MpduInfo arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('short unsigned int', 'arg1'), param('ns3::WifiTxVector', 'arg2'), param('ns3::MpduInfo', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3WifiMacQueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::WifiMacQueueItem const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::WifiMacQueueItem const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3WifiMacHeader___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, ns3::WifiMacHeader const *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::WifiMacHeader *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::WifiMacHeader const * arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::WifiMacHeader const *', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3WifiTxVector_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::WifiTxVector, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::WifiTxVector arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1'), param('ns3::WifiTxVector', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Ns3WifiPhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Time, ns3::Time, ns3::WifiPhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::Time arg0, ns3::Time arg1, ns3::WifiPhy::State arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Time', 'arg0'), param('ns3::Time', 'arg1'), param('ns3::WifiPhy::State', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Time, ns3::Time, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::Time arg0, ns3::Time arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Time', 'arg0'), param('ns3::Time', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned int arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned int', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Ns3Mac48Address_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, ns3::Mac48Address, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, ns3::Mac48Address arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('ns3::Mac48Address', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, long unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('long unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3QueueDiscItem_methods(root_module, cls): ## queue-item.h (module 'network'): ns3::QueueDiscItem::QueueDiscItem(ns3::Ptr p, ns3::Address const & addr, uint16_t protocol) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::Packet >', 'p'), param('ns3::Address const &', 'addr'), param('uint16_t', 'protocol')]) @@ -19135,7 +20619,7 @@ def register_Ns3QueueDiscItem_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -19157,7 +20641,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -19179,7 +20663,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -19196,7 +20680,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -19218,7 +20702,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -19241,83 +20725,87 @@ def register_Ns3HashFunctionMurmur3_methods(root_module, cls): def register_functions(root_module): module = root_module - ## wifi-utils.h (module 'wifi'): extern uint16_t ns3::ConvertGuardIntervalToNanoSeconds(ns3::WifiMode mode, bool htShortGuardInterval, ns3::Time heGuardInterval) [free function] + ## wifi-utils.h (module 'wifi'): uint16_t ns3::ConvertGuardIntervalToNanoSeconds(ns3::WifiMode mode, bool htShortGuardInterval, ns3::Time heGuardInterval) [free function] module.add_function('ConvertGuardIntervalToNanoSeconds', 'uint16_t', [param('ns3::WifiMode', 'mode'), param('bool', 'htShortGuardInterval'), param('ns3::Time', 'heGuardInterval')]) - ## wifi-utils.h (module 'wifi'): extern double ns3::DbToRatio(double db) [free function] + ## wifi-utils.h (module 'wifi'): double ns3::DbToRatio(double db) [free function] module.add_function('DbToRatio', 'double', [param('double', 'db')]) - ## wifi-utils.h (module 'wifi'): extern double ns3::DbmToW(double dbm) [free function] + ## wifi-utils.h (module 'wifi'): double ns3::DbmToW(double dbm) [free function] module.add_function('DbmToW', 'double', [param('double', 'dbm')]) - ## qos-utils.h (module 'wifi'): extern uint8_t ns3::GetTid(ns3::Ptr packet, ns3::WifiMacHeader const hdr) [free function] + ## qos-utils.h (module 'wifi'): uint8_t ns3::GetTid(ns3::Ptr packet, ns3::WifiMacHeader const hdr) [free function] module.add_function('GetTid', 'uint8_t', [param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::WifiMacHeader const', 'hdr')]) - ## dsss-parameter-set.h (module 'wifi'): extern ns3::Ptr ns3::MakeDsssParameterSetChecker() [free function] + ## wifi-utils.h (module 'wifi'): double ns3::Log2(double val) [free function] + module.add_function('Log2', + 'double', + [param('double', 'val')]) + ## dsss-parameter-set.h (module 'wifi'): ns3::Ptr ns3::MakeDsssParameterSetChecker() [free function] module.add_function('MakeDsssParameterSetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## edca-parameter-set.h (module 'wifi'): extern ns3::Ptr ns3::MakeEdcaParameterSetChecker() [free function] + ## edca-parameter-set.h (module 'wifi'): ns3::Ptr ns3::MakeEdcaParameterSetChecker() [free function] module.add_function('MakeEdcaParameterSetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## erp-information.h (module 'wifi'): extern ns3::Ptr ns3::MakeErpInformationChecker() [free function] + ## erp-information.h (module 'wifi'): ns3::Ptr ns3::MakeErpInformationChecker() [free function] module.add_function('MakeErpInformationChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## he-capabilities.h (module 'wifi'): extern ns3::Ptr ns3::MakeHeCapabilitiesChecker() [free function] + ## he-capabilities.h (module 'wifi'): ns3::Ptr ns3::MakeHeCapabilitiesChecker() [free function] module.add_function('MakeHeCapabilitiesChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ht-capabilities.h (module 'wifi'): extern ns3::Ptr ns3::MakeHtCapabilitiesChecker() [free function] + ## ht-capabilities.h (module 'wifi'): ns3::Ptr ns3::MakeHtCapabilitiesChecker() [free function] module.add_function('MakeHtCapabilitiesChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ht-operation.h (module 'wifi'): extern ns3::Ptr ns3::MakeHtOperationChecker() [free function] + ## ht-operation.h (module 'wifi'): ns3::Ptr ns3::MakeHtOperationChecker() [free function] module.add_function('MakeHtOperationChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ssid.h (module 'wifi'): extern ns3::Ptr ns3::MakeSsidChecker() [free function] + ## ssid.h (module 'wifi'): ns3::Ptr ns3::MakeSsidChecker() [free function] module.add_function('MakeSsidChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vht-capabilities.h (module 'wifi'): extern ns3::Ptr ns3::MakeVhtCapabilitiesChecker() [free function] + ## vht-capabilities.h (module 'wifi'): ns3::Ptr ns3::MakeVhtCapabilitiesChecker() [free function] module.add_function('MakeVhtCapabilitiesChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vht-operation.h (module 'wifi'): extern ns3::Ptr ns3::MakeVhtOperationChecker() [free function] + ## vht-operation.h (module 'wifi'): ns3::Ptr ns3::MakeVhtOperationChecker() [free function] module.add_function('MakeVhtOperationChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## wifi-mode.h (module 'wifi'): extern ns3::Ptr ns3::MakeWifiModeChecker() [free function] + ## wifi-mode.h (module 'wifi'): ns3::Ptr ns3::MakeWifiModeChecker() [free function] module.add_function('MakeWifiModeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## qos-utils.h (module 'wifi'): extern uint8_t ns3::QosUtilsGetTidForPacket(ns3::Ptr packet) [free function] + ## qos-utils.h (module 'wifi'): uint8_t ns3::QosUtilsGetTidForPacket(ns3::Ptr packet) [free function] module.add_function('QosUtilsGetTidForPacket', 'uint8_t', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## qos-utils.h (module 'wifi'): extern bool ns3::QosUtilsIsOldPacket(uint16_t startingSeq, uint16_t seqNumber) [free function] + ## qos-utils.h (module 'wifi'): bool ns3::QosUtilsIsOldPacket(uint16_t startingSeq, uint16_t seqNumber) [free function] module.add_function('QosUtilsIsOldPacket', 'bool', [param('uint16_t', 'startingSeq'), param('uint16_t', 'seqNumber')]) - ## qos-utils.h (module 'wifi'): extern uint32_t ns3::QosUtilsMapSeqControlToUniqueInteger(uint16_t seqControl, uint16_t endSequence) [free function] + ## qos-utils.h (module 'wifi'): uint32_t ns3::QosUtilsMapSeqControlToUniqueInteger(uint16_t seqControl, uint16_t endSequence) [free function] module.add_function('QosUtilsMapSeqControlToUniqueInteger', 'uint32_t', [param('uint16_t', 'seqControl'), param('uint16_t', 'endSequence')]) - ## qos-utils.h (module 'wifi'): extern ns3::AcIndex ns3::QosUtilsMapTidToAc(uint8_t tid) [free function] + ## qos-utils.h (module 'wifi'): ns3::AcIndex ns3::QosUtilsMapTidToAc(uint8_t tid) [free function] module.add_function('QosUtilsMapTidToAc', 'ns3::AcIndex', [param('uint8_t', 'tid')]) - ## wifi-utils.h (module 'wifi'): extern double ns3::RatioToDb(double ratio) [free function] + ## wifi-utils.h (module 'wifi'): double ns3::RatioToDb(double ratio) [free function] module.add_function('RatioToDb', 'double', [param('double', 'ratio')]) - ## wifi-utils.h (module 'wifi'): extern double ns3::WToDbm(double w) [free function] + ## wifi-utils.h (module 'wifi'): double ns3::WToDbm(double w) [free function] module.add_function('WToDbm', 'double', [param('double', 'w')]) From 524685f5df20eecedab2ec63a6b4cec107b6181a Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Tue, 4 Jul 2017 18:19:06 +0200 Subject: [PATCH 136/551] wifi: Define WifiMacQueue as a subclass of Queue --- src/wifi/model/block-ack-manager.h | 4 +- src/wifi/model/mac-low.h | 3 +- src/wifi/model/wifi-mac-queue.cc | 27 ++---------- src/wifi/model/wifi-mac-queue.h | 66 ++++++++++-------------------- 4 files changed, 26 insertions(+), 74 deletions(-) diff --git a/src/wifi/model/block-ack-manager.h b/src/wifi/model/block-ack-manager.h index 2e308693cc6..7ad8a7e414e 100644 --- a/src/wifi/model/block-ack-manager.h +++ b/src/wifi/model/block-ack-manager.h @@ -33,9 +33,7 @@ namespace ns3 { class MgtAddBaResponseHeader; class MgtAddBaRequestHeader; class MacTxMiddle; -class WifiMacQueueItem; -template class WifiQueue; -typedef WifiQueue WifiMacQueue; +class WifiMacQueue; /** * \ingroup wifi diff --git a/src/wifi/model/mac-low.h b/src/wifi/model/mac-low.h index afc02b3a7e3..4c622b990ed 100644 --- a/src/wifi/model/mac-low.h +++ b/src/wifi/model/mac-low.h @@ -41,8 +41,7 @@ class DcaTxop; class EdcaTxopN; class DcfManager; class WifiMacQueueItem; -template class WifiQueue; -typedef WifiQueue WifiMacQueue; +class WifiMacQueue; /** * \brief control how a packet is transmitted. diff --git a/src/wifi/model/wifi-mac-queue.cc b/src/wifi/model/wifi-mac-queue.cc index 279e4188a42..fa801620256 100644 --- a/src/wifi/model/wifi-mac-queue.cc +++ b/src/wifi/model/wifi-mac-queue.cc @@ -87,8 +87,8 @@ WifiMacQueueItem::GetSize (void) const NS_OBJECT_TEMPLATE_CLASS_DEFINE (Queue,WifiMacQueueItem); +NS_OBJECT_ENSURE_REGISTERED (WifiMacQueue); -template<> TypeId WifiMacQueue::GetTypeId (void) { @@ -109,19 +109,16 @@ WifiMacQueue::GetTypeId (void) return tid; } -template<> -WifiMacQueue::WifiQueue () +WifiMacQueue::WifiMacQueue () : NS_LOG_TEMPLATE_DEFINE ("WifiMacQueue") { } -template<> -WifiMacQueue::~WifiQueue () +WifiMacQueue::~WifiMacQueue () { NS_LOG_FUNCTION_NOARGS (); } -template<> void WifiMacQueue::SetMaxDelay (Time delay) { @@ -130,7 +127,6 @@ WifiMacQueue::SetMaxDelay (Time delay) m_maxDelay = delay; } -template<> Time WifiMacQueue::GetMaxDelay (void) const { @@ -139,7 +135,6 @@ WifiMacQueue::GetMaxDelay (void) const return m_maxDelay; } -template<> bool WifiMacQueue::TtlExceeded (ConstIterator &it) { @@ -156,7 +151,6 @@ WifiMacQueue::TtlExceeded (ConstIterator &it) return false; } -template<> bool WifiMacQueue::Enqueue (Ptr item) { @@ -184,7 +178,6 @@ WifiMacQueue::Enqueue (Ptr item) return DoEnqueue (Tail (), item); } -template<> bool WifiMacQueue::PushFront (Ptr item) { @@ -212,7 +205,6 @@ WifiMacQueue::PushFront (Ptr item) return DoEnqueue (Head (), item); } -template<> Ptr WifiMacQueue::Dequeue (void) { @@ -229,7 +221,6 @@ WifiMacQueue::Dequeue (void) return 0; } -template<> Ptr WifiMacQueue::DequeueByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address dest) @@ -253,7 +244,6 @@ WifiMacQueue::DequeueByTidAndAddress (uint8_t tid, return 0; } -template<> Ptr WifiMacQueue::DequeueFirstAvailable (const Ptr blockedPackets) { @@ -276,7 +266,6 @@ WifiMacQueue::DequeueFirstAvailable (const Ptr blockedPa return 0; } -template<> Ptr WifiMacQueue::Peek (void) const { @@ -295,7 +284,6 @@ WifiMacQueue::Peek (void) const return 0; } -template<> Ptr WifiMacQueue::PeekByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address dest) @@ -319,7 +307,6 @@ WifiMacQueue::PeekByTidAndAddress (uint8_t tid, return 0; } -template<> Ptr WifiMacQueue::PeekFirstAvailable (const Ptr blockedPackets) { @@ -342,7 +329,6 @@ WifiMacQueue::PeekFirstAvailable (const Ptr blockedPacke return 0; } -template<> Ptr WifiMacQueue::Remove (void) { @@ -359,7 +345,6 @@ WifiMacQueue::Remove (void) return 0; } -template<> bool WifiMacQueue::Remove (Ptr packet) { @@ -382,7 +367,6 @@ WifiMacQueue::Remove (Ptr packet) return false; } -template<> uint32_t WifiMacQueue::GetNPacketsByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address addr) @@ -408,7 +392,6 @@ WifiMacQueue::GetNPacketsByTidAndAddress (uint8_t tid, WifiMacHeader::AddressTyp return nPackets; } -template<> bool WifiMacQueue::IsEmpty (void) { @@ -426,7 +409,6 @@ WifiMacQueue::IsEmpty (void) return true; } -template<> uint32_t WifiMacQueue::GetNPackets (void) { @@ -443,7 +425,6 @@ WifiMacQueue::GetNPackets (void) return QueueBase::GetNPackets (); } -template<> uint32_t WifiMacQueue::GetNBytes (void) { @@ -460,6 +441,4 @@ WifiMacQueue::GetNBytes (void) return QueueBase::GetNBytes (); } -NS_OBJECT_TEMPLATE_CLASS_DEFINE (WifiQueue,WifiMacQueueItem); - } //namespace ns3 diff --git a/src/wifi/model/wifi-mac-queue.h b/src/wifi/model/wifi-mac-queue.h index 0ba602da042..b2761b401a8 100644 --- a/src/wifi/model/wifi-mac-queue.h +++ b/src/wifi/model/wifi-mac-queue.h @@ -107,6 +107,14 @@ class WifiMacQueueItem : public SimpleRefCount }; +// The following explicit template instantiation declaration prevents modules +// including this header file from implicitly instantiating Queue. +// This would cause python examples using wifi to crash at runtime with the +// following error message: "Trying to allocate twice the same uid: +// ns3::Queue" +extern template class Queue; + + /** * \ingroup wifi * @@ -121,32 +129,8 @@ class WifiMacQueueItem : public SimpleRefCount * to verify whether or not it should be dropped. If * dot11EDCATableMSDULifetime has elapsed, it is dropped. * Otherwise, it is returned to the caller. - * - * WifiMacQueue could have been declared as a subclass of Queue, - * but this would have caused python examples using wifi to crash at runtime - * with the following error message: "Trying to allocate twice the same uid: - * ns3::Queue". Such an error wasn't fully debugged but it - * may have been due to static initialization order issues. - * - * To avoid such an error, the template class WifiQueue is introduced - * as a subclass of Queue. WifiMacQueue is then declared as a - * specialization of WifiQueue with Item equal to WifiMacQueueItem. - * The methods of the WifiQueue class are left unimplemented for Item other - * than WifiMacQueueItem. - * - * Modules that need to forward declare WifiMacQueue have to include the - * following: - * - * \code - * class WifiMacQueueItem; - * template class WifiQueue; - * typedef WifiQueue WifiMacQueue; - * \endcode - * - * in their header file. */ -template -class WifiQueue : public Queue +class WifiMacQueue : public Queue { public: /** @@ -154,8 +138,8 @@ class WifiQueue : public Queue * \return the object TypeId */ static TypeId GetTypeId (void); - WifiQueue (); - ~WifiQueue (); + WifiMacQueue (); + ~WifiMacQueue (); /// drop policy enum DropPolicy @@ -183,20 +167,20 @@ class WifiQueue : public Queue * \param item the Wifi MAC queue item to be enqueued at the end * \return true if success, false if the packet has been dropped */ - bool Enqueue (Ptr item); + bool Enqueue (Ptr item); /** * Enqueue the given Wifi MAC queue item at the front of the queue. * * \param item the Wifi MAC queue item to be enqueued at the front * \return true if success, false if the packet has been dropped */ - bool PushFront (Ptr item); + bool PushFront (Ptr item); /** * Dequeue the packet in the front of the queue. * * \return the packet */ - Ptr Dequeue (void); + Ptr Dequeue (void); /** * Search and return, if present in the queue, the first packet having the * address indicated by type equal to addr, and tid @@ -210,7 +194,7 @@ class WifiQueue : public Queue * * \return the packet */ - Ptr DequeueByTidAndAddress (uint8_t tid, + Ptr DequeueByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address addr); /** @@ -224,13 +208,13 @@ class WifiQueue : public Queue * * \return packet */ - Ptr DequeueFirstAvailable (const Ptr blockedPackets); + Ptr DequeueFirstAvailable (const Ptr blockedPackets); /** * Peek the packet in the front of the queue. The packet is not removed. * * \return the packet */ - Ptr Peek (void) const; + Ptr Peek (void) const; /** * Search and return, if present in the queue, the first packet having the * address indicated by type equal to addr, and tid @@ -244,7 +228,7 @@ class WifiQueue : public Queue * * \return packet */ - Ptr PeekByTidAndAddress (uint8_t tid, + Ptr PeekByTidAndAddress (uint8_t tid, WifiMacHeader::AddressType type, Mac48Address addr); /** @@ -254,13 +238,13 @@ class WifiQueue : public Queue * * \return packet */ - Ptr PeekFirstAvailable (const Ptr blockedPackets); + Ptr PeekFirstAvailable (const Ptr blockedPackets); /** * Remove the packet in the front of the queue. * * \return the packet */ - Ptr Remove (void); + Ptr Remove (void); /** * If exists, removes packet from queue and returns true. Otherwise it * takes no effects and return false. Deletion of the packet is @@ -315,7 +299,7 @@ class WifiQueue : public Queue * \param it an iterator pointing to the item * \return true if the item is removed, false otherwise */ - bool TtlExceeded (typename Queue::ConstIterator &it); + bool TtlExceeded (ConstIterator &it); Time m_maxDelay; //!< Time to live for packets in the queue DropPolicy m_dropPolicy; //!< Drop behavior of queue @@ -323,14 +307,6 @@ class WifiQueue : public Queue NS_LOG_TEMPLATE_DECLARE; //!< redefinition of the log component }; -/// Forward declare overridden methods to avoid specializing after instantiation -template<> bool WifiQueue::IsEmpty (void); -template<> uint32_t WifiQueue::GetNPackets (void); -template<> uint32_t WifiQueue::GetNBytes (void); - -/// Declare WifiMacQueue as a specialization of template class WifiQueue -typedef WifiQueue WifiMacQueue; - } //namespace ns3 #endif /* WIFI_MAC_QUEUE_H */ From 5f78e3f9368f9c807d5a3606c5847212578c0928 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Tue, 4 Jul 2017 18:19:19 +0200 Subject: [PATCH 137/551] wifi: Rescan bindings (64-bit only) --- src/wifi/bindings/modulegen__gcc_LP64.py | 187 +++++++++++------------ 1 file changed, 92 insertions(+), 95 deletions(-) diff --git a/src/wifi/bindings/modulegen__gcc_LP64.py b/src/wifi/bindings/modulegen__gcc_LP64.py index be85fdfe699..eb30ef39855 100644 --- a/src/wifi/bindings/modulegen__gcc_LP64.py +++ b/src/wifi/bindings/modulegen__gcc_LP64.py @@ -714,7 +714,7 @@ def register_types(module): module.add_class('ParfWifiManager', parent=root_module['ns3::WifiRemoteStationManager']) ## qos-blocked-destinations.h (module 'wifi'): ns3::QosBlockedDestinations [class] module.add_class('QosBlockedDestinations', parent=root_module['ns3::SimpleRefCount< ns3::QosBlockedDestinations, ns3::empty, ns3::DefaultDeleter >']) - ## queue.h (module 'network'): ns3::Queue [class] + ## wifi-mac-queue.h (module 'wifi'): ns3::Queue [class] module.add_class('Queue', template_parameters=['ns3::WifiMacQueueItem'], parent=root_module['ns3::QueueBase']) ## queue-item.h (module 'network'): ns3::QueueItem [class] module.add_class('QueueItem', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >']) @@ -774,16 +774,16 @@ def register_types(module): module.add_class('VhtOperationChecker', parent=root_module['ns3::AttributeChecker']) ## vht-operation.h (module 'wifi'): ns3::VhtOperationValue [class] module.add_class('VhtOperationValue', parent=root_module['ns3::AttributeValue']) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueue [class] + module.add_class('WifiMacQueue', parent=root_module['ns3::Queue< ns3::WifiMacQueueItem >']) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueue::DropPolicy [enumeration] + module.add_enum('DropPolicy', ['DROP_NEWEST', 'DROP_OLDEST'], outer_class=root_module['ns3::WifiMacQueue']) ## wifi-mode.h (module 'wifi'): ns3::WifiModeChecker [class] module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker']) ## wifi-mode.h (module 'wifi'): ns3::WifiModeValue [class] module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue']) ## wifi-net-device.h (module 'wifi'): ns3::WifiNetDevice [class] module.add_class('WifiNetDevice', parent=root_module['ns3::NetDevice']) - ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue [class] - module.add_class('WifiMacQueue', parent=root_module['ns3::Queue< ns3::WifiMacQueueItem >']) - ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue::DropPolicy [enumeration] - module.add_enum('DropPolicy', ['DROP_NEWEST', 'DROP_OLDEST'], outer_class=root_module['ns3::WifiMacQueue']) ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel [class] module.add_class('WifiRadioEnergyModel', parent=root_module['ns3::DeviceEnergyModel']) ## yans-error-rate-model.h (module 'wifi'): ns3::YansErrorRateModel [class] @@ -872,9 +872,6 @@ def register_types(module): module.add_container('ns3::MpduAggregator::DeaggregatedMpdus', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmpduSubframeHeader >', container_type=u'list') module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type=u'list') module.add_container('ns3::MsduAggregator::DeaggregatedMsdus', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::AmsduSubframeHeader >', container_type=u'list') - typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >', u'ns3::WifiMacQueue') - typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >*', u'ns3::WifiMacQueue*') - typehandlers.add_type_alias(u'ns3::WifiQueue< ns3::WifiMacQueueItem >&', u'ns3::WifiMacQueue&') typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') @@ -1375,10 +1372,10 @@ def register_methods(root_module): register_Ns3VhtOperation_methods(root_module, root_module['ns3::VhtOperation']) register_Ns3VhtOperationChecker_methods(root_module, root_module['ns3::VhtOperationChecker']) register_Ns3VhtOperationValue_methods(root_module, root_module['ns3::VhtOperationValue']) + register_Ns3WifiMacQueue_methods(root_module, root_module['ns3::WifiMacQueue']) register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker']) register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue']) register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice']) - register_Ns3WifiMacQueue_methods(root_module, root_module['ns3::WifiMacQueue']) register_Ns3WifiRadioEnergyModel_methods(root_module, root_module['ns3::WifiRadioEnergyModel']) register_Ns3YansErrorRateModel_methods(root_module, root_module['ns3::YansErrorRateModel']) register_Ns3YansWifiChannel_methods(root_module, root_module['ns3::YansWifiChannel']) @@ -11861,10 +11858,10 @@ def register_Ns3BlockAckManager_methods(root_module, cls): cls.add_method('SetMaxPacketDelay', 'void', [param('ns3::Time', 'maxDelay')]) - ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetQueue(ns3::Ptr > const queue) [member function] + ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetQueue(ns3::Ptr const queue) [member function] cls.add_method('SetQueue', 'void', - [param('ns3::Ptr< ns3::WifiQueue< ns3::WifiMacQueueItem > > const', 'queue')]) + [param('ns3::Ptr< ns3::WifiMacQueue > const', 'queue')]) ## block-ack-manager.h (module 'wifi'): void ns3::BlockAckManager::SetTxFailedCallback(ns3::BlockAckManager::TxFailed callback) [member function] cls.add_method('SetTxFailedCallback', 'void', @@ -12745,9 +12742,9 @@ def register_Ns3DcaTxop_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## dca-txop.h (module 'wifi'): ns3::Ptr > ns3::DcaTxop::GetQueue() const [member function] + ## dca-txop.h (module 'wifi'): ns3::Ptr ns3::DcaTxop::GetQueue() const [member function] cls.add_method('GetQueue', - 'ns3::Ptr< ns3::WifiQueue< ns3::WifiMacQueueItem > >', + 'ns3::Ptr< ns3::WifiMacQueue >', [], is_const=True) ## dca-txop.h (module 'wifi'): ns3::Time ns3::DcaTxop::GetTxopLimit() const [member function] @@ -17720,7 +17717,7 @@ def register_Ns3Queue__Ns3WifiMacQueueItem_methods(root_module, cls): cls.add_method('Flush', 'void', []) - ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + ## wifi-mac-queue.h (module 'wifi'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] cls.add_constructor([param('ns3::Queue< ns3::WifiMacQueueItem > const &', 'arg0')]) ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] cls.add_method('Head', @@ -19280,6 +19277,87 @@ def register_Ns3VhtOperationValue_methods(root_module, cls): [param('ns3::VhtOperation const &', 'value')]) return +def register_Ns3WifiMacQueue_methods(root_module, cls): + ## wifi-mac-queue.h (module 'wifi'): static ns3::TypeId ns3::WifiMacQueue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueue::WifiMacQueue() [constructor] + cls.add_constructor([]) + ## wifi-mac-queue.h (module 'wifi'): void ns3::WifiMacQueue::SetMaxDelay(ns3::Time delay) [member function] + cls.add_method('SetMaxDelay', + 'void', + [param('ns3::Time', 'delay')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Time ns3::WifiMacQueue::GetMaxDelay() const [member function] + cls.add_method('GetMaxDelay', + 'ns3::Time', + [], + is_const=True) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiMacQueue::Enqueue(ns3::Ptr item) [member function] + cls.add_method('Enqueue', + 'bool', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiMacQueue::PushFront(ns3::Ptr item) [member function] + cls.add_method('PushFront', + 'bool', + [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::DequeueByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('DequeueByTidAndAddress', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::DequeueFirstAvailable(ns3::Ptr const blockedPackets) [member function] + cls.add_method('DequeueFirstAvailable', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::Peek() const [member function] + cls.add_method('Peek', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [], + is_const=True, is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::PeekByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('PeekByTidAndAddress', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::PeekFirstAvailable(ns3::Ptr const blockedPackets) [member function] + cls.add_method('PeekFirstAvailable', + 'ns3::Ptr< ns3::WifiMacQueueItem const >', + [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) + ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiMacQueue::Remove() [member function] + cls.add_method('Remove', + 'ns3::Ptr< ns3::WifiMacQueueItem >', + [], + is_virtual=True) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiMacQueue::Remove(ns3::Ptr packet) [member function] + cls.add_method('Remove', + 'bool', + [param('ns3::Ptr< ns3::Packet const >', 'packet')]) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiMacQueue::GetNPacketsByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] + cls.add_method('GetNPacketsByTidAndAddress', + 'uint32_t', + [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) + ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiMacQueue::IsEmpty() [member function] + cls.add_method('IsEmpty', + 'bool', + []) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiMacQueue::GetNPackets() [member function] + cls.add_method('GetNPackets', + 'uint32_t', + []) + ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiMacQueue::GetNBytes() [member function] + cls.add_method('GetNBytes', + 'uint32_t', + []) + ## wifi-mac-queue.h (module 'wifi'): ns3::WifiMacQueue::WifiMacQueue(ns3::WifiMacQueue const & arg0) [constructor] + cls.add_constructor([param('ns3::WifiMacQueue const &', 'arg0')]) + return + def register_Ns3WifiModeChecker_methods(root_module, cls): ## wifi-mode.h (module 'wifi'): ns3::WifiModeChecker::WifiModeChecker() [constructor] cls.add_constructor([]) @@ -19497,87 +19575,6 @@ def register_Ns3WifiNetDevice_methods(root_module, cls): visibility='protected') return -def register_Ns3WifiMacQueue_methods(root_module, cls): - ## mac-low.h (module 'wifi'): ns3::WifiQueue::WifiQueue(ns3::WifiQueue const & arg0) [constructor] - cls.add_constructor([param('ns3::WifiQueue< ns3::WifiMacQueueItem > const &', 'arg0')]) - ## wifi-mac-queue.h (module 'wifi'): ns3::WifiQueue::WifiQueue() [constructor] - cls.add_constructor([]) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Dequeue() [member function] - cls.add_method('Dequeue', - 'ns3::Ptr< ns3::WifiMacQueueItem >', - [], - is_virtual=True) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::DequeueByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] - cls.add_method('DequeueByTidAndAddress', - 'ns3::Ptr< ns3::WifiMacQueueItem >', - [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::DequeueFirstAvailable(ns3::Ptr const blockedPackets) [member function] - cls.add_method('DequeueFirstAvailable', - 'ns3::Ptr< ns3::WifiMacQueueItem >', - [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) - ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::Enqueue(ns3::Ptr item) [member function] - cls.add_method('Enqueue', - 'bool', - [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')], - is_virtual=True) - ## wifi-mac-queue.h (module 'wifi'): ns3::Time ns3::WifiQueue::GetMaxDelay() const [member function] - cls.add_method('GetMaxDelay', - 'ns3::Time', - [], - is_const=True) - ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNBytes() [member function] - cls.add_method('GetNBytes', - 'uint32_t', - []) - ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNPackets() [member function] - cls.add_method('GetNPackets', - 'uint32_t', - []) - ## wifi-mac-queue.h (module 'wifi'): uint32_t ns3::WifiQueue::GetNPacketsByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] - cls.add_method('GetNPacketsByTidAndAddress', - 'uint32_t', - [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) - ## wifi-mac-queue.h (module 'wifi'): static ns3::TypeId ns3::WifiQueue::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', - [], - is_static=True) - ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::IsEmpty() [member function] - cls.add_method('IsEmpty', - 'bool', - []) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Peek() const [member function] - cls.add_method('Peek', - 'ns3::Ptr< ns3::WifiMacQueueItem const >', - [], - is_const=True, is_virtual=True) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::PeekByTidAndAddress(uint8_t tid, ns3::WifiMacHeader::AddressType type, ns3::Mac48Address addr) [member function] - cls.add_method('PeekByTidAndAddress', - 'ns3::Ptr< ns3::WifiMacQueueItem const >', - [param('uint8_t', 'tid'), param('ns3::WifiMacHeader::AddressType', 'type'), param('ns3::Mac48Address', 'addr')]) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::PeekFirstAvailable(ns3::Ptr const blockedPackets) [member function] - cls.add_method('PeekFirstAvailable', - 'ns3::Ptr< ns3::WifiMacQueueItem const >', - [param('ns3::Ptr< ns3::QosBlockedDestinations > const', 'blockedPackets')]) - ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::PushFront(ns3::Ptr item) [member function] - cls.add_method('PushFront', - 'bool', - [param('ns3::Ptr< ns3::WifiMacQueueItem >', 'item')]) - ## wifi-mac-queue.h (module 'wifi'): ns3::Ptr ns3::WifiQueue::Remove() [member function] - cls.add_method('Remove', - 'ns3::Ptr< ns3::WifiMacQueueItem >', - [], - is_virtual=True) - ## wifi-mac-queue.h (module 'wifi'): bool ns3::WifiQueue::Remove(ns3::Ptr packet) [member function] - cls.add_method('Remove', - 'bool', - [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## wifi-mac-queue.h (module 'wifi'): void ns3::WifiQueue::SetMaxDelay(ns3::Time delay) [member function] - cls.add_method('SetMaxDelay', - 'void', - [param('ns3::Time', 'delay')]) - return - def register_Ns3WifiRadioEnergyModel_methods(root_module, cls): ## wifi-radio-energy-model.h (module 'wifi'): ns3::WifiRadioEnergyModel::WifiRadioEnergyModel(ns3::WifiRadioEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::WifiRadioEnergyModel const &', 'arg0')]) From 944e85dbf0d7da11a0a030e17f7dc03e5c746259 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 4 Jul 2017 20:47:52 +0200 Subject: [PATCH 138/551] wifi: (fixes #2673) Update WiFi spectrum model when channel is switched at run-time --- RELEASE_NOTES | 1 + src/wifi/model/spectrum-wifi-phy.cc | 56 +++++++++++++++++++++++++++++ src/wifi/model/spectrum-wifi-phy.h | 15 ++++++++ src/wifi/model/wifi-phy.h | 11 +++--- 4 files changed, 77 insertions(+), 6 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 11a25855a26..e7f853ca66b 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -101,6 +101,7 @@ Bugs fixed - Bug 2660 - TrafficControlHelper::Default should not configure internal queue sizes - Bug 2665 - Ipv4RawSocket can not send packets to broadcast or multicast - Bug 2671 - ArpCache::Entry::SetMacAddress is misspelled +- Bug 2673 - run-time channel switch does not update WiFi spectrum model - Bug 2717 - Fix mask generation for Ipv4RoutingTableEntry::CreateDefaultRoute - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. diff --git a/src/wifi/model/spectrum-wifi-phy.cc b/src/wifi/model/spectrum-wifi-phy.cc index 49306a6f3d8..e383fae283b 100644 --- a/src/wifi/model/spectrum-wifi-phy.cc +++ b/src/wifi/model/spectrum-wifi-phy.cc @@ -125,6 +125,62 @@ SpectrumWifiPhy::SetChannel (const Ptr channel) m_channel = channel; } +void +SpectrumWifiPhy::ResetSpectrumModel (void) +{ + NS_LOG_FUNCTION (this); + NS_ASSERT_MSG (IsInitialized (), "Executing method before run-time"); + NS_LOG_DEBUG ("Run-time change of spectrum model from frequency/width pair of (" << GetFrequency () << ", " << (uint16_t)GetChannelWidth () << ")"); + // Replace existing spectrum model with new one, and must call AddRx () + // on the SpectrumChannel to provide this new spectrum model to it + m_rxSpectrumModel = WifiSpectrumValueHelper::GetSpectrumModel (GetFrequency (), GetChannelWidth (), GetBandBandwidth (), GetGuardBandwidth ()); + m_channel->AddRx (m_wifiSpectrumPhyInterface); +} + +void +SpectrumWifiPhy::SetChannelNumber (uint8_t nch) +{ + NS_LOG_FUNCTION (this << (uint16_t) nch); + WifiPhy::SetChannelNumber (nch); + if (IsInitialized ()) + { + ResetSpectrumModel (); + } +} + +void +SpectrumWifiPhy::SetFrequency (uint16_t freq) +{ + NS_LOG_FUNCTION (this << freq); + WifiPhy::SetFrequency (freq); + if (IsInitialized ()) + { + ResetSpectrumModel (); + } +} + +void +SpectrumWifiPhy::SetChannelWidth (uint8_t channelwidth) +{ + NS_LOG_FUNCTION (this << (uint16_t) channelwidth); + WifiPhy::SetChannelWidth (channelwidth); + if (IsInitialized ()) + { + ResetSpectrumModel (); + } +} + +void +SpectrumWifiPhy::ConfigureStandard (WifiPhyStandard standard) +{ + NS_LOG_FUNCTION (this << standard); + WifiPhy::ConfigureStandard (standard); + if (IsInitialized ()) + { + ResetSpectrumModel (); + } +} + void SpectrumWifiPhy::AddOperationalChannel (uint8_t channelNumber) { diff --git a/src/wifi/model/spectrum-wifi-phy.h b/src/wifi/model/spectrum-wifi-phy.h index 0e804ebdee8..03deb9c01f5 100644 --- a/src/wifi/model/spectrum-wifi-phy.h +++ b/src/wifi/model/spectrum-wifi-phy.h @@ -160,6 +160,16 @@ class SpectrumWifiPhy : public WifiPhy Ptr GetChannel (void) const; + // The following four methods call to the base WifiPhy class method + // but also generate a new SpectrumModel if called during runtime + + virtual void SetChannelNumber (uint8_t id); + + virtual void SetFrequency (uint16_t freq); + + virtual void SetChannelWidth (uint8_t channelwidth); + + virtual void ConfigureStandard (WifiPhyStandard standard); protected: // Inherited @@ -180,6 +190,11 @@ class SpectrumWifiPhy : public WifiPhy */ Ptr GetTxPowerSpectralDensity (uint16_t centerFrequency, uint8_t channelWidth, double txPowerW, WifiModulationClass modulationClass) const; + /** + * Perform run-time spectrum model change + */ + void ResetSpectrumModel (void); + Ptr m_channel; //!< SpectrumChannel that this SpectrumWifiPhy is connected to std::vector m_operationalChannelList; //!< List of possible channels diff --git a/src/wifi/model/wifi-phy.h b/src/wifi/model/wifi-phy.h index cfd91eb1d11..e36237cc524 100644 --- a/src/wifi/model/wifi-phy.h +++ b/src/wifi/model/wifi-phy.h @@ -588,14 +588,14 @@ class WifiPhy : public Object * * Channel center frequency = Channel starting frequency + 5 MHz * (nch - 1) * - * where Starting channel frequency is standard-dependent, see SetStandard() + * where Starting channel frequency is standard-dependent, * as defined in (Section 18.3.8.4.2 "Channel numbering"; IEEE Std 802.11-2012). * This method may fail to take action if the Phy model determines that * the channel number cannot be switched for some reason (e.g. sleep state) * * \param id the channel number */ - void SetChannelNumber (uint8_t id); + virtual void SetChannelNumber (uint8_t id); /** * Return current channel number. * @@ -612,7 +612,7 @@ class WifiPhy : public Object * * \param standard the Wi-Fi standard */ - void ConfigureStandard (WifiPhyStandard standard); + virtual void ConfigureStandard (WifiPhyStandard standard); /** * Get the configured Wi-Fi standard @@ -1488,7 +1488,7 @@ class WifiPhy : public Object /** * \param freq the operating center frequency (MHz) on this node. */ - void SetFrequency (uint16_t freq); + virtual void SetFrequency (uint16_t freq); /** * \return the operating center frequency (MHz) */ @@ -1628,7 +1628,7 @@ class WifiPhy : public Object /** * \param channelwidth channel width */ - void SetChannelWidth (uint8_t channelwidth); + virtual void SetChannelWidth (uint8_t channelwidth); /** * \param channelwidth channel width (in MHz) to support */ @@ -1695,7 +1695,6 @@ class WifiPhy : public Object EventId m_endRxEvent; //!< the end reeive event EventId m_endPlcpRxEvent; //!< the end PLCP receive event - private: /** * \brief post-construction setting of frequency and/or channel number From c6614ad0003ade1aa892d448d5e82982b6bfa56c Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 4 Jul 2017 20:52:51 +0200 Subject: [PATCH 139/551] wifi: (fixes #2733) Support NSS > 1 in ideal wifi manager --- RELEASE_NOTES | 1 + src/wifi/examples/wifi-manager-example.cc | 12 ++++ src/wifi/model/ideal-wifi-manager.cc | 74 +++++++++++------------ 3 files changed, 50 insertions(+), 37 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index e7f853ca66b..6ef5725d182 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -104,6 +104,7 @@ Bugs fixed - Bug 2673 - run-time channel switch does not update WiFi spectrum model - Bug 2717 - Fix mask generation for Ipv4RoutingTableEntry::CreateDefaultRoute - Bug 2722 - 802.11g sends DSSS spectrum signals using CreateOfdmTxPowerSpectralDensity +- Bug 2733 - Ideal wifi manager cannot handle NSS higher than 1 - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes - Bug 2757 - 802.11n/ac/ax maximum TXOP is not properly enforced diff --git a/src/wifi/examples/wifi-manager-example.cc b/src/wifi/examples/wifi-manager-example.cc index ae9db90506b..1cdc7c9fe58 100644 --- a/src/wifi/examples/wifi-manager-example.cc +++ b/src/wifi/examples/wifi-manager-example.cc @@ -182,6 +182,18 @@ int main (int argc, char *argv[]) cmd.AddValue ("infrastructure", "Use infrastructure instead of adhoc", infrastructure); cmd.Parse (argc,argv); + // Print out some explanation of what this program does + std::cout << std::endl << "This program demonstrates and plots the operation of different " << std::endl; + std::cout << "Wi-Fi rate controls on different station configurations," << std::endl; + std::cout << "by stepping down the received signal strength across a wide range" << std::endl; + std::cout << "and observing the adjustment of the rate." << std::endl; + std::cout << "Run 'wifi-manager-example --PrintHelp' to show program options."<< std::endl << std::endl; + + if (infrastructure == false) + { + NS_ABORT_MSG_IF (serverNss != clientNss, "In ad hoc mode, we assume sender and receiver are similarly configured"); + } + if (standard == "802.11b") { NS_ABORT_MSG_IF (serverChannelWidth != 22 && serverChannelWidth != 22, "Invalid channel width for standard " << standard); diff --git a/src/wifi/model/ideal-wifi-manager.cc b/src/wifi/model/ideal-wifi-manager.cc index c15acda691d..bf444f15293 100644 --- a/src/wifi/model/ideal-wifi-manager.cc +++ b/src/wifi/model/ideal-wifi-manager.cc @@ -38,6 +38,9 @@ struct IdealWifiRemoteStation : public WifiRemoteStation WifiMode m_lastMode; //!< Mode most recently used to the remote station }; +// To avoid using the cache before a valid value has been cached +static const double CACHE_INITIAL_VALUE = -100; + NS_OBJECT_ENSURE_REGISTERED (IdealWifiManager); NS_LOG_COMPONENT_DEFINE ("IdealWifiManager"); @@ -148,8 +151,7 @@ IdealWifiManager::DoInitialize () { guardInterval = GetPhy ()->GetGuardInterval ().GetNanoSeconds (); } - uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); - for (uint8_t i = 1; i <= maxNss; i++) + for (uint8_t i = 1; i <= GetPhy ()->GetMaxSupportedTxSpatialStreams (); i++) { NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () << " channel width " << (uint16_t) j << @@ -204,7 +206,7 @@ IdealWifiManager::DoCreateStation (void) const NS_LOG_FUNCTION (this); IdealWifiRemoteStation *station = new IdealWifiRemoteStation (); station->m_lastSnrObserved = 0.0; - station->m_lastSnrCached = 0.0; + station->m_lastSnrCached = CACHE_INITIAL_VALUE; station->m_lastMode = GetDefaultMode (); station->m_nss = 1; return station; @@ -280,17 +282,17 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) NS_LOG_FUNCTION (this << st); IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st; //We search within the Supported rate set the mode with the - //highest snr threshold possible which is smaller than m_lastSnr + //highest data rate for which the snr threshold is smaller than m_lastSnr //to ensure correct packet delivery. - double maxThreshold = 0.0; WifiMode maxMode = GetDefaultMode (); WifiTxVector txVector; WifiMode mode; + uint64_t bestRate = 0; uint8_t selectedNss = 1; uint16_t guardInterval; uint8_t channelWidth = std::min (GetChannelWidth (station), GetPhy ()->GetChannelWidth ()); txVector.SetChannelWidth (channelWidth); - if (station->m_lastSnrObserved == station->m_lastSnrCached) + if (station->m_lastSnrCached != CACHE_INITIAL_VALUE && station->m_lastSnrObserved == station->m_lastSnrCached) { // SNR has not changed, so skip the search and use the last // mode selected @@ -298,7 +300,8 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) selectedNss = station->m_nss; NS_LOG_DEBUG ("Using cached mode = " << maxMode.GetUniqueName () << " last snr observed " << station->m_lastSnrObserved << - " cached " << station->m_lastSnrCached); + " cached " << station->m_lastSnrCached << + " nss " << (uint16_t) selectedNss); } else { @@ -326,7 +329,8 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) // Derive NSS from the MCS index. There is a different mode for each possible NSS value. uint8_t nss = (mode.GetMcsValue () / 8) + 1; txVector.SetNss (nss); - if (WifiPhy::IsValidTxVector (txVector) == false) + if (WifiPhy::IsValidTxVector (txVector) == false || + nss > GetNumberOfSupportedStreams (st)) { NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () << " nss " << (uint16_t) nss << " width " << @@ -334,18 +338,20 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) continue; } double threshold = GetSnrThreshold (txVector); - NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () << - " threshold " << threshold << " maxThreshold " << - maxThreshold << " last snr observed " << + uint64_t dataRate = mode.GetDataRate (txVector.GetChannelWidth (), txVector.GetGuardInterval (), nss); + NS_LOG_DEBUG ("Testing mode " << mode.GetUniqueName () << + " data rate " << dataRate << + " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved << " cached " << station->m_lastSnrCached); - if (threshold > maxThreshold && threshold < station->m_lastSnrObserved) + if (dataRate > bestRate && threshold < station->m_lastSnrObserved) { NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () << + " data rate " << dataRate << " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved); - maxThreshold = threshold; + bestRate = dataRate; maxMode = mode; selectedNss = nss; } @@ -364,14 +370,8 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) { continue; } - uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); - for (uint8_t nss = 1; nss <= maxNss; nss++) + for (uint8_t nss = 1; nss <= GetNumberOfSupportedStreams (station); nss++) { - // If the peer does not support more streams, stop searching. - if (GetNumberOfSupportedStreams (station) < nss) - { - break; - } txVector.SetNss (nss); if (WifiPhy::IsValidTxVector (txVector) == false) { @@ -381,18 +381,20 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) continue; } double threshold = GetSnrThreshold (txVector); + uint64_t dataRate = mode.GetDataRate (txVector.GetChannelWidth (), txVector.GetGuardInterval (), nss); NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () << - " threshold " << threshold << " maxThreshold " << - maxThreshold << " last snr observed " << + " data rate " << dataRate << + " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved << " cached " << station->m_lastSnrCached); - if (threshold > maxThreshold && threshold < station->m_lastSnrObserved) + if (dataRate > bestRate && threshold < station->m_lastSnrObserved) { NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () << + " data rate " << dataRate << " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved); - maxThreshold = threshold; + bestRate = dataRate; maxMode = mode; selectedNss = nss; } @@ -407,14 +409,8 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) { continue; } - uint8_t maxNss = GetPhy ()->GetMaxSupportedTxSpatialStreams (); - for (uint8_t nss = 1; nss <= maxNss; nss++) + for (uint8_t nss = 1; nss <= GetNumberOfSupportedStreams (station); nss++) { - // If the peer does not support more streams, stop searching. - if (GetNumberOfSupportedStreams (station) < nss) - { - break; - } txVector.SetNss (nss); if (WifiPhy::IsValidTxVector (txVector) == false) { @@ -424,18 +420,20 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) continue; } double threshold = GetSnrThreshold (txVector); + uint64_t dataRate = mode.GetDataRate (txVector.GetChannelWidth (), txVector.GetGuardInterval (), nss); NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () << - " threshold " << threshold << " maxThreshold " << - maxThreshold << " last snr observed " << + " data rate " << dataRate << + " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved << " cached " << station->m_lastSnrCached); - if (threshold > maxThreshold && threshold < station->m_lastSnrObserved) + if (dataRate > bestRate && threshold < station->m_lastSnrObserved) { NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () << + " data rate " << dataRate << " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved); - maxThreshold = threshold; + bestRate = dataRate; maxMode = mode; selectedNss = nss; } @@ -454,17 +452,19 @@ IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st) txVector.SetNss (selectedNss); txVector.SetChannelWidth (GetChannelWidthForMode (mode)); double threshold = GetSnrThreshold (txVector); + uint64_t dataRate = mode.GetDataRate (txVector.GetChannelWidth (), txVector.GetGuardInterval (), txVector.GetNss ()); NS_LOG_DEBUG ("mode = " << mode.GetUniqueName () << " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved); - if (threshold > maxThreshold && threshold < station->m_lastSnrObserved) + if (dataRate > bestRate && threshold < station->m_lastSnrObserved) { NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () << + " data rate " << dataRate << " threshold " << threshold << " last snr observed " << station->m_lastSnrObserved); - maxThreshold = threshold; + bestRate = dataRate; maxMode = mode; } } From 0cfaf415f400ae483354709cb82765b9a44ac081 Mon Sep 17 00:00:00 2001 From: Ankit Deepak Date: Thu, 6 Jul 2017 11:49:29 -0700 Subject: [PATCH 140/551] bindings: Replace gccxml usage with castxml --- .../ns3modulegen_core_customizations.py | 2 +- bindings/python/ns3modulescan-modular.py | 24 +++++---- bindings/python/ns3modulescan.py | 4 +- bindings/python/wscript | 52 ++++++++++--------- 4 files changed, 46 insertions(+), 36 deletions(-) diff --git a/bindings/python/ns3modulegen_core_customizations.py b/bindings/python/ns3modulegen_core_customizations.py index fa79960f25b..aaf425d166a 100644 --- a/bindings/python/ns3modulegen_core_customizations.py +++ b/bindings/python/ns3modulegen_core_customizations.py @@ -71,7 +71,7 @@ def create_type_handler(self, type_handler, *args, **kwargs): args = tuple([correct_ctype] + list(args[1:])) handler = type_handler(*args, **kwargs) - handler.set_tranformation(self, orig_ctype) + handler.set_transformation(self, orig_ctype) return handler def untransform(self, type_handler, declarations, code_block, expression): diff --git a/bindings/python/ns3modulescan-modular.py b/bindings/python/ns3modulescan-modular.py index ab1bb9cf76a..de478533801 100644 --- a/bindings/python/ns3modulescan-modular.py +++ b/bindings/python/ns3modulescan-modular.py @@ -4,20 +4,21 @@ import os.path import pybindgen.settings -from pybindgen.gccxmlparser import ModuleParser, PygenClassifier, PygenSection, WrapperWarning, find_declaration_from_name +from pybindgen.castxmlparser import ModuleParser, PygenClassifier, PygenSection, WrapperWarning, find_declaration_from_name from pybindgen.typehandlers.codesink import FileCodeSink from pygccxml.declarations import templates from pygccxml.declarations.enumeration import enumeration_t from pygccxml.declarations.class_declaration import class_t -from pygccxml.declarations.calldef import free_function_t, member_function_t, constructor_t, calldef_t - +from pygccxml.declarations.free_calldef import free_function_t +from pygccxml.declarations.calldef_members import constructor_t, member_function_t +from pygccxml.declarations.calldef import calldef_t ## we need the smart pointer type transformation to be active even -## during gccxml scanning. +## during castxml scanning. import ns3modulegen_core_customizations -## silence gccxmlparser errors; we only want error handling in the +## silence castxmlparser errors; we only want error handling in the ## generated python script, not while scanning. class ErrorHandler(pybindgen.settings.ErrorHandler): def handle_error(self, dummy_wrapper, dummy_exception, dummy_traceback_): @@ -34,6 +35,8 @@ def handle_error(self, dummy_wrapper, dummy_exception, dummy_traceback_): def get_ns3_relative_path(path): l = [] head = path + if not path: + return while head: new_head, tail = os.path.split(head) if new_head == head: @@ -58,7 +61,8 @@ def __call__(self, module_parser, ns3_header = get_ns3_relative_path(pygccxml_definition.location.file_name) except ValueError: # the header is not from ns3 return # ignore the definition, it's not ns-3 def. - + if not ns3_header: + return definition_module = self.headers_map[ns3_header] ## Note: we don't include line numbers in the comments because @@ -78,7 +82,7 @@ def __call__(self, module_parser, if isinstance(pygccxml_definition, member_function_t) \ and pygccxml_definition.parent.name == 'Object' \ and pygccxml_definition.name == 'GetObject': - template_args = templates.args(pygccxml_definition.demangled_name) + template_args = templates.args(str(pygccxml_definition)) if template_args == ['ns3::Object']: global_annotations['template_instance_names'] = 'ns3::Object=>GetObject' @@ -227,13 +231,13 @@ def ns3_module_scan(top_builddir, module_name, headers_map, output_file_name, cf module_parser.add_pre_scan_hook(PreScanHook(headers_map, module_name)) #module_parser.add_post_scan_hook(post_scan_hook) - gccxml_options = dict( + castxml_options = dict( include_paths=[top_builddir], define_symbols={ #'NS3_ASSERT_ENABLE': None, #'NS3_LOG_ENABLE': None, }, - cflags=('--gccxml-cxxflags "%s -DPYTHON_SCAN"' % cflags) + cflags=('-std=c++14 %s' % cflags) ) try: @@ -257,7 +261,7 @@ def ns3_module_scan(top_builddir, module_name, headers_map, output_file_name, cf None, whitelist_paths=[top_builddir], #includes=['"ns3/everything.h"'], pygen_sink=output_sink, - gccxml_options=gccxml_options) + castxml_options=castxml_options) module_parser.scan_types() callback_classes_file = open(os.path.join(os.path.dirname(output_file_name), "callbacks_list.py"), "wt") diff --git a/bindings/python/ns3modulescan.py b/bindings/python/ns3modulescan.py index 36436d39911..31626773409 100644 --- a/bindings/python/ns3modulescan.py +++ b/bindings/python/ns3modulescan.py @@ -8,7 +8,9 @@ from pybindgen.typehandlers.codesink import FileCodeSink from pygccxml.declarations import templates from pygccxml.declarations.class_declaration import class_t -from pygccxml.declarations.calldef import free_function_t, member_function_t, constructor_t, calldef_t +from pygccxml.declarations.free_calldef import free_function_t +from pygccxml.declarations.calldef_members import constructor_t, member_function_t +from pygccxml.declarations.calldef import calldef_t ## we need the smart pointer type transformation to be active even diff --git a/bindings/python/wscript b/bindings/python/wscript index a10bee87c94..fa9c0f59247 100644 --- a/bindings/python/wscript +++ b/bindings/python/wscript @@ -15,7 +15,8 @@ from waflib.Errors import WafError # https://github.com/gjcarneiro/pybindgen REQUIRED_PYBINDGEN_VERSION = '0.17.0.post58+ngcf00cc0' -REQUIRED_PYGCCXML_VERSION = (0, 9, 5) +REQUIRED_PYGCCXML_VERSION = (1, 9, 0) +REQUIRED_CASTXML_VERSION = '0.1' RUN_ME=-3 @@ -268,7 +269,7 @@ int main () try: conf.check_python_module('pygccxml') except Errors.ConfigurationError: - conf.report_optional_feature("pygccxml", "Python API Scanning Support", False, + conf.report_optional_feature("castxml", "Python API Scanning Support", False, "Missing 'pygccxml' Python module") return @@ -285,40 +286,43 @@ int main () "automatic scanning of API definitions will not be possible" % (pygccxml_version_str, '.'.join([str(x) for x in REQUIRED_PYGCCXML_VERSION]))) - conf.report_optional_feature("pygccxml", "Python API Scanning Support", False, - "pygccxml too old") + conf.report_optional_feature("castxml", "Python API Scanning Support", False, + "pygccxml Python module too old") return - ## Check gccxml version + ## Check castxml version try: - gccxml = conf.find_program('gccxml', var='GCCXML') + castxml = conf.find_program('castxml', var='CASTXML') except WafError: - gccxml = None - if not gccxml: - Logs.warn("gccxml missing; automatic scanning of API definitions will not be possible") - conf.report_optional_feature("pygccxml", "Python API Scanning Support", False, - "gccxml missing") + castxml = None + if not castxml: + Logs.warn("castxml missing; automatic scanning of API definitions will not be possible") + conf.report_optional_feature("castxml", "Python API Scanning Support", False, + "castxml missing") return - gccxml_version_line = os.popen(gccxml[0] + " --version").readline().strip() - m = re.match( "^GCC-XML version (\d\.\d(\.\d)?)$", gccxml_version_line) + out = subprocess.Popen([castxml[0], '--version'], + stdout=subprocess.PIPE).communicate()[0] + castxml_version_line = maybe_decode(out).split('\n', 1)[0].strip() + ## Expecting version string such as 'castxml version 0.1-gfab9c47' + m = re.match( "^castxml version (\d\.\d)(-)?(\w+)?", castxml_version_line) try: - gccxml_version = m.group(1) - gccxml_version_ok = ([int(s) for s in gccxml_version.split('.')] >= [0, 9]) + castxml_version = m.group(1) + castxml_version_ok = castxml_version >= REQUIRED_CASTXML_VERSION except AttributeError: - gccxml_version = gccxml_version_line - gccxml_version_ok = False - conf.msg('Checking for gccxml version', gccxml_version) - if not gccxml_version_ok: - Logs.warn("gccxml version unknown or too old, need version >= 0.9; automatic scanning of API definitions will not be possible") - conf.report_optional_feature("pygccxml", "Python API Scanning Support", False, - "gccxml too old") + castxml_version = castxml_version_line + castxml_version_ok = False + conf.msg('Checking for castxml version', castxml_version) + if not castxml_version_ok: + Logs.warn("castxml version unknown or too old, need version >= %s; automatic scanning of API definitions will not be possible" % REQUIRED_CASTXML_VERSION) + conf.report_optional_feature("castxml", "Python API Scanning Support", False, + "castxml too old") return ## If we reached conf.env['ENABLE_PYTHON_SCANNING'] = True - conf.report_optional_feature("pygccxml", "Python API Scanning Support", True, None) + conf.report_optional_feature("castxml", "Python API Scanning Support", True, None) # --------------------- @@ -342,7 +346,7 @@ def get_module_path(bld, module): return ns3headers.path.abspath() class apiscan_task(Task.Task): - """Uses gccxml to scan the file 'everything.h' and extract API definitions. + """Uses castxml to scan the file 'everything.h' and extract API definitions. """ after = 'gen_ns3_module_header ns3header' before = 'cxx command' From 17a6187d020bd984498b386669e04a455e636ba7 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 6 Jul 2017 13:06:04 -0700 Subject: [PATCH 141/551] rescan core and network bindings (64-bit only) --- src/core/bindings/modulegen__gcc_LP64.py | 106 +++--- src/network/bindings/modulegen__gcc_LP64.py | 402 ++++++++++---------- 2 files changed, 254 insertions(+), 254 deletions(-) diff --git a/src/core/bindings/modulegen__gcc_LP64.py b/src/core/bindings/modulegen__gcc_LP64.py index 392d4690fed..b0028196263 100644 --- a/src/core/bindings/modulegen__gcc_LP64.py +++ b/src/core/bindings/modulegen__gcc_LP64.py @@ -1249,7 +1249,7 @@ def register_Ns3RandomVariableStreamHelper_methods(root_module, cls): ## random-variable-stream-helper.h (module 'core'): static int64_t ns3::RandomVariableStreamHelper::AssignStreams(std::string path, int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('std::string', 'path'), param('long int', 'stream')], + [param('std::string', 'path'), param('int64_t', 'stream')], is_static=True) return @@ -1276,12 +1276,12 @@ def register_Ns3RngSeedManager_methods(root_module, cls): ## rng-seed-manager.h (module 'core'): static void ns3::RngSeedManager::SetRun(uint64_t run) [member function] cls.add_method('SetRun', 'void', - [param('long unsigned int', 'run')], + [param('uint64_t', 'run')], is_static=True) ## rng-seed-manager.h (module 'core'): static void ns3::RngSeedManager::SetSeed(uint32_t seed) [member function] cls.add_method('SetSeed', 'void', - [param('unsigned int', 'seed')], + [param('uint32_t', 'seed')], is_static=True) return @@ -1422,7 +1422,7 @@ def register_Ns3SystemCondition_methods(root_module, cls): ## system-condition.h (module 'core'): bool ns3::SystemCondition::TimedWait(uint64_t ns) [member function] cls.add_method('TimedWait', 'bool', - [param('long unsigned int', 'ns')]) + [param('uint64_t', 'ns')]) ## system-condition.h (module 'core'): void ns3::SystemCondition::Wait() [member function] cls.add_method('Wait', 'void', @@ -1584,7 +1584,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('unsigned int', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', @@ -1596,12 +1596,12 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] cls.add_method('GetAttributeFullName', 'std::string', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function] cls.add_method('GetAttributeN', @@ -1636,7 +1636,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] cls.add_method('GetRegistered', 'ns3::TypeId', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_static=True) ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function] cls.add_method('GetRegisteredN', @@ -1651,7 +1651,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function] cls.add_method('GetTraceSource', 'ns3::TypeId::TraceSourceInformation', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function] cls.add_method('GetTraceSourceN', @@ -1720,7 +1720,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', - [param('unsigned int', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) + [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] cls.add_method('SetGroupName', 'ns3::TypeId', @@ -1732,11 +1732,11 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', - [param('long unsigned int', 'size')]) + [param('std::size_t', 'size')]) ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t uid) [member function] cls.add_method('SetUid', 'void', - [param('short unsigned int', 'uid')]) + [param('uint16_t', 'uid')]) return def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): @@ -1925,7 +1925,7 @@ def register_Ns3DesMetrics_methods(root_module, cls): ## des-metrics.h (module 'core'): void ns3::DesMetrics::TraceWithContext(uint32_t context, ns3::Time const & now, ns3::Time const & delay) [member function] cls.add_method('TraceWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::Time const &', 'now'), param('ns3::Time const &', 'delay')]) + [param('uint32_t', 'context'), param('ns3::Time const &', 'now'), param('ns3::Time const &', 'delay')]) ## des-metrics.h (module 'core'): ns3::DesMetrics::DesMetrics() [constructor] cls.add_constructor([]) return @@ -2017,7 +2017,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::RandomVariableStream::SetStream(int64_t stream) [member function] cls.add_method('SetStream', 'void', - [param('long int', 'stream')]) + [param('int64_t', 'stream')]) ## random-variable-stream.h (module 'core'): int64_t ns3::RandomVariableStream::GetStream() const [member function] cls.add_method('GetStream', 'int64_t', @@ -2357,7 +2357,7 @@ def register_Ns3SimulatorImpl_methods(root_module, cls): ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_pure_virtual=True, is_virtual=True) ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function] cls.add_method('SetScheduler', @@ -2396,7 +2396,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): int64_t ns3::Synchronizer::GetDrift(uint64_t ts) [member function] cls.add_method('GetDrift', 'int64_t', - [param('long unsigned int', 'ts')]) + [param('uint64_t', 'ts')]) ## synchronizer.h (module 'core'): uint64_t ns3::Synchronizer::GetOrigin() [member function] cls.add_method('GetOrigin', 'uint64_t', @@ -2417,7 +2417,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): void ns3::Synchronizer::SetOrigin(uint64_t ts) [member function] cls.add_method('SetOrigin', 'void', - [param('long unsigned int', 'ts')]) + [param('uint64_t', 'ts')]) ## synchronizer.h (module 'core'): void ns3::Synchronizer::Signal() [member function] cls.add_method('Signal', 'void', @@ -2425,7 +2425,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): bool ns3::Synchronizer::Synchronize(uint64_t tsCurrent, uint64_t tsDelay) [member function] cls.add_method('Synchronize', 'bool', - [param('long unsigned int', 'tsCurrent'), param('long unsigned int', 'tsDelay')]) + [param('uint64_t', 'tsCurrent'), param('uint64_t', 'tsDelay')]) ## synchronizer.h (module 'core'): uint64_t ns3::Synchronizer::DoEventEnd() [member function] cls.add_method('DoEventEnd', 'uint64_t', @@ -2444,7 +2444,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): int64_t ns3::Synchronizer::DoGetDrift(uint64_t ns) [member function] cls.add_method('DoGetDrift', 'int64_t', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], is_pure_virtual=True, visibility='protected', is_virtual=True) ## synchronizer.h (module 'core'): bool ns3::Synchronizer::DoRealtime() [member function] cls.add_method('DoRealtime', @@ -2459,7 +2459,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): void ns3::Synchronizer::DoSetOrigin(uint64_t ns) [member function] cls.add_method('DoSetOrigin', 'void', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], is_pure_virtual=True, visibility='protected', is_virtual=True) ## synchronizer.h (module 'core'): void ns3::Synchronizer::DoSignal() [member function] cls.add_method('DoSignal', @@ -2469,7 +2469,7 @@ def register_Ns3Synchronizer_methods(root_module, cls): ## synchronizer.h (module 'core'): bool ns3::Synchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function] cls.add_method('DoSynchronize', 'bool', - [param('long unsigned int', 'nsCurrent'), param('long unsigned int', 'nsDelay')], + [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], is_pure_virtual=True, visibility='protected', is_virtual=True) return @@ -2562,7 +2562,7 @@ def register_Ns3Time_methods(root_module, cls): ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit unit) [member function] cls.add_method('FromInteger', 'ns3::Time', - [param('long unsigned int', 'value'), param('ns3::Time::Unit', 'unit')], + [param('uint64_t', 'value'), param('ns3::Time::Unit', 'unit')], is_static=True) ## nstime.h (module 'core'): double ns3::Time::GetDays() const [member function] cls.add_method('GetDays', @@ -2753,7 +2753,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::TriangularRandomVariable::GetInteger(uint32_t mean, uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'min'), param('unsigned int', 'max')]) + [param('uint32_t', 'mean'), param('uint32_t', 'min'), param('uint32_t', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::TriangularRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2791,7 +2791,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::UniformRandomVariable::GetInteger(uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'min'), param('unsigned int', 'max')]) + [param('uint32_t', 'min'), param('uint32_t', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::UniformRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2838,7 +2838,7 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): int64_t ns3::WallClockSynchronizer::DoGetDrift(uint64_t ns) [member function] cls.add_method('DoGetDrift', 'int64_t', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::DoRealtime() [member function] cls.add_method('DoRealtime', @@ -2853,7 +2853,7 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::DoSetOrigin(uint64_t ns) [member function] cls.add_method('DoSetOrigin', 'void', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::DoSignal() [member function] cls.add_method('DoSignal', @@ -2863,12 +2863,12 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::DoSynchronize(uint64_t nsCurrent, uint64_t nsDelay) [member function] cls.add_method('DoSynchronize', 'bool', - [param('long unsigned int', 'nsCurrent'), param('long unsigned int', 'nsDelay')], + [param('uint64_t', 'nsCurrent'), param('uint64_t', 'nsDelay')], visibility='protected', is_virtual=True) ## wall-clock-synchronizer.h (module 'core'): uint64_t ns3::WallClockSynchronizer::DriftCorrect(uint64_t nsNow, uint64_t nsDelay) [member function] cls.add_method('DriftCorrect', 'uint64_t', - [param('long unsigned int', 'nsNow'), param('long unsigned int', 'nsDelay')], + [param('uint64_t', 'nsNow'), param('uint64_t', 'nsDelay')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): uint64_t ns3::WallClockSynchronizer::GetNormalizedRealtime() [member function] cls.add_method('GetNormalizedRealtime', @@ -2883,17 +2883,17 @@ def register_Ns3WallClockSynchronizer_methods(root_module, cls): ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::NsToTimeval(int64_t ns, timeval * tv) [member function] cls.add_method('NsToTimeval', 'void', - [param('long int', 'ns'), param('timeval *', 'tv')], + [param('int64_t', 'ns'), param('timeval *', 'tv')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::SleepWait(uint64_t ns) [member function] cls.add_method('SleepWait', 'bool', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): bool ns3::WallClockSynchronizer::SpinWait(uint64_t ns) [member function] cls.add_method('SpinWait', 'bool', - [param('long unsigned int', 'ns')], + [param('uint64_t', 'ns')], visibility='protected') ## wall-clock-synchronizer.h (module 'core'): void ns3::WallClockSynchronizer::TimevalAdd(timeval * tv1, timeval * tv2, timeval * result) [member function] cls.add_method('TimevalAdd', @@ -2937,7 +2937,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::WeibullRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) + [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::WeibullRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -2970,7 +2970,7 @@ def register_Ns3ZetaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ZetaRandomVariable::GetInteger(uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'alpha')]) + [param('uint32_t', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZetaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3004,11 +3004,11 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue(uint32_t n, double alpha) [member function] cls.add_method('GetValue', 'double', - [param('unsigned int', 'n'), param('double', 'alpha')]) + [param('uint32_t', 'n'), param('double', 'alpha')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ZipfRandomVariable::GetInteger(uint32_t n, uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'n'), param('unsigned int', 'alpha')]) + [param('uint32_t', 'n'), param('uint32_t', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3231,7 +3231,7 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): cls.add_method('GetCppTypeid', 'std::string', [], - is_static=True, visibility='protected', template_parameters=[u'std::string']) + is_static=True, visibility='protected', template_parameters=[u'std::__cxx11::basic_string', u' std::allocator > ']) ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] cls.add_method('GetCppTypeid', 'std::string', @@ -3297,7 +3297,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ConstantRandomVariable::GetInteger(uint32_t constant) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'constant')]) + [param('uint32_t', 'constant')]) ## random-variable-stream.h (module 'core'): double ns3::ConstantRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3393,7 +3393,7 @@ def register_Ns3DefaultSimulatorImpl_methods(root_module, cls): ## default-simulator-impl.h (module 'core'): void ns3::DefaultSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_virtual=True) ## default-simulator-impl.h (module 'core'): void ns3::DefaultSimulatorImpl::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function] cls.add_method('SetScheduler', @@ -3428,7 +3428,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] cls.add_method('SetValueArray', 'void', - [param('double *', 'values'), param('long unsigned int', 'length')]) + [param('double *', 'values'), param('uint64_t', 'length')]) ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3693,11 +3693,11 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue(uint32_t k, double lambda) [member function] cls.add_method('GetValue', 'double', - [param('unsigned int', 'k'), param('double', 'lambda')]) + [param('uint32_t', 'k'), param('double', 'lambda')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ErlangRandomVariable::GetInteger(uint32_t k, uint32_t lambda) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'k'), param('unsigned int', 'lambda')]) + [param('uint32_t', 'k'), param('uint32_t', 'lambda')]) ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3759,7 +3759,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ExponentialRandomVariable::GetInteger(uint32_t mean, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'bound')]) + [param('uint32_t', 'mean'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ExponentialRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3817,7 +3817,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::GammaRandomVariable::GetInteger(uint32_t alpha, uint32_t beta) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'alpha'), param('unsigned int', 'beta')]) + [param('uint32_t', 'alpha'), param('uint32_t', 'beta')]) ## random-variable-stream.h (module 'core'): double ns3::GammaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -3962,7 +3962,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::LogNormalRandomVariable::GetInteger(uint32_t mu, uint32_t sigma) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mu'), param('unsigned int', 'sigma')]) + [param('uint32_t', 'mu'), param('uint32_t', 'sigma')]) ## random-variable-stream.h (module 'core'): double ns3::LogNormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -4044,7 +4044,7 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::NormalRandomVariable::GetInteger(uint32_t mean, uint32_t variance, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'variance'), param('unsigned int', 'bound')]) + [param('uint32_t', 'mean'), param('uint32_t', 'variance'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::NormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -4125,7 +4125,7 @@ def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerAccessor::DoGet(ns3::ObjectBase const * object, uint32_t i, uint32_t * index) const [member function] cls.add_method('DoGet', 'ns3::Ptr< ns3::Object >', - [param('ns3::ObjectBase const *', 'object'), param('unsigned int', 'i'), param('uint32_t *', 'index')], + [param('ns3::ObjectBase const *', 'object'), param('uint32_t', 'i'), param('uint32_t *', 'index')], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerAccessor::DoGetN(ns3::ObjectBase const * object, uint32_t * n) const [member function] cls.add_method('DoGetN', @@ -4174,7 +4174,7 @@ def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerValue::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Object >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## object-ptr-container.h (module 'core'): uint32_t ns3::ObjectPtrContainerValue::GetN() const [member function] cls.add_method('GetN', @@ -4223,7 +4223,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ParetoRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) + [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -4387,15 +4387,15 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleRealtimeNowWithContext(uint32_t context, ns3::EventImpl * event) [member function] cls.add_method('ScheduleRealtimeNowWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::EventImpl *', 'event')]) + [param('uint32_t', 'context'), param('ns3::EventImpl *', 'event')]) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleRealtimeWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleRealtimeWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')]) + [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')]) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::ScheduleWithContext(uint32_t context, ns3::Time const & delay, ns3::EventImpl * event) [member function] cls.add_method('ScheduleWithContext', 'void', - [param('unsigned int', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], + [param('uint32_t', 'context'), param('ns3::Time const &', 'delay'), param('ns3::EventImpl *', 'event')], is_virtual=True) ## realtime-simulator-impl.h (module 'core'): void ns3::RealtimeSimulatorImpl::SetHardLimit(ns3::Time limit) [member function] cls.add_method('SetHardLimit', @@ -4784,12 +4784,12 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): ## config.h (module 'core'): ns3::Ptr ns3::Config::MatchContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Object >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## config.h (module 'core'): std::string ns3::Config::MatchContainer::GetMatchedPath(uint32_t i) const [member function] cls.add_method('GetMatchedPath', 'std::string', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## config.h (module 'core'): uint32_t ns3::Config::MatchContainer::GetN() const [member function] cls.add_method('GetN', diff --git a/src/network/bindings/modulegen__gcc_LP64.py b/src/network/bindings/modulegen__gcc_LP64.py index 09e2152c211..0461325a53d 100644 --- a/src/network/bindings/modulegen__gcc_LP64.py +++ b/src/network/bindings/modulegen__gcc_LP64.py @@ -987,21 +987,21 @@ def register_Ns3Address_methods(root_module, cls): ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', 'bool', - [param('unsigned char', 'type'), param('unsigned char', 'len')], + [param('uint8_t', 'type'), param('uint8_t', 'len')], is_const=True) ## address.h (module 'network'): uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function] cls.add_method('CopyAllFrom', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('unsigned char', 'len')]) + [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) ## address.h (module 'network'): uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function] cls.add_method('CopyAllTo', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned char', 'len')], + [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], is_const=True) ## address.h (module 'network'): uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function] cls.add_method('CopyFrom', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('unsigned char', 'len')]) + [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) ## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function] cls.add_method('CopyTo', 'uint32_t', @@ -1029,7 +1029,7 @@ def register_Ns3Address_methods(root_module, cls): ## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function] cls.add_method('IsMatchingType', 'bool', - [param('unsigned char', 'type')], + [param('uint8_t', 'type')], is_const=True) ## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function] cls.add_method('Register', @@ -1077,7 +1077,7 @@ def register_Ns3ApplicationContainer_methods(root_module, cls): ## application-container.h (module 'network'): ns3::Ptr ns3::ApplicationContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Application >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## application-container.h (module 'network'): uint32_t ns3::ApplicationContainer::GetN() const [member function] cls.add_method('GetN', @@ -1110,7 +1110,7 @@ def register_Ns3AsciiFile_methods(root_module, cls): ## ascii-file.h (module 'network'): void ns3::AsciiFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', - [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) + [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode', default_value='std::ios_base::out')]) ## ascii-file.h (module 'network'): void ns3::AsciiFile::Close() [member function] cls.add_method('Close', 'void', @@ -1182,7 +1182,7 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls): ## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr object, uint32_t interface, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromInterfacePair', 'std::string', - [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('unsigned int', 'interface'), param('bool', 'useObjectNames', default_value='true')]) + [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')]) return def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): @@ -1225,11 +1225,11 @@ def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool explicitFilename) [member function] cls.add_method('EnableAscii', 'void', - [param('std::string', 'prefix'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid'), param('bool', 'explicitFilename')]) + [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'explicitFilename')]) ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr stream, uint32_t nodeid, uint32_t deviceid) [member function] cls.add_method('EnableAscii', 'void', - [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid')]) + [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid')]) ## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(std::string prefix) [member function] cls.add_method('EnableAsciiAll', 'void', @@ -1296,7 +1296,7 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', - [param('unsigned int', 'end')]) + [param('uint32_t', 'end')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(ns3::Buffer const & o) [member function] cls.add_method('AddAtEnd', 'void', @@ -1304,7 +1304,7 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::AddAtStart(uint32_t start) [member function] cls.add_method('AddAtStart', 'void', - [param('unsigned int', 'start')]) + [param('uint32_t', 'start')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::Begin() const [member function] cls.add_method('Begin', 'ns3::Buffer::Iterator', @@ -1313,22 +1313,22 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::CopyData(std::ostream * os, uint32_t size) const [member function] cls.add_method('CopyData', 'void', - [param('std::ostream *', 'os'), param('unsigned int', 'size')], + [param('std::ostream *', 'os'), param('uint32_t', 'size')], is_const=True) ## buffer.h (module 'network'): uint32_t ns3::Buffer::CopyData(uint8_t * buffer, uint32_t size) const [member function] cls.add_method('CopyData', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned int', 'size')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], is_const=True) ## buffer.h (module 'network'): ns3::Buffer ns3::Buffer::CreateFragment(uint32_t start, uint32_t length) const [member function] cls.add_method('CreateFragment', 'ns3::Buffer', - [param('unsigned int', 'start'), param('unsigned int', 'length')], + [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Deserialize(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator ns3::Buffer::End() const [member function] cls.add_method('End', 'ns3::Buffer::Iterator', @@ -1352,15 +1352,15 @@ def register_Ns3Buffer_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtEnd(uint32_t end) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('unsigned int', 'end')]) + [param('uint32_t', 'end')]) ## buffer.h (module 'network'): void ns3::Buffer::RemoveAtStart(uint32_t start) [member function] cls.add_method('RemoveAtStart', 'void', - [param('unsigned int', 'start')]) + [param('uint32_t', 'start')]) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], is_const=True) return @@ -1372,11 +1372,11 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size) [member function] cls.add_method('CalculateIpChecksum', 'uint16_t', - [param('short unsigned int', 'size')]) + [param('uint16_t', 'size')]) ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::CalculateIpChecksum(uint16_t size, uint32_t initialChecksum) [member function] cls.add_method('CalculateIpChecksum', 'uint16_t', - [param('short unsigned int', 'size'), param('unsigned int', 'initialChecksum')]) + [param('uint16_t', 'size'), param('uint32_t', 'initialChecksum')]) ## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function] cls.add_method('GetDistanceFrom', 'uint32_t', @@ -1409,7 +1409,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function] cls.add_method('Next', 'void', - [param('unsigned int', 'delta')]) + [param('uint32_t', 'delta')]) ## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::PeekU8() [member function] cls.add_method('PeekU8', 'uint8_t', @@ -1421,15 +1421,15 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function] cls.add_method('Prev', 'void', - [param('unsigned int', 'delta')]) + [param('uint32_t', 'delta')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(uint8_t * buffer, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('uint8_t *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Read(ns3::Buffer::Iterator start, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('ns3::Buffer::Iterator', 'start'), param('unsigned int', 'size')]) + [param('ns3::Buffer::Iterator', 'start'), param('uint32_t', 'size')]) ## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function] cls.add_method('ReadLsbtohU16', 'uint16_t', @@ -1473,7 +1473,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Write', 'void', - [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function] cls.add_method('Write', 'void', @@ -1481,47 +1481,47 @@ def register_Ns3BufferIterator_methods(root_module, cls): ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function] cls.add_method('WriteHtolsbU16', 'void', - [param('short unsigned int', 'data')]) + [param('uint16_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function] cls.add_method('WriteHtolsbU32', 'void', - [param('unsigned int', 'data')]) + [param('uint32_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function] cls.add_method('WriteHtolsbU64', 'void', - [param('long unsigned int', 'data')]) + [param('uint64_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function] cls.add_method('WriteHtonU16', 'void', - [param('short unsigned int', 'data')]) + [param('uint16_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function] cls.add_method('WriteHtonU32', 'void', - [param('unsigned int', 'data')]) + [param('uint32_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function] cls.add_method('WriteHtonU64', 'void', - [param('long unsigned int', 'data')]) + [param('uint64_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function] cls.add_method('WriteU16', 'void', - [param('short unsigned int', 'data')]) + [param('uint16_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function] cls.add_method('WriteU32', 'void', - [param('unsigned int', 'data')]) + [param('uint32_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function] cls.add_method('WriteU64', 'void', - [param('long unsigned int', 'data')]) + [param('uint64_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function] cls.add_method('WriteU8', 'void', - [param('unsigned char', 'data')]) + [param('uint8_t', 'data')]) ## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data, uint32_t len) [member function] cls.add_method('WriteU8', 'void', - [param('unsigned char', 'data'), param('unsigned int', 'len')]) + [param('uint8_t', 'data'), param('uint32_t', 'len')]) return def register_Ns3ByteTagIterator_methods(root_module, cls): @@ -1571,7 +1571,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', 'ns3::TagBuffer', - [param('ns3::TypeId', 'tid'), param('unsigned int', 'bufferSize'), param('int', 'start'), param('int', 'end')]) + [param('ns3::TypeId', 'tid'), param('uint32_t', 'bufferSize'), param('int32_t', 'start'), param('int32_t', 'end')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function] cls.add_method('Add', 'void', @@ -1579,19 +1579,19 @@ def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t appendOffset) [member function] cls.add_method('AddAtEnd', 'void', - [param('int', 'appendOffset')]) + [param('int32_t', 'appendOffset')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t prependOffset) [member function] cls.add_method('AddAtStart', 'void', - [param('int', 'prependOffset')]) + [param('int32_t', 'prependOffset')]) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Adjust(int32_t adjustment) [member function] cls.add_method('Adjust', 'void', - [param('int', 'adjustment')]) + [param('int32_t', 'adjustment')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator ns3::ByteTagList::Begin(int32_t offsetStart, int32_t offsetEnd) const [member function] cls.add_method('Begin', 'ns3::ByteTagList::Iterator', - [param('int', 'offsetStart'), param('int', 'offsetEnd')], + [param('int32_t', 'offsetStart'), param('int32_t', 'offsetEnd')], is_const=True) ## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function] cls.add_method('RemoveAll', @@ -1673,7 +1673,7 @@ def register_Ns3ChannelList_methods(root_module, cls): ## channel-list.h (module 'network'): static ns3::Ptr ns3::ChannelList::GetChannel(uint32_t n) [member function] cls.add_method('GetChannel', 'ns3::Ptr< ns3::Channel >', - [param('unsigned int', 'n')], + [param('uint32_t', 'n')], is_static=True) ## channel-list.h (module 'network'): static uint32_t ns3::ChannelList::GetNChannels() [member function] cls.add_method('GetNChannels', @@ -1695,7 +1695,7 @@ def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, uint32_t val) [member function] cls.add_method('OutputSingleton', 'void', - [param('std::string', 'key'), param('std::string', 'variable'), param('unsigned int', 'val')], + [param('std::string', 'key'), param('std::string', 'variable'), param('uint32_t', 'val')], is_pure_virtual=True, is_virtual=True) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, double val) [member function] cls.add_method('OutputSingleton', @@ -1738,17 +1738,17 @@ def register_Ns3DataRate_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::Time ns3::DataRate::CalculateBitsTxTime(uint32_t bits) const [member function] cls.add_method('CalculateBitsTxTime', 'ns3::Time', - [param('unsigned int', 'bits')], + [param('uint32_t', 'bits')], is_const=True) ## data-rate.h (module 'network'): ns3::Time ns3::DataRate::CalculateBytesTxTime(uint32_t bytes) const [member function] cls.add_method('CalculateBytesTxTime', 'ns3::Time', - [param('unsigned int', 'bytes')], + [param('uint32_t', 'bytes')], is_const=True) ## data-rate.h (module 'network'): double ns3::DataRate::CalculateTxTime(uint32_t bytes) const [member function] cls.add_method('CalculateTxTime', 'double', - [param('unsigned int', 'bytes')], + [param('uint32_t', 'bytes')], is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', @@ -2077,7 +2077,7 @@ def register_Ns3Inet6SocketAddress_methods(root_module, cls): ## inet6-socket-address.h (module 'network'): void ns3::Inet6SocketAddress::SetPort(uint16_t port) [member function] cls.add_method('SetPort', 'void', - [param('short unsigned int', 'port')]) + [param('uint16_t', 'port')]) return def register_Ns3InetSocketAddress_methods(root_module, cls): @@ -2125,11 +2125,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls): ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetPort(uint16_t port) [member function] cls.add_method('SetPort', 'void', - [param('short unsigned int', 'port')]) + [param('uint16_t', 'port')]) ## inet-socket-address.h (module 'network'): void ns3::InetSocketAddress::SetTos(uint8_t tos) [member function] cls.add_method('SetTos', 'void', - [param('unsigned char', 'tos')]) + [param('uint8_t', 'tos')]) return def register_Ns3Ipv4Address_methods(root_module, cls): @@ -2243,7 +2243,7 @@ def register_Ns3Ipv4Address_methods(root_module, cls): ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function] cls.add_method('Set', 'void', - [param('unsigned int', 'address')]) + [param('uint32_t', 'address')]) ## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function] cls.add_method('Set', 'void', @@ -2310,7 +2310,7 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): ## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function] cls.add_method('Set', 'void', - [param('unsigned int', 'mask')]) + [param('uint32_t', 'mask')]) return def register_Ns3Ipv6Address_methods(root_module, cls): @@ -2801,7 +2801,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::NetDevice >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## net-device-container.h (module 'network'): uint32_t ns3::NetDeviceContainer::GetN() const [member function] cls.add_method('GetN', @@ -2847,11 +2847,11 @@ def register_Ns3NodeContainer_methods(root_module, cls): ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] cls.add_method('Create', 'void', - [param('unsigned int', 'n')]) + [param('uint32_t', 'n')]) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n, uint32_t systemId) [member function] cls.add_method('Create', 'void', - [param('unsigned int', 'n'), param('unsigned int', 'systemId')]) + [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', 'ns3::NodeContainer::Iterator', @@ -2860,7 +2860,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'ns3::Ptr< ns3::Node >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## node-container.h (module 'network'): static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function] cls.add_method('GetGlobal', @@ -2902,7 +2902,7 @@ def register_Ns3NodeList_methods(root_module, cls): ## node-list.h (module 'network'): static ns3::Ptr ns3::NodeList::GetNode(uint32_t n) [member function] cls.add_method('GetNode', 'ns3::Ptr< ns3::Node >', - [param('unsigned int', 'n')], + [param('uint32_t', 'n')], is_static=True) return @@ -3033,15 +3033,15 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddHeader(ns3::Header const & header, uint32_t size) [member function] cls.add_method('AddHeader', 'void', - [param('ns3::Header const &', 'header'), param('unsigned int', 'size')]) + [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function] cls.add_method('AddPaddingAtEnd', 'void', - [param('unsigned int', 'end')]) + [param('uint32_t', 'end')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] cls.add_method('AddTrailer', 'void', - [param('ns3::Trailer const &', 'trailer'), param('unsigned int', 'size')]) + [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::PacketMetadata::BeginItem(ns3::Buffer buffer) const [member function] cls.add_method('BeginItem', 'ns3::PacketMetadata::ItemIterator', @@ -3050,12 +3050,12 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata ns3::PacketMetadata::CreateFragment(uint32_t start, uint32_t end) const [member function] cls.add_method('CreateFragment', 'ns3::PacketMetadata', - [param('unsigned int', 'start'), param('unsigned int', 'end')], + [param('uint32_t', 'start'), param('uint32_t', 'end')], is_const=True) ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Deserialize(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) ## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function] cls.add_method('Enable', 'void', @@ -3079,23 +3079,23 @@ def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('unsigned int', 'end')]) + [param('uint32_t', 'end')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function] cls.add_method('RemoveAtStart', 'void', - [param('unsigned int', 'start')]) + [param('uint32_t', 'start')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveHeader(ns3::Header const & header, uint32_t size) [member function] cls.add_method('RemoveHeader', 'void', - [param('ns3::Header const &', 'header'), param('unsigned int', 'size')]) + [param('ns3::Header const &', 'header'), param('uint32_t', 'size')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveTrailer(ns3::Trailer const & trailer, uint32_t size) [member function] cls.add_method('RemoveTrailer', 'void', - [param('ns3::Trailer const &', 'trailer'), param('unsigned int', 'size')]) + [param('ns3::Trailer const &', 'trailer'), param('uint32_t', 'size')]) ## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], is_const=True) return @@ -3182,11 +3182,11 @@ def register_Ns3PacketSocketAddress_methods(root_module, cls): ## packet-socket-address.h (module 'network'): void ns3::PacketSocketAddress::SetProtocol(uint16_t protocol) [member function] cls.add_method('SetProtocol', 'void', - [param('short unsigned int', 'protocol')]) + [param('uint16_t', 'protocol')]) ## packet-socket-address.h (module 'network'): void ns3::PacketSocketAddress::SetSingleDevice(uint32_t device) [member function] cls.add_method('SetSingleDevice', 'void', - [param('unsigned int', 'device')]) + [param('uint32_t', 'device')]) return def register_Ns3PacketSocketHelper_methods(root_module, cls): @@ -3518,7 +3518,7 @@ def register_Ns3PcapFile_methods(root_module, cls): ## pcap-file.h (module 'network'): static bool ns3::PcapFile::Diff(std::string const & f1, std::string const & f2, uint32_t & sec, uint32_t & usec, uint32_t & packets, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT) [member function] cls.add_method('Diff', 'bool', - [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t &', 'packets'), param('unsigned int', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], + [param('std::string const &', 'f1'), param('std::string const &', 'f2'), param('uint32_t &', 'sec'), param('uint32_t &', 'usec'), param('uint32_t &', 'packets'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT')], is_static=True) ## pcap-file.h (module 'network'): bool ns3::PcapFile::Eof() const [member function] cls.add_method('Eof', @@ -3565,7 +3565,7 @@ def register_Ns3PcapFile_methods(root_module, cls): ## pcap-file.h (module 'network'): void ns3::PcapFile::Init(uint32_t dataLinkType, uint32_t snapLen=ns3::PcapFile::SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ns3::PcapFile::ZONE_DEFAULT, bool swapMode=false, bool nanosecMode=false) [member function] cls.add_method('Init', 'void', - [param('unsigned int', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false'), param('bool', 'nanosecMode', default_value='false')]) + [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='ns3::PcapFile::SNAPLEN_DEFAULT'), param('int32_t', 'timeZoneCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT'), param('bool', 'swapMode', default_value='false'), param('bool', 'nanosecMode', default_value='false')]) ## pcap-file.h (module 'network'): bool ns3::PcapFile::IsNanoSecMode() [member function] cls.add_method('IsNanoSecMode', 'bool', @@ -3577,19 +3577,19 @@ def register_Ns3PcapFile_methods(root_module, cls): ## pcap-file.h (module 'network'): void ns3::PcapFile::Read(uint8_t * const data, uint32_t maxBytes, uint32_t & tsSec, uint32_t & tsUsec, uint32_t & inclLen, uint32_t & origLen, uint32_t & readLen) [member function] cls.add_method('Read', 'void', - [param('uint8_t * const', 'data'), param('unsigned int', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')]) + [param('uint8_t * const', 'data'), param('uint32_t', 'maxBytes'), param('uint32_t &', 'tsSec'), param('uint32_t &', 'tsUsec'), param('uint32_t &', 'inclLen'), param('uint32_t &', 'origLen'), param('uint32_t &', 'readLen')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen) [member function] cls.add_method('Write', 'void', - [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('uint8_t const * const', 'data'), param('unsigned int', 'totalLen')]) + [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] cls.add_method('Write', 'void', - [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) + [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', - [param('unsigned int', 'tsSec'), param('unsigned int', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) + [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) ## pcap-file.h (module 'network'): ns3::PcapFile::SNAPLEN_DEFAULT [variable] cls.add_static_attribute('SNAPLEN_DEFAULT', 'uint32_t const', is_const=True) ## pcap-file.h (module 'network'): ns3::PcapFile::ZONE_DEFAULT [variable] @@ -3604,7 +3604,7 @@ def register_Ns3PcapHelper_methods(root_module, cls): ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::ios_base::openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] cls.add_method('CreateFile', 'ns3::Ptr< ns3::PcapFileWrapper >', - [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='std::numeric_limits::max()'), param('int', 'tzCorrection', default_value='0')]) + [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='0')]) ## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr device, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromDevice', 'std::string', @@ -3612,7 +3612,7 @@ def register_Ns3PcapHelper_methods(root_module, cls): ## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr object, uint32_t interface, bool useObjectNames=true) [member function] cls.add_method('GetFilenameFromInterfacePair', 'std::string', - [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('unsigned int', 'interface'), param('bool', 'useObjectNames', default_value='true')]) + [param('std::string', 'prefix'), param('ns3::Ptr< ns3::Object >', 'object'), param('uint32_t', 'interface'), param('bool', 'useObjectNames', default_value='true')]) return def register_Ns3PcapHelperForDevice_methods(root_module, cls): @@ -3639,7 +3639,7 @@ def register_Ns3PcapHelperForDevice_methods(root_module, cls): ## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, uint32_t nodeid, uint32_t deviceid, bool promiscuous=false) [member function] cls.add_method('EnablePcap', 'void', - [param('std::string', 'prefix'), param('unsigned int', 'nodeid'), param('unsigned int', 'deviceid'), param('bool', 'promiscuous', default_value='false')]) + [param('std::string', 'prefix'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('bool', 'promiscuous', default_value='false')]) ## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function] cls.add_method('EnablePcapAll', 'void', @@ -3961,7 +3961,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Read(uint8_t * buffer, uint32_t size) [member function] cls.add_method('Read', 'void', - [param('uint8_t *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')]) ## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function] cls.add_method('ReadDouble', 'double', @@ -3985,11 +3985,11 @@ def register_Ns3TagBuffer_methods(root_module, cls): ## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function] cls.add_method('TrimAtEnd', 'void', - [param('unsigned int', 'trim')]) + [param('uint32_t', 'trim')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::Write(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('Write', 'void', - [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteDouble(double v) [member function] cls.add_method('WriteDouble', 'void', @@ -3997,19 +3997,19 @@ def register_Ns3TagBuffer_methods(root_module, cls): ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('short unsigned int', 'v')]) + [param('uint16_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('unsigned int', 'v')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', - [param('long unsigned int', 'v')]) + [param('uint64_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function] cls.add_method('WriteU8', 'void', - [param('unsigned char', 'v')]) + [param('uint8_t', 'v')]) return def register_Ns3TimeWithUnit_methods(root_module, cls): @@ -4076,7 +4076,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('unsigned int', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', @@ -4088,12 +4088,12 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetAttributeFullName(uint32_t i) const [member function] cls.add_method('GetAttributeFullName', 'std::string', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetAttributeN() const [member function] cls.add_method('GetAttributeN', @@ -4128,7 +4128,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::GetRegistered(uint32_t i) [member function] cls.add_method('GetRegistered', 'ns3::TypeId', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_static=True) ## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function] cls.add_method('GetRegisteredN', @@ -4143,7 +4143,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation ns3::TypeId::GetTraceSource(uint32_t i) const [member function] cls.add_method('GetTraceSource', 'ns3::TypeId::TraceSourceInformation', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True) ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function] cls.add_method('GetTraceSourceN', @@ -4212,7 +4212,7 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', - [param('unsigned int', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) + [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetGroupName(std::string groupName) [member function] cls.add_method('SetGroupName', 'ns3::TypeId', @@ -4234,11 +4234,11 @@ def register_Ns3TypeId_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', - [param('long unsigned int', 'size')]) + [param('std::size_t', 'size')]) ## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t uid) [member function] cls.add_method('SetUid', 'void', - [param('short unsigned int', 'uid')]) + [param('uint16_t', 'uid')]) return def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): @@ -4476,7 +4476,7 @@ def register_Ns3FlowIdTag_methods(root_module, cls): ## flow-id-tag.h (module 'network'): void ns3::FlowIdTag::SetFlowId(uint32_t flowId) [member function] cls.add_method('SetFlowId', 'void', - [param('unsigned int', 'flowId')]) + [param('uint32_t', 'flowId')]) return def register_Ns3Header_methods(root_module, cls): @@ -4554,7 +4554,7 @@ def register_Ns3LlcSnapHeader_methods(root_module, cls): ## llc-snap-header.h (module 'network'): void ns3::LlcSnapHeader::SetType(uint16_t type) [member function] cls.add_method('SetType', 'void', - [param('short unsigned int', 'type')]) + [param('uint16_t', 'type')]) return def register_Ns3Object_methods(root_module, cls): @@ -4772,7 +4772,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=ns3::PcapFile::ZONE_DEFAULT) [member function] cls.add_method('Init', 'void', - [param('unsigned int', 'dataLinkType'), param('unsigned int', 'snapLen', default_value='std::numeric_limits::max()'), param('int', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) + [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] cls.add_method('Write', 'void', @@ -4784,7 +4784,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, uint8_t const * buffer, uint32_t length) [member function] cls.add_method('Write', 'void', - [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('unsigned int', 'length')]) + [param('ns3::Time', 't'), param('uint8_t const *', 'buffer'), param('uint32_t', 'length')]) ## pcap-file-wrapper.h (module 'network'): ns3::Ptr ns3::PcapFileWrapper::Read(ns3::Time & t) [member function] cls.add_method('Read', 'ns3::Ptr< ns3::Packet >', @@ -4911,11 +4911,11 @@ def register_Ns3QueueBase_methods(root_module, cls): ## queue.h (module 'network'): void ns3::QueueBase::SetMaxBytes(uint32_t maxBytes) [member function] cls.add_method('SetMaxBytes', 'void', - [param('unsigned int', 'maxBytes')]) + [param('uint32_t', 'maxBytes')]) ## queue.h (module 'network'): void ns3::QueueBase::SetMaxPackets(uint32_t maxPackets) [member function] cls.add_method('SetMaxPackets', 'void', - [param('unsigned int', 'maxPackets')]) + [param('uint32_t', 'maxPackets')]) ## queue.h (module 'network'): void ns3::QueueBase::SetMode(ns3::QueueBase::QueueMode mode) [member function] cls.add_method('SetMode', 'void', @@ -4935,7 +4935,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): void ns3::QueueLimits::Completed(uint32_t count) [member function] cls.add_method('Completed', 'void', - [param('unsigned int', 'count')], + [param('uint32_t', 'count')], is_pure_virtual=True, is_virtual=True) ## queue-limits.h (module 'network'): static ns3::TypeId ns3::QueueLimits::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4945,7 +4945,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): void ns3::QueueLimits::Queued(uint32_t count) [member function] cls.add_method('Queued', 'void', - [param('unsigned int', 'count')], + [param('uint32_t', 'count')], is_pure_virtual=True, is_virtual=True) ## queue-limits.h (module 'network'): void ns3::QueueLimits::Reset() [member function] cls.add_method('Reset', @@ -5102,7 +5102,7 @@ def register_Ns3RadiotapHeader_methods(root_module, cls): ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetAmpduStatus(uint32_t referenceNumber, uint16_t flags, uint8_t crc) [member function] cls.add_method('SetAmpduStatus', 'void', - [param('unsigned int', 'referenceNumber'), param('short unsigned int', 'flags'), param('unsigned char', 'crc')]) + [param('uint32_t', 'referenceNumber'), param('uint16_t', 'flags'), param('uint8_t', 'crc')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetAntennaNoisePower(double noise) [member function] cls.add_method('SetAntennaNoisePower', 'void', @@ -5114,27 +5114,27 @@ def register_Ns3RadiotapHeader_methods(root_module, cls): ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetChannelFrequencyAndFlags(uint16_t frequency, uint16_t flags) [member function] cls.add_method('SetChannelFrequencyAndFlags', 'void', - [param('short unsigned int', 'frequency'), param('short unsigned int', 'flags')]) + [param('uint16_t', 'frequency'), param('uint16_t', 'flags')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetFrameFlags(uint8_t flags) [member function] cls.add_method('SetFrameFlags', 'void', - [param('unsigned char', 'flags')]) + [param('uint8_t', 'flags')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetMcsFields(uint8_t known, uint8_t flags, uint8_t mcs) [member function] cls.add_method('SetMcsFields', 'void', - [param('unsigned char', 'known'), param('unsigned char', 'flags'), param('unsigned char', 'mcs')]) + [param('uint8_t', 'known'), param('uint8_t', 'flags'), param('uint8_t', 'mcs')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetRate(uint8_t rate) [member function] cls.add_method('SetRate', 'void', - [param('unsigned char', 'rate')]) + [param('uint8_t', 'rate')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetTsft(uint64_t tsft) [member function] cls.add_method('SetTsft', 'void', - [param('long unsigned int', 'tsft')]) + [param('uint64_t', 'tsft')]) ## radiotap-header.h (module 'network'): void ns3::RadiotapHeader::SetVhtFields(uint16_t known, uint8_t flags, uint8_t bandwidth, uint8_t * mcs_nss, uint8_t coding, uint8_t group_id, uint16_t partial_aid) [member function] cls.add_method('SetVhtFields', 'void', - [param('short unsigned int', 'known'), param('unsigned char', 'flags'), param('unsigned char', 'bandwidth'), param('uint8_t *', 'mcs_nss'), param('unsigned char', 'coding'), param('unsigned char', 'group_id'), param('short unsigned int', 'partial_aid')]) + [param('uint16_t', 'known'), param('uint8_t', 'flags'), param('uint8_t', 'bandwidth'), param('uint8_t *', 'mcs_nss'), param('uint8_t', 'coding'), param('uint8_t', 'group_id'), param('uint16_t', 'partial_aid')]) return def register_Ns3RandomVariableStream_methods(root_module, cls): @@ -5148,7 +5148,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::RandomVariableStream::SetStream(int64_t stream) [member function] cls.add_method('SetStream', 'void', - [param('long int', 'stream')]) + [param('int64_t', 'stream')]) ## random-variable-stream.h (module 'core'): int64_t ns3::RandomVariableStream::GetStream() const [member function] cls.add_method('GetStream', 'int64_t', @@ -5460,7 +5460,7 @@ def register_Ns3SllHeader_methods(root_module, cls): ## sll-header.h (module 'network'): void ns3::SllHeader::SetArpType(uint16_t arphdType) [member function] cls.add_method('SetArpType', 'void', - [param('short unsigned int', 'arphdType')]) + [param('uint16_t', 'arphdType')]) ## sll-header.h (module 'network'): void ns3::SllHeader::SetPacketType(ns3::SllHeader::PacketType type) [member function] cls.add_method('SetPacketType', 'void', @@ -5584,7 +5584,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): static uint8_t ns3::Socket::IpTos2Priority(uint8_t ipTos) [member function] cls.add_method('IpTos2Priority', 'uint8_t', - [param('unsigned char', 'ipTos')], + [param('uint8_t', 'ipTos')], is_static=True) ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] cls.add_method('Ipv6JoinGroup', @@ -5634,7 +5634,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): ns3::Ptr ns3::Socket::Recv(uint32_t maxSize, uint32_t flags) [member function] cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', - [param('unsigned int', 'maxSize'), param('unsigned int', 'flags')], + [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::Recv() [member function] cls.add_method('Recv', @@ -5643,11 +5643,11 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::Recv(uint8_t * buf, uint32_t size, uint32_t flags) [member function] cls.add_method('Recv', 'int', - [param('uint8_t *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags')]) + [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')]) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', - [param('unsigned int', 'maxSize'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')], + [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): ns3::Ptr ns3::Socket::RecvFrom(ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', @@ -5656,11 +5656,11 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::RecvFrom(uint8_t * buf, uint32_t size, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'int', - [param('uint8_t *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')]) + [param('uint8_t *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')]) ## socket.h (module 'network'): int ns3::Socket::Send(ns3::Ptr p, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): int ns3::Socket::Send(ns3::Ptr p) [member function] cls.add_method('Send', @@ -5669,16 +5669,16 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): int ns3::Socket::Send(uint8_t const * buf, uint32_t size, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('uint8_t const *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags')]) + [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags')]) ## socket.h (module 'network'): int ns3::Socket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] cls.add_method('SendTo', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags'), param('ns3::Address const &', 'toAddress')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')], is_pure_virtual=True, is_virtual=True) ## socket.h (module 'network'): int ns3::Socket::SendTo(uint8_t const * buf, uint32_t size, uint32_t flags, ns3::Address const & address) [member function] cls.add_method('SendTo', 'int', - [param('uint8_t const *', 'buf'), param('unsigned int', 'size'), param('unsigned int', 'flags'), param('ns3::Address const &', 'address')]) + [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')]) ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] cls.add_method('SetAcceptCallback', 'void', @@ -5711,16 +5711,16 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::SetIpTos(uint8_t ipTos) [member function] cls.add_method('SetIpTos', 'void', - [param('unsigned char', 'ipTos')]) + [param('uint8_t', 'ipTos')]) ## socket.h (module 'network'): void ns3::Socket::SetIpTtl(uint8_t ipTtl) [member function] cls.add_method('SetIpTtl', 'void', - [param('unsigned char', 'ipTtl')], + [param('uint8_t', 'ipTtl')], is_virtual=True) ## socket.h (module 'network'): void ns3::Socket::SetIpv6HopLimit(uint8_t ipHopLimit) [member function] cls.add_method('SetIpv6HopLimit', 'void', - [param('unsigned char', 'ipHopLimit')], + [param('uint8_t', 'ipHopLimit')], is_virtual=True) ## socket.h (module 'network'): void ns3::Socket::SetIpv6RecvHopLimit(bool ipv6RecvHopLimit) [member function] cls.add_method('SetIpv6RecvHopLimit', @@ -5737,7 +5737,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::SetPriority(uint8_t priority) [member function] cls.add_method('SetPriority', 'void', - [param('unsigned char', 'priority')]) + [param('uint8_t', 'priority')]) ## socket.h (module 'network'): void ns3::Socket::SetRecvCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> arg0) [member function] cls.add_method('SetRecvCallback', 'void', @@ -5803,7 +5803,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::NotifyDataSent(uint32_t size) [member function] cls.add_method('NotifyDataSent', 'void', - [param('unsigned int', 'size')], + [param('uint32_t', 'size')], visibility='protected') ## socket.h (module 'network'): void ns3::Socket::NotifyErrorClose() [member function] cls.add_method('NotifyErrorClose', @@ -5823,7 +5823,7 @@ def register_Ns3Socket_methods(root_module, cls): ## socket.h (module 'network'): void ns3::Socket::NotifySend(uint32_t spaceAvailable) [member function] cls.add_method('NotifySend', 'void', - [param('unsigned int', 'spaceAvailable')], + [param('uint32_t', 'spaceAvailable')], visibility='protected') return @@ -5887,7 +5887,7 @@ def register_Ns3SocketIpTosTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpTosTag::SetTos(uint8_t tos) [member function] cls.add_method('SetTos', 'void', - [param('unsigned char', 'tos')]) + [param('uint8_t', 'tos')]) return def register_Ns3SocketIpTtlTag_methods(root_module, cls): @@ -5933,7 +5933,7 @@ def register_Ns3SocketIpTtlTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpTtlTag::SetTtl(uint8_t ttl) [member function] cls.add_method('SetTtl', 'void', - [param('unsigned char', 'ttl')]) + [param('uint8_t', 'ttl')]) return def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): @@ -5979,7 +5979,7 @@ def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpv6HopLimitTag::SetHopLimit(uint8_t hopLimit) [member function] cls.add_method('SetHopLimit', 'void', - [param('unsigned char', 'hopLimit')]) + [param('uint8_t', 'hopLimit')]) return def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): @@ -6025,7 +6025,7 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketIpv6TclassTag::SetTclass(uint8_t tclass) [member function] cls.add_method('SetTclass', 'void', - [param('unsigned char', 'tclass')]) + [param('uint8_t', 'tclass')]) return def register_Ns3SocketPriorityTag_methods(root_module, cls): @@ -6071,7 +6071,7 @@ def register_Ns3SocketPriorityTag_methods(root_module, cls): ## socket.h (module 'network'): void ns3::SocketPriorityTag::SetPriority(uint8_t priority) [member function] cls.add_method('SetPriority', 'void', - [param('unsigned char', 'priority')]) + [param('uint8_t', 'priority')]) return def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): @@ -6188,7 +6188,7 @@ def register_Ns3Time_methods(root_module, cls): ## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit unit) [member function] cls.add_method('FromInteger', 'ns3::Time', - [param('long unsigned int', 'value'), param('ns3::Time::Unit', 'unit')], + [param('uint64_t', 'value'), param('ns3::Time::Unit', 'unit')], is_static=True) ## nstime.h (module 'core'): double ns3::Time::GetDays() const [member function] cls.add_method('GetDays', @@ -6412,7 +6412,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::TriangularRandomVariable::GetInteger(uint32_t mean, uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'min'), param('unsigned int', 'max')]) + [param('uint32_t', 'mean'), param('uint32_t', 'min'), param('uint32_t', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::TriangularRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6450,7 +6450,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::UniformRandomVariable::GetInteger(uint32_t min, uint32_t max) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'min'), param('unsigned int', 'max')]) + [param('uint32_t', 'min'), param('uint32_t', 'max')]) ## random-variable-stream.h (module 'core'): double ns3::UniformRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6493,7 +6493,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::WeibullRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) + [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::WeibullRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6526,7 +6526,7 @@ def register_Ns3ZetaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ZetaRandomVariable::GetInteger(uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'alpha')]) + [param('uint32_t', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZetaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6560,11 +6560,11 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue(uint32_t n, double alpha) [member function] cls.add_method('GetValue', 'double', - [param('unsigned int', 'n'), param('double', 'alpha')]) + [param('uint32_t', 'n'), param('double', 'alpha')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ZipfRandomVariable::GetInteger(uint32_t n, uint32_t alpha) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'n'), param('unsigned int', 'alpha')]) + [param('uint32_t', 'n'), param('uint32_t', 'alpha')]) ## random-variable-stream.h (module 'core'): double ns3::ZipfRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -6888,7 +6888,7 @@ def register_Ns3Channel_methods(root_module, cls): ## channel.h (module 'network'): ns3::Ptr ns3::Channel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_pure_virtual=True, is_const=True, is_virtual=True) ## channel.h (module 'network'): uint32_t ns3::Channel::GetId() const [member function] cls.add_method('GetId', @@ -6927,7 +6927,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ConstantRandomVariable::GetInteger(uint32_t constant) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'constant')]) + [param('uint32_t', 'constant')]) ## random-variable-stream.h (module 'core'): double ns3::ConstantRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7119,7 +7119,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): void ns3::DeterministicRandomVariable::SetValueArray(double * values, uint64_t length) [member function] cls.add_method('SetValueArray', 'void', - [param('double *', 'values'), param('long unsigned int', 'length')]) + [param('double *', 'values'), param('uint64_t', 'length')]) ## random-variable-stream.h (module 'core'): double ns3::DeterministicRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7178,7 +7178,7 @@ def register_Ns3DynamicQueueLimits_methods(root_module, cls): ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Completed(uint32_t count) [member function] cls.add_method('Completed', 'void', - [param('unsigned int', 'count')], + [param('uint32_t', 'count')], is_virtual=True) ## dynamic-queue-limits.h (module 'network'): static ns3::TypeId ns3::DynamicQueueLimits::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -7188,7 +7188,7 @@ def register_Ns3DynamicQueueLimits_methods(root_module, cls): ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Queued(uint32_t count) [member function] cls.add_method('Queued', 'void', - [param('unsigned int', 'count')], + [param('uint32_t', 'count')], is_virtual=True) ## dynamic-queue-limits.h (module 'network'): void ns3::DynamicQueueLimits::Reset() [member function] cls.add_method('Reset', @@ -7416,11 +7416,11 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue(uint32_t k, double lambda) [member function] cls.add_method('GetValue', 'double', - [param('unsigned int', 'k'), param('double', 'lambda')]) + [param('uint32_t', 'k'), param('double', 'lambda')]) ## random-variable-stream.h (module 'core'): uint32_t ns3::ErlangRandomVariable::GetInteger(uint32_t k, uint32_t lambda) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'k'), param('unsigned int', 'lambda')]) + [param('uint32_t', 'k'), param('uint32_t', 'lambda')]) ## random-variable-stream.h (module 'core'): double ns3::ErlangRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7550,11 +7550,11 @@ def register_Ns3EthernetHeader_methods(root_module, cls): ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetLengthType(uint16_t size) [member function] cls.add_method('SetLengthType', 'void', - [param('short unsigned int', 'size')]) + [param('uint16_t', 'size')]) ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetPreambleSfd(uint64_t preambleSfd) [member function] cls.add_method('SetPreambleSfd', 'void', - [param('long unsigned int', 'preambleSfd')]) + [param('uint64_t', 'preambleSfd')]) ## ethernet-header.h (module 'network'): void ns3::EthernetHeader::SetSource(ns3::Mac48Address source) [member function] cls.add_method('SetSource', 'void', @@ -7622,7 +7622,7 @@ def register_Ns3EthernetTrailer_methods(root_module, cls): ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::SetFcs(uint32_t fcs) [member function] cls.add_method('SetFcs', 'void', - [param('unsigned int', 'fcs')]) + [param('uint32_t', 'fcs')]) return def register_Ns3EventImpl_methods(root_module, cls): @@ -7674,7 +7674,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ExponentialRandomVariable::GetInteger(uint32_t mean, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'bound')]) + [param('uint32_t', 'mean'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ExponentialRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7712,7 +7712,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::GammaRandomVariable::GetInteger(uint32_t alpha, uint32_t beta) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'alpha'), param('unsigned int', 'beta')]) + [param('uint32_t', 'alpha'), param('uint32_t', 'beta')]) ## random-variable-stream.h (module 'core'): double ns3::GammaRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -7974,7 +7974,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::LogNormalRandomVariable::GetInteger(uint32_t mu, uint32_t sigma) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mu'), param('unsigned int', 'sigma')]) + [param('uint32_t', 'mu'), param('uint32_t', 'sigma')]) ## random-variable-stream.h (module 'core'): double ns3::LogNormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -8265,12 +8265,12 @@ def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): bool ns3::NetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('Send', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], is_pure_virtual=True, is_virtual=True) ## net-device.h (module 'network'): bool ns3::NetDevice::SendFrom(ns3::Ptr packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('SendFrom', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], is_pure_virtual=True, is_virtual=True) ## net-device.h (module 'network'): void ns3::NetDevice::SetAddress(ns3::Address address) [member function] cls.add_method('SetAddress', @@ -8326,11 +8326,11 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::NotifyQueuedBytes(uint32_t bytes) [member function] cls.add_method('NotifyQueuedBytes', 'void', - [param('unsigned int', 'bytes')]) + [param('uint32_t', 'bytes')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::NotifyTransmittedBytes(uint32_t bytes) [member function] cls.add_method('NotifyTransmittedBytes', 'void', - [param('unsigned int', 'bytes')]) + [param('uint32_t', 'bytes')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::ResetQueueLimits() [member function] cls.add_method('ResetQueueLimits', 'void', @@ -8388,7 +8388,7 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): ## net-device-queue-interface.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function] cls.add_method('GetTxQueue', 'ns3::Ptr< ns3::NetDeviceQueue >', - [param('unsigned char', 'i')], + [param('uint8_t', 'i')], is_const=True) ## net-device-queue-interface.h (module 'network'): static ns3::TypeId ns3::NetDeviceQueueInterface::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -8406,7 +8406,7 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetTxQueuesN(uint8_t numTxQueues) [member function] cls.add_method('SetTxQueuesN', 'void', - [param('unsigned char', 'numTxQueues')]) + [param('uint8_t', 'numTxQueues')]) ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -8423,11 +8423,11 @@ def register_Ns3NixVector_methods(root_module, cls): ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', 'void', - [param('unsigned int', 'newBits'), param('unsigned int', 'numberOfBits')]) + [param('uint32_t', 'newBits'), param('uint32_t', 'numberOfBits')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::BitCount(uint32_t numberOfNeighbors) const [member function] cls.add_method('BitCount', 'uint32_t', - [param('unsigned int', 'numberOfNeighbors')], + [param('uint32_t', 'numberOfNeighbors')], is_const=True) ## nix-vector.h (module 'network'): ns3::Ptr ns3::NixVector::Copy() const [member function] cls.add_method('Copy', @@ -8437,11 +8437,11 @@ def register_Ns3NixVector_methods(root_module, cls): ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Deserialize(uint32_t const * buffer, uint32_t size) [member function] cls.add_method('Deserialize', 'uint32_t', - [param('uint32_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint32_t const *', 'buffer'), param('uint32_t', 'size')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::ExtractNeighborIndex(uint32_t numberOfBits) [member function] cls.add_method('ExtractNeighborIndex', 'uint32_t', - [param('unsigned int', 'numberOfBits')]) + [param('uint32_t', 'numberOfBits')]) ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetRemainingBits() [member function] cls.add_method('GetRemainingBits', 'uint32_t', @@ -8454,7 +8454,7 @@ def register_Ns3NixVector_methods(root_module, cls): ## nix-vector.h (module 'network'): uint32_t ns3::NixVector::Serialize(uint32_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint32_t *', 'buffer'), param('unsigned int', 'maxSize')], + [param('uint32_t *', 'buffer'), param('uint32_t', 'maxSize')], is_const=True) return @@ -8481,12 +8481,12 @@ def register_Ns3Node_methods(root_module, cls): ## node.h (module 'network'): ns3::Ptr ns3::Node::GetApplication(uint32_t index) const [member function] cls.add_method('GetApplication', 'ns3::Ptr< ns3::Application >', - [param('unsigned int', 'index')], + [param('uint32_t', 'index')], is_const=True) ## node.h (module 'network'): ns3::Ptr ns3::Node::GetDevice(uint32_t index) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('unsigned int', 'index')], + [param('uint32_t', 'index')], is_const=True) ## node.h (module 'network'): uint32_t ns3::Node::GetId() const [member function] cls.add_method('GetId', @@ -8525,7 +8525,7 @@ def register_Ns3Node_methods(root_module, cls): ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', - [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('short unsigned int', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) + [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', @@ -8578,7 +8578,7 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::NormalRandomVariable::GetInteger(uint32_t mean, uint32_t variance, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'mean'), param('unsigned int', 'variance'), param('unsigned int', 'bound')]) + [param('uint32_t', 'mean'), param('uint32_t', 'variance'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::NormalRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -8677,7 +8677,7 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function] cls.add_method('AddPaddingAtEnd', 'void', - [param('unsigned int', 'size')]) + [param('uint32_t', 'size')]) ## packet.h (module 'network'): void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function] cls.add_method('AddTrailer', 'void', @@ -8695,17 +8695,17 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): uint32_t ns3::Packet::CopyData(uint8_t * buffer, uint32_t size) const [member function] cls.add_method('CopyData', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned int', 'size')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'size')], is_const=True) ## packet.h (module 'network'): void ns3::Packet::CopyData(std::ostream * os, uint32_t size) const [member function] cls.add_method('CopyData', 'void', - [param('std::ostream *', 'os'), param('unsigned int', 'size')], + [param('std::ostream *', 'os'), param('uint32_t', 'size')], is_const=True) ## packet.h (module 'network'): ns3::Ptr ns3::Packet::CreateFragment(uint32_t start, uint32_t length) const [member function] cls.add_method('CreateFragment', 'ns3::Ptr< ns3::Packet >', - [param('unsigned int', 'start'), param('unsigned int', 'length')], + [param('uint32_t', 'start'), param('uint32_t', 'length')], is_const=True) ## packet.h (module 'network'): static void ns3::Packet::EnableChecking() [member function] cls.add_method('EnableChecking', @@ -8792,11 +8792,11 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): void ns3::Packet::RemoveAtEnd(uint32_t size) [member function] cls.add_method('RemoveAtEnd', 'void', - [param('unsigned int', 'size')]) + [param('uint32_t', 'size')]) ## packet.h (module 'network'): void ns3::Packet::RemoveAtStart(uint32_t size) [member function] cls.add_method('RemoveAtStart', 'void', - [param('unsigned int', 'size')]) + [param('uint32_t', 'size')]) ## packet.h (module 'network'): uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function] cls.add_method('RemoveHeader', 'uint32_t', @@ -8816,7 +8816,7 @@ def register_Ns3Packet_methods(root_module, cls): ## packet.h (module 'network'): uint32_t ns3::Packet::Serialize(uint8_t * buffer, uint32_t maxSize) const [member function] cls.add_method('Serialize', 'uint32_t', - [param('uint8_t *', 'buffer'), param('unsigned int', 'maxSize')], + [param('uint8_t *', 'buffer'), param('uint32_t', 'maxSize')], is_const=True) ## packet.h (module 'network'): void ns3::Packet::SetNixVector(ns3::Ptr nixVector) [member function] cls.add_method('SetNixVector', @@ -8937,22 +8937,22 @@ def register_Ns3PacketSocket_methods(root_module, cls): ## packet-socket.h (module 'network'): ns3::Ptr ns3::PacketSocket::Recv(uint32_t maxSize, uint32_t flags) [member function] cls.add_method('Recv', 'ns3::Ptr< ns3::Packet >', - [param('unsigned int', 'maxSize'), param('unsigned int', 'flags')], + [param('uint32_t', 'maxSize'), param('uint32_t', 'flags')], is_virtual=True) ## packet-socket.h (module 'network'): ns3::Ptr ns3::PacketSocket::RecvFrom(uint32_t maxSize, uint32_t flags, ns3::Address & fromAddress) [member function] cls.add_method('RecvFrom', 'ns3::Ptr< ns3::Packet >', - [param('unsigned int', 'maxSize'), param('unsigned int', 'flags'), param('ns3::Address &', 'fromAddress')], + [param('uint32_t', 'maxSize'), param('uint32_t', 'flags'), param('ns3::Address &', 'fromAddress')], is_virtual=True) ## packet-socket.h (module 'network'): int ns3::PacketSocket::Send(ns3::Ptr p, uint32_t flags) [member function] cls.add_method('Send', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags')], is_virtual=True) ## packet-socket.h (module 'network'): int ns3::PacketSocket::SendTo(ns3::Ptr p, uint32_t flags, ns3::Address const & toAddress) [member function] cls.add_method('SendTo', 'int', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('unsigned int', 'flags'), param('ns3::Address const &', 'toAddress')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint32_t', 'flags'), param('ns3::Address const &', 'toAddress')], is_virtual=True) ## packet-socket.h (module 'network'): bool ns3::PacketSocket::SetAllowBroadcast(bool allowBroadcast) [member function] cls.add_method('SetAllowBroadcast', @@ -9099,7 +9099,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): ## random-variable-stream.h (module 'core'): uint32_t ns3::ParetoRandomVariable::GetInteger(uint32_t scale, uint32_t shape, uint32_t bound) [member function] cls.add_method('GetInteger', 'uint32_t', - [param('unsigned int', 'scale'), param('unsigned int', 'shape'), param('unsigned int', 'bound')]) + [param('uint32_t', 'scale'), param('uint32_t', 'shape'), param('uint32_t', 'bound')]) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetValue() [member function] cls.add_method('GetValue', 'double', @@ -9258,11 +9258,11 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPushBack(uint8_t prefix) [member function] cls.add_method('PrefixPushBack', 'void', - [param('unsigned char', 'prefix')]) + [param('uint8_t', 'prefix')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPushFront(uint8_t prefix) [member function] cls.add_method('PrefixPushFront', 'void', - [param('unsigned char', 'prefix')]) + [param('uint8_t', 'prefix')]) ## packetbb.h (module 'network'): int ns3::PbbAddressBlock::PrefixSize() const [member function] cls.add_method('PrefixSize', 'int', @@ -9595,11 +9595,11 @@ def register_Ns3PbbMessage_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbMessage::SetHopCount(uint8_t hopcount) [member function] cls.add_method('SetHopCount', 'void', - [param('unsigned char', 'hopcount')]) + [param('uint8_t', 'hopcount')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetHopLimit(uint8_t hoplimit) [member function] cls.add_method('SetHopLimit', 'void', - [param('unsigned char', 'hoplimit')]) + [param('uint8_t', 'hoplimit')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetOriginatorAddress(ns3::Address address) [member function] cls.add_method('SetOriginatorAddress', 'void', @@ -9607,11 +9607,11 @@ def register_Ns3PbbMessage_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbMessage::SetSequenceNumber(uint16_t seqnum) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('short unsigned int', 'seqnum')]) + [param('uint16_t', 'seqnum')]) ## packetbb.h (module 'network'): void ns3::PbbMessage::SetType(uint8_t type) [member function] cls.add_method('SetType', 'void', - [param('unsigned char', 'type')]) + [param('uint8_t', 'type')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::TlvBack() [member function] cls.add_method('TlvBack', 'ns3::Ptr< ns3::PbbTlv >', @@ -9914,7 +9914,7 @@ def register_Ns3PbbPacket_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbPacket::SetSequenceNumber(uint16_t number) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('short unsigned int', 'number')]) + [param('uint16_t', 'number')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::TlvBack() [member function] cls.add_method('TlvBack', 'ns3::Ptr< ns3::PbbTlv >', @@ -10042,11 +10042,11 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetType(uint8_t type) [member function] cls.add_method('SetType', 'void', - [param('unsigned char', 'type')]) + [param('uint8_t', 'type')]) ## packetbb.h (module 'network'): void ns3::PbbTlv::SetTypeExt(uint8_t type) [member function] cls.add_method('SetTypeExt', 'void', - [param('unsigned char', 'type')]) + [param('uint8_t', 'type')]) ## packetbb.h (module 'network'): void ns3::PbbTlv::SetValue(ns3::Buffer start) [member function] cls.add_method('SetValue', 'void', @@ -10054,7 +10054,7 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetValue(uint8_t const * buffer, uint32_t size) [member function] cls.add_method('SetValue', 'void', - [param('uint8_t const *', 'buffer'), param('unsigned int', 'size')]) + [param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbTlv::GetIndexStart() const [member function] cls.add_method('GetIndexStart', 'uint8_t', @@ -10083,12 +10083,12 @@ def register_Ns3PbbTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbTlv::SetIndexStart(uint8_t index) [member function] cls.add_method('SetIndexStart', 'void', - [param('unsigned char', 'index')], + [param('uint8_t', 'index')], visibility='protected') ## packetbb.h (module 'network'): void ns3::PbbTlv::SetIndexStop(uint8_t index) [member function] cls.add_method('SetIndexStop', 'void', - [param('unsigned char', 'index')], + [param('uint8_t', 'index')], visibility='protected') ## packetbb.h (module 'network'): void ns3::PbbTlv::SetMultivalue(bool isMultivalue) [member function] cls.add_method('SetMultivalue', @@ -10310,7 +10310,7 @@ def register_Ns3RateErrorModel_methods(root_module, cls): ## error-model.h (module 'network'): int64_t ns3::RateErrorModel::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('long int', 'stream')]) + [param('int64_t', 'stream')]) ## error-model.h (module 'network'): double ns3::RateErrorModel::GetRate() const [member function] cls.add_method('GetRate', 'double', @@ -10414,7 +10414,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): ## simple-channel.h (module 'network'): ns3::Ptr ns3::SimpleChannel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True, is_virtual=True) ## simple-channel.h (module 'network'): uint32_t ns3::SimpleChannel::GetNDevices() const [member function] cls.add_method('GetNDevices', @@ -10429,7 +10429,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): ## simple-channel.h (module 'network'): void ns3::SimpleChannel::Send(ns3::Ptr p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr sender) [member function] cls.add_method('Send', 'void', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], is_virtual=True) ## simple-channel.h (module 'network'): void ns3::SimpleChannel::UnBlackList(ns3::Ptr from, ns3::Ptr to) [member function] cls.add_method('UnBlackList', @@ -10531,16 +10531,16 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::Receive(ns3::Ptr packet, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from) [member function] cls.add_method('Receive', 'void', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')]) + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from')]) ## simple-net-device.h (module 'network'): bool ns3::SimpleNetDevice::Send(ns3::Ptr packet, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('Send', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], is_virtual=True) ## simple-net-device.h (module 'network'): bool ns3::SimpleNetDevice::SendFrom(ns3::Ptr packet, ns3::Address const & source, ns3::Address const & dest, uint16_t protocolNumber) [member function] cls.add_method('SendFrom', 'bool', - [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('short unsigned int', 'protocolNumber')], + [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Address const &', 'source'), param('ns3::Address const &', 'dest'), param('uint16_t', 'protocolNumber')], is_virtual=True) ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetAddress(ns3::Address address) [member function] cls.add_method('SetAddress', @@ -10782,7 +10782,7 @@ def register_Ns3BurstErrorModel_methods(root_module, cls): ## error-model.h (module 'network'): int64_t ns3::BurstErrorModel::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', 'int64_t', - [param('long int', 'stream')]) + [param('int64_t', 'stream')]) ## error-model.h (module 'network'): double ns3::BurstErrorModel::GetBurstRate() const [member function] cls.add_method('GetBurstRate', 'double', @@ -11195,7 +11195,7 @@ def register_Ns3ErrorChannel_methods(root_module, cls): ## error-channel.h (module 'network'): ns3::Ptr ns3::ErrorChannel::GetDevice(uint32_t i) const [member function] cls.add_method('GetDevice', 'ns3::Ptr< ns3::NetDevice >', - [param('unsigned int', 'i')], + [param('uint32_t', 'i')], is_const=True, is_virtual=True) ## error-channel.h (module 'network'): uint32_t ns3::ErrorChannel::GetNDevices() const [member function] cls.add_method('GetNDevices', @@ -11210,7 +11210,7 @@ def register_Ns3ErrorChannel_methods(root_module, cls): ## error-channel.h (module 'network'): void ns3::ErrorChannel::Send(ns3::Ptr p, uint16_t protocol, ns3::Mac48Address to, ns3::Mac48Address from, ns3::Ptr sender) [member function] cls.add_method('Send', 'void', - [param('ns3::Ptr< ns3::Packet >', 'p'), param('short unsigned int', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], + [param('ns3::Ptr< ns3::Packet >', 'p'), param('uint16_t', 'protocol'), param('ns3::Mac48Address', 'to'), param('ns3::Mac48Address', 'from'), param('ns3::Ptr< ns3::SimpleNetDevice >', 'sender')], is_virtual=True) ## error-channel.h (module 'network'): void ns3::ErrorChannel::SetDuplicateMode(bool mode) [member function] cls.add_method('SetDuplicateMode', @@ -11319,11 +11319,11 @@ def register_Ns3PbbAddressTlv_methods(root_module, cls): ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetIndexStart(uint8_t index) [member function] cls.add_method('SetIndexStart', 'void', - [param('unsigned char', 'index')]) + [param('uint8_t', 'index')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetIndexStop(uint8_t index) [member function] cls.add_method('SetIndexStop', 'void', - [param('unsigned char', 'index')]) + [param('uint8_t', 'index')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlv::SetMultivalue(bool isMultivalue) [member function] cls.add_method('SetMultivalue', 'void', @@ -11351,7 +11351,7 @@ def register_Ns3QueueDiscItem_methods(root_module, cls): ## queue-item.h (module 'network'): void ns3::QueueDiscItem::SetTxQueueIndex(uint8_t txq) [member function] cls.add_method('SetTxQueueIndex', 'void', - [param('unsigned char', 'txq')]) + [param('uint8_t', 'txq')]) ## queue-item.h (module 'network'): void ns3::QueueDiscItem::AddHeader() [member function] cls.add_method('AddHeader', 'void', From 71f73e92b44e0b6c3b8674df189579f27662389d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Fri, 7 Jul 2017 23:21:20 +0200 Subject: [PATCH 142/551] internet-apps: DHCPv4 application Special thanks to: - Radu Lupu - Ankit Deepak - Deepti Rajagopal - Mohit P. Tahiliani --- .gitignore | 2 + AUTHORS | 2 + src/internet-apps/doc/internet-apps.rst | 85 +++- src/internet-apps/examples/dhcp-example.cc | 162 +++++++ src/internet-apps/examples/wscript | 8 + src/internet-apps/helper/dhcp-helper.cc | 220 +++++++++ src/internet-apps/helper/dhcp-helper.h | 118 +++++ src/internet-apps/model/dhcp-client.cc | 506 ++++++++++++++++++++ src/internet-apps/model/dhcp-client.h | 195 ++++++++ src/internet-apps/model/dhcp-header.cc | 517 +++++++++++++++++++++ src/internet-apps/model/dhcp-header.h | 322 +++++++++++++ src/internet-apps/model/dhcp-server.cc | 421 +++++++++++++++++ src/internet-apps/model/dhcp-server.h | 147 ++++++ src/internet-apps/test/dhcp-test.cc | 162 +++++++ src/internet-apps/wscript | 15 + src/internet/doc/ipv4.rst | 83 ++++ src/internet/doc/ipv6.rst | 2 +- 17 files changed, 2955 insertions(+), 12 deletions(-) create mode 100644 src/internet-apps/examples/dhcp-example.cc create mode 100644 src/internet-apps/examples/wscript create mode 100644 src/internet-apps/helper/dhcp-helper.cc create mode 100644 src/internet-apps/helper/dhcp-helper.h create mode 100644 src/internet-apps/model/dhcp-client.cc create mode 100644 src/internet-apps/model/dhcp-client.h create mode 100644 src/internet-apps/model/dhcp-header.cc create mode 100644 src/internet-apps/model/dhcp-header.h create mode 100644 src/internet-apps/model/dhcp-server.cc create mode 100644 src/internet-apps/model/dhcp-server.h create mode 100644 src/internet-apps/test/dhcp-test.cc diff --git a/.gitignore b/.gitignore index 5165012ca44..1ac66b75573 100644 --- a/.gitignore +++ b/.gitignore @@ -35,3 +35,5 @@ TAGS build-dir/ build/ +/.cproject +/.project diff --git a/AUTHORS b/AUTHORS index e937ee6a5c6..7799cc7b412 100644 --- a/AUTHORS +++ b/AUTHORS @@ -99,6 +99,7 @@ Björn Lichtblau (lichtbla@informatik.hu-berlin.de) Timo Lindhorst (tlnd@online.de) Erwan Livolant (erwan.livolant@inria.fr) Andrea Lupia (alupia@dimes.unical.it) +Radu Lupu Keith Ma (keith.nwsuaf@gmail.com) Federico Maguolo (maguolof@dei.unipd.it) Antti Makela (zarhan@cc.hut.fi) @@ -144,6 +145,7 @@ Ovidiu Poncea (ovidiu.poncea@cs.pub.ro) Vikas Pushkar (vikaskupushkar@gmail.com) Andrea Ranieri (andreran@uno.it) Bruno Ranieri (Yrrsinn@googlemail.com) +Deepti Rajagopal Varun Reddy (varunamarreddy@gmail.com) Ken Renard (kenneth.renard@arl.army.mil) Manuel Requena (mrequena@cttc.es) diff --git a/src/internet-apps/doc/internet-apps.rst b/src/internet-apps/doc/internet-apps.rst index a2776507adc..72226616366 100644 --- a/src/internet-apps/doc/internet-apps.rst +++ b/src/internet-apps/doc/internet-apps.rst @@ -14,16 +14,18 @@ The goal of this module is to hold all the Internet-specific applications, and most notably some very specific applications (e.g., ping) or daemons (e.g., radvd). Other non-Internet-specific applications such as packet generators are contained in other modules. -Model Description -***************** - The source code for the new module lives in the directory ``src/internet-apps``. Each application has its own goals, limitations and scope, which are briefly explained in the following. +All the applications are extensively used in the top-level ``examples`` +directories. The users are encouraged to check the scripts therein to have a +clear overview of the various options and usage tricks. + + V4Ping -====== +****** This app mimics a "ping" (ICMP Echo) using IPv4. The application allows the following attributes to be set: @@ -36,7 +38,7 @@ following attributes to be set: Moreover, the user can access the measured rtt value (as a Traced Source). Ping6 -===== +***** This app mimics a "ping" (ICMP Echo) using IPv6. The application allows the following attributes to be set: @@ -48,16 +50,77 @@ following attributes to be set: * Max number of packets to send Radvd -===== +***** This app mimics a "RADVD" daemon. I.e., the daemon responsible for IPv6 routers advertisements. All the IPv6 routers should have a RADVD daemon installed. The configuration of the Radvd application mimics the one of the radvd Linux program. -Examples and use -**************** +DHCPv4 +****** + +The |ns3| implementation of Dynamic Host Configuration Protocol (DHCP) +follows the specifications of :rfc:`2131` and :rfc:`2132`. + +The source code for DHCP is located in ``src/internet-apps/model`` and consists of the +following 6 files: + +* dhcp-server.h, +* dhcp-server.cc, +* dhcp-client.h, +* dhcp-client.cc, +* dhcp-header.h and +* dhcp-header.cc + +Helpers +======= + +The following two files have been added to ``src/internet-apps/helper`` for DHCP: + +* dhcp-helper.h and +* dhcp-helper.cc + +Tests +===== +The tests for DHCP can be found at ``src/internet-apps/test/dhcp-test.cc`` + +Examples +======== +The examples for DHCP can be found at ``src/internet-apps/examples/dhcp-example.cc`` + + +Scope and Limitations +===================== + +The server should be provided with a network address, mask and a range of address +for the pool. One client application can be installed on only one netdevice in a +node, and can configure address for only that netdevice. + +The following five basic DHCP messages are supported: + +* DHCP DISCOVER +* DHCP OFFER +* DHCP REQUEST +* DHCP ACK +* DHCP NACK + +Also, the following eight options of BootP are supported: + +* 1 (Mask) +* 50 (Requested Address) +* 51 (Address Lease Time) +* 53 (DHCP message type) +* 54 (DHCP server identifier) +* 58 (Address renew time) +* 59 (Address rebind time) +* 255 (end) + +The client identifier option (61) can be implemented in near future. + +In the current implementation, a DHCP client can obtain IPv4 address dynamically +from the DHCP server, and can renew it within a lease time period. + +Multiple DHCP servers can be configured, but the implementation does not support +the use of a DHCP Relay yet. -All the applications are extensively used in the top-level ``examples`` -directories. The users are encouraged to check the scripts therein to have a -clear overview of the various options and usage tricks. diff --git a/src/internet-apps/examples/dhcp-example.cc b/src/internet-apps/examples/dhcp-example.cc new file mode 100644 index 00000000000..1516aea31e6 --- /dev/null +++ b/src/internet-apps/examples/dhcp-example.cc @@ -0,0 +1,162 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#include +#include "ns3/core-module.h" +#include "ns3/network-module.h" +#include "ns3/internet-apps-module.h" +#include "ns3/csma-module.h" +#include "ns3/internet-module.h" +#include "ns3/point-to-point-module.h" +#include "ns3/applications-module.h" + +using namespace ns3; + +NS_LOG_COMPONENT_DEFINE ("DhcpExample"); + +int +main (int argc, char *argv[]) +{ + CommandLine cmd; + + bool verbose = false; + bool tracing = false; + cmd.AddValue ("verbose", "turn on the logs", verbose); + cmd.AddValue ("tracing", "turn on the tracing", tracing); + + cmd.Parse (argc, argv); + + // GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true)); + + if (verbose) + { + LogComponentEnable ("DhcpServer", LOG_LEVEL_ALL); + LogComponentEnable ("DhcpClient", LOG_LEVEL_ALL); + LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO); + LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO); + } + + Time stopTime = Seconds (20); + + NS_LOG_INFO ("Create nodes."); + NodeContainer nodes; + NodeContainer router; + nodes.Create (3); + router.Create (2); + + NodeContainer net (nodes, router); + + NS_LOG_INFO ("Create channels."); + CsmaHelper csma; + csma.SetChannelAttribute ("DataRate", StringValue ("5Mbps")); + csma.SetChannelAttribute ("Delay", StringValue ("2ms")); + csma.SetDeviceAttribute ("Mtu", UintegerValue (1500)); + NetDeviceContainer devNet = csma.Install (net); + + NodeContainer p2pNodes; + p2pNodes.Add (net.Get (4)); + p2pNodes.Create (1); + + PointToPointHelper pointToPoint; + pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps")); + pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms")); + + NetDeviceContainer p2pDevices; + p2pDevices = pointToPoint.Install (p2pNodes); + + InternetStackHelper tcpip; + tcpip.Install (nodes); + tcpip.Install (router); + tcpip.Install (p2pNodes.Get (1)); + + Ipv4AddressHelper address; + address.SetBase ("172.30.1.0", "255.255.255.0"); + Ipv4InterfaceContainer p2pInterfaces; + p2pInterfaces = address.Assign (p2pDevices); + + // manually add a routing entry because we don't want to add a dynamic routing + Ipv4StaticRoutingHelper ipv4RoutingHelper; + Ptr ipv4Ptr = p2pNodes.Get (1)->GetObject (); + Ptr staticRoutingA = ipv4RoutingHelper.GetStaticRouting (ipv4Ptr); + staticRoutingA->AddNetworkRouteTo (Ipv4Address ("172.30.0.0"), Ipv4Mask ("/24"), + Ipv4Address ("172.30.1.1"), 1); + + NS_LOG_INFO ("Setup the IP addresses and create DHCP applications."); + DhcpHelper dhcpHelper; + + // The router must have a fixed IP. + Ipv4InterfaceContainer fixedNodes = dhcpHelper.InstallFixedAddress (devNet.Get (4), Ipv4Address ("172.30.0.17"), Ipv4Mask ("/24")); + // Not really necessary, IP forwarding is enabled by default in IPv4. + fixedNodes.Get (0).first->SetAttribute ("IpForward", BooleanValue (true)); + + // DHCP server + ApplicationContainer dhcpServerApp = dhcpHelper.InstallDhcpServer (devNet.Get (3), Ipv4Address ("172.30.0.12"), + Ipv4Address ("172.30.0.0"), Ipv4Mask ("/24"), + Ipv4Address ("172.30.0.10"), Ipv4Address ("172.30.0.15"), + Ipv4Address ("172.30.0.17")); + + // This is just to show how it can be done. + DynamicCast (dhcpServerApp.Get (0))->AddStaticDhcpEntry (devNet.Get (2)->GetAddress (), Ipv4Address ("172.30.0.14")); + + dhcpServerApp.Start (Seconds (0.0)); + dhcpServerApp.Stop (stopTime); + + // DHCP clients + NetDeviceContainer dhcpClientNetDevs; + dhcpClientNetDevs.Add (devNet.Get (0)); + dhcpClientNetDevs.Add (devNet.Get (1)); + dhcpClientNetDevs.Add (devNet.Get (2)); + + ApplicationContainer dhcpClients = dhcpHelper.InstallDhcpClient (dhcpClientNetDevs); + dhcpClients.Start (Seconds (1.0)); + dhcpClients.Stop (stopTime); + + UdpEchoServerHelper echoServer (9); + + ApplicationContainer serverApps = echoServer.Install (p2pNodes.Get (1)); + serverApps.Start (Seconds (0.0)); + serverApps.Stop (stopTime); + + UdpEchoClientHelper echoClient (p2pInterfaces.GetAddress (1), 9); + echoClient.SetAttribute ("MaxPackets", UintegerValue (100)); + echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0))); + echoClient.SetAttribute ("PacketSize", UintegerValue (1024)); + + ApplicationContainer clientApps = echoClient.Install (nodes.Get (1)); + clientApps.Start (Seconds (10.0)); + clientApps.Stop (stopTime); + + Simulator::Stop (stopTime + Seconds (10.0)); + + if (tracing) + { + csma.EnablePcapAll ("dhcp-csma"); + pointToPoint.EnablePcapAll ("dhcp-p2p"); + } + + NS_LOG_INFO ("Run Simulation."); + Simulator::Run (); + Simulator::Destroy (); + NS_LOG_INFO ("Done."); +} diff --git a/src/internet-apps/examples/wscript b/src/internet-apps/examples/wscript new file mode 100644 index 00000000000..fcf3fee0a11 --- /dev/null +++ b/src/internet-apps/examples/wscript @@ -0,0 +1,8 @@ +## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*- + +def build(bld): + if not bld.env['ENABLE_EXAMPLES']: + return; + + obj = bld.create_ns3_program('dhcp-example', ['internet', 'internet-apps', 'csma', 'point-to-point', 'applications']) + obj.source = 'dhcp-example.cc' diff --git a/src/internet-apps/helper/dhcp-helper.cc b/src/internet-apps/helper/dhcp-helper.cc new file mode 100644 index 00000000000..5860644f8f2 --- /dev/null +++ b/src/internet-apps/helper/dhcp-helper.cc @@ -0,0 +1,220 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#include "dhcp-helper.h" +#include "ns3/dhcp-server.h" +#include "ns3/dhcp-client.h" +#include "ns3/uinteger.h" +#include "ns3/names.h" +#include "ns3/ipv4.h" +#include "ns3/loopback-net-device.h" +#include "ns3/traffic-control-layer.h" +#include "ns3/traffic-control-helper.h" +#include "ns3/log.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("DhcpHelper"); + +DhcpHelper::DhcpHelper () +{ + m_clientFactory.SetTypeId (DhcpClient::GetTypeId ()); + m_serverFactory.SetTypeId (DhcpServer::GetTypeId ()); +} + +void DhcpHelper::SetClientAttribute ( + std::string name, + const AttributeValue &value) +{ + m_clientFactory.Set (name, value); +} + +void DhcpHelper::SetServerAttribute ( + std::string name, + const AttributeValue &value) +{ + m_serverFactory.Set (name, value); +} + +ApplicationContainer DhcpHelper::InstallDhcpClient (Ptr netDevice) const +{ + return ApplicationContainer (InstallDhcpClientPriv (netDevice)); +} + +ApplicationContainer DhcpHelper::InstallDhcpClient (NetDeviceContainer netDevices) const +{ + ApplicationContainer apps; + for (NetDeviceContainer::Iterator i = netDevices.Begin (); i != netDevices.End (); ++i) + { + apps.Add (InstallDhcpClientPriv (*i)); + } + return apps; +} + +Ptr DhcpHelper::InstallDhcpClientPriv (Ptr netDevice) const +{ + Ptr node = netDevice->GetNode (); + NS_ASSERT_MSG (node != 0, "DhcpClientHelper: NetDevice is not not associated with any node -> fail"); + + Ptr ipv4 = node->GetObject (); + NS_ASSERT_MSG (ipv4, "DhcpHelper: NetDevice is associated" + " with a node without IPv4 stack installed -> fail " + "(maybe need to use InternetStackHelper?)"); + + int32_t interface = ipv4->GetInterfaceForDevice (netDevice); + if (interface == -1) + { + interface = ipv4->AddInterface (netDevice); + } + NS_ASSERT_MSG (interface >= 0, "DhcpHelper: Interface index not found"); + + ipv4->SetMetric (interface, 1); + ipv4->SetUp (interface); + + // Install the default traffic control configuration if the traffic + // control layer has been aggregated, if this is not + // a loopback interface, and there is no queue disc installed already + Ptr tc = node->GetObject (); + if (tc && DynamicCast (netDevice) == 0 && tc->GetRootQueueDiscOnDevice (netDevice) == 0) + { + NS_LOG_LOGIC ("DhcpHelper - Installing default traffic control configuration"); + TrafficControlHelper tcHelper = TrafficControlHelper::Default (); + tcHelper.Install (netDevice); + } + + Ptr app = DynamicCast (m_clientFactory.Create ()); + app->SetDhcpClientNetDevice (netDevice); + node->AddApplication (app); + + return app; +} + +ApplicationContainer DhcpHelper::InstallDhcpServer (Ptr netDevice, Ipv4Address serverAddr, + Ipv4Address poolAddr, Ipv4Mask poolMask, + Ipv4Address minAddr, Ipv4Address maxAddr, + Ipv4Address gateway) +{ + m_serverFactory.Set ("PoolAddresses", Ipv4AddressValue (poolAddr)); + m_serverFactory.Set ("PoolMask", Ipv4MaskValue (poolMask)); + m_serverFactory.Set ("FirstAddress", Ipv4AddressValue (minAddr)); + m_serverFactory.Set ("LastAddress", Ipv4AddressValue (maxAddr)); + m_serverFactory.Set ("Gateway", Ipv4AddressValue (gateway)); + + Ptr node = netDevice->GetNode (); + NS_ASSERT_MSG (node != 0, "DhcpHelper: NetDevice is not not associated with any node -> fail"); + + Ptr ipv4 = node->GetObject (); + NS_ASSERT_MSG (ipv4, "DhcpHelper: NetDevice is associated" + " with a node without IPv4 stack installed -> fail " + "(maybe need to use InternetStackHelper?)"); + + int32_t interface = ipv4->GetInterfaceForDevice (netDevice); + if (interface == -1) + { + interface = ipv4->AddInterface (netDevice); + } + NS_ASSERT_MSG (interface >= 0, "DhcpHelper: Interface index not found"); + + Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (serverAddr, poolMask); + ipv4->AddAddress (interface, ipv4Addr); + ipv4->SetMetric (interface, 1); + ipv4->SetUp (interface); + + // Install the default traffic control configuration if the traffic + // control layer has been aggregated, if this is not + // a loopback interface, and there is no queue disc installed already + Ptr tc = node->GetObject (); + if (tc && DynamicCast (netDevice) == 0 && tc->GetRootQueueDiscOnDevice (netDevice) == 0) + { + NS_LOG_LOGIC ("DhcpHelper - Installing default traffic control configuration"); + TrafficControlHelper tcHelper = TrafficControlHelper::Default (); + tcHelper.Install (netDevice); + } + + // check that the already fixed addresses are not in conflict with the pool + std::list::iterator iter; + for (iter=m_fixedAddresses.begin (); iter!=m_fixedAddresses.end (); iter ++) + { + if (iter->Get () >= minAddr.Get () && iter->Get () <= maxAddr.Get ()) + { + NS_ABORT_MSG ("DhcpHelper: Fixed address can not conflict with a pool: " << *iter << " is in [" << minAddr << ", " << maxAddr << "]"); + } + } + m_addressPools.push_back (std::make_pair (minAddr, maxAddr)); + + Ptr app = m_serverFactory.Create (); + node->AddApplication (app); + return ApplicationContainer (app); +} + +Ipv4InterfaceContainer DhcpHelper::InstallFixedAddress (Ptr netDevice, Ipv4Address addr, Ipv4Mask mask) +{ + Ipv4InterfaceContainer retval; + + Ptr node = netDevice->GetNode (); + NS_ASSERT_MSG (node != 0, "DhcpHelper: NetDevice is not not associated with any node -> fail"); + + Ptr ipv4 = node->GetObject (); + NS_ASSERT_MSG (ipv4, "DhcpHelper: NetDevice is associated" + " with a node without IPv4 stack installed -> fail " + "(maybe need to use InternetStackHelper?)"); + + int32_t interface = ipv4->GetInterfaceForDevice (netDevice); + if (interface == -1) + { + interface = ipv4->AddInterface (netDevice); + } + NS_ASSERT_MSG (interface >= 0, "DhcpHelper: Interface index not found"); + + Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (addr, mask); + ipv4->AddAddress (interface, ipv4Addr); + ipv4->SetMetric (interface, 1); + ipv4->SetUp (interface); + retval.Add (ipv4, interface); + + // Install the default traffic control configuration if the traffic + // control layer has been aggregated, if this is not + // a loopback interface, and there is no queue disc installed already + Ptr tc = node->GetObject (); + if (tc && DynamicCast (netDevice) == 0 && tc->GetRootQueueDiscOnDevice (netDevice) == 0) + { + NS_LOG_LOGIC ("DhcpHelper - Installing default traffic control configuration"); + TrafficControlHelper tcHelper = TrafficControlHelper::Default (); + tcHelper.Install (netDevice); + } + + // check that the already fixed addresses are not in conflict with the pool + std::list >::iterator iter; + for (iter=m_addressPools.begin (); iter!=m_addressPools.end (); iter ++) + { + if (addr.Get () >= iter->first.Get () && addr.Get () <= iter->second.Get ()) + { + NS_ABORT_MSG ("DhcpHelper: Fixed address can not conflict with a pool: " << addr << " is in [" << iter->first << ", " << iter->second << "]"); + } + } + m_fixedAddresses.push_back (addr); + return retval; +} + +} // namespace ns3 diff --git a/src/internet-apps/helper/dhcp-helper.h b/src/internet-apps/helper/dhcp-helper.h new file mode 100644 index 00000000000..7fbbe171cbc --- /dev/null +++ b/src/internet-apps/helper/dhcp-helper.h @@ -0,0 +1,118 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#ifndef DHCP_HELPER_H +#define DHCP_HELPER_H + +#include +#include "ns3/application-container.h" +#include "ns3/net-device-container.h" +#include "ns3/object-factory.h" +#include "ns3/ipv4-address.h" +#include "ns3/ipv4-interface-container.h" + +namespace ns3 { + +/** + * \ingroup dhcp + * + * \class DhcpHelper + * \brief The helper class used to configure and install DHCP applications on nodes + */ +class DhcpHelper +{ +public: + DhcpHelper (); + + /** + * \brief Set DHCP client attributes + * \param name Name of the attribute + * \param value Value to be set + */ + void SetClientAttribute (std::string name, const AttributeValue &value); + + /** + * \brief Set DHCP server attributes + * \param name Name of the attribute + * \param value Value to be set + */ + void SetServerAttribute (std::string name, const AttributeValue &value); + + /** + * \brief Install DHCP client of a nodes / NetDevice + * \param netDevice The NetDevice on which DHCP client application has to be installed + * \return The application container with DHCP client installed + */ + ApplicationContainer InstallDhcpClient (Ptr netDevice) const; + + /** + * \brief Install DHCP client of a set of nodes / NetDevices + * \param netDevices The NetDevices on which DHCP client application has to be installed + * \return The application container with DHCP client installed + */ + ApplicationContainer InstallDhcpClient (NetDeviceContainer netDevices) const; + + /** + * \brief Install DHCP server of a node / NetDevice + * + * Note: the server address must be coherent with the pool address, because + * DHCP relays are not yet supported. + * + * \param netDevice The NetDevice on which DHCP server application has to be installed + * \param serverAddr The Ipv4Address of the server + * \param poolAddr The Ipv4Address (network part) of the allocated pool + * \param poolMask The mask of the allocated pool + * \param minAddr The lower bound of the Ipv4Address pool + * \param maxAddr The upper bound of the Ipv4Address pool + * \param gateway The Ipv4Address of default gateway (optional) + * \return The application container with DHCP server installed + */ + ApplicationContainer InstallDhcpServer (Ptr netDevice, Ipv4Address serverAddr, + Ipv4Address poolAddr, Ipv4Mask poolMask, + Ipv4Address minAddr, Ipv4Address maxAddr, + Ipv4Address gateway = Ipv4Address ()); + /** + * \brief Assign a fixed IP addresses to a net device. + * \param netDevice The NetDevice on which the address has to be installed + * \param serverAddr The Ipv4Address + * \param poolMask The network mask + */ + Ipv4InterfaceContainer InstallFixedAddress (Ptr netDevice, Ipv4Address addr, Ipv4Mask mask); + +private: + /** + * \brief Function to install DHCP client on a node + * \param node The node on which DHCP client application has to be installed + * \return The pointer to the installed DHCP client + */ + Ptr InstallDhcpClientPriv (Ptr netDevice) const; + ObjectFactory m_clientFactory; //!< DHCP client factory + ObjectFactory m_serverFactory; //!< DHCP server factory + std::list m_fixedAddresses; //!< list of fixed addresses already allocated. + std::list< std::pair > m_addressPools; //!< list of address pools. +}; + +} // namespace ns3 + +#endif /* DHCP_HELPER_H */ diff --git a/src/internet-apps/model/dhcp-client.cc b/src/internet-apps/model/dhcp-client.cc new file mode 100644 index 00000000000..ee2accfbb28 --- /dev/null +++ b/src/internet-apps/model/dhcp-client.cc @@ -0,0 +1,506 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + * + */ + +#include +#include +#include + +#include "ns3/ipv4.h" +#include "ns3/log.h" +#include "ns3/double.h" +#include "ns3/ipv4-address.h" +#include "ns3/nstime.h" +#include "ns3/inet-socket-address.h" +#include "ns3/socket.h" +#include "ns3/simulator.h" +#include "ns3/socket-factory.h" +#include "ns3/packet.h" +#include "ns3/ipv4-static-routing-helper.h" +#include "ns3/uinteger.h" +#include "ns3/random-variable-stream.h" +#include "ns3/pointer.h" +#include "ns3/string.h" +#include "ns3/ipv4-routing-table-entry.h" +#include "dhcp-client.h" +#include "dhcp-header.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("DhcpClient"); +NS_OBJECT_ENSURE_REGISTERED (DhcpClient); + +TypeId +DhcpClient::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::DhcpClient") + .SetParent () + .AddConstructor () + .SetGroupName ("Internet-Apps") + .AddAttribute ("RTRS", "Time for retransmission of Discover message", + TimeValue (Seconds (5)), + MakeTimeAccessor (&DhcpClient::m_rtrs), + MakeTimeChecker ()) + .AddAttribute ("Collect", "Time for which offer collection starts", + TimeValue (Seconds (5)), + MakeTimeAccessor (&DhcpClient::m_collect), + MakeTimeChecker ()) + .AddAttribute ("ReRequest", "Time after which request will be resent to next server", + TimeValue (Seconds (10)), + MakeTimeAccessor (&DhcpClient::m_nextoffer), + MakeTimeChecker ()) + .AddAttribute ("Transactions", + "The possible value of transaction numbers ", + StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1000000.0]"), + MakePointerAccessor (&DhcpClient::m_ran), + MakePointerChecker ()) + .AddTraceSource ("NewLease", + "Get a NewLease", + MakeTraceSourceAccessor (&DhcpClient::m_newLease), + "ns3::Ipv4Address::TracedCallback") + .AddTraceSource ("ExpireLease", + "A lease expires", + MakeTraceSourceAccessor (&DhcpClient::m_expiry), + "ns3::Ipv4Address::TracedCallback"); + return tid; +} + +DhcpClient::DhcpClient () +{ + NS_LOG_FUNCTION_NOARGS (); + m_server = Ipv4Address::GetAny (); + m_socket = 0; + m_refreshEvent = EventId (); + m_requestEvent = EventId (); + m_discoverEvent = EventId (); + m_rebindEvent = EventId (); + m_nextOfferEvent = EventId (); + m_timeout = EventId (); +} + +DhcpClient::DhcpClient (Ptr netDevice) +{ + NS_LOG_FUNCTION_NOARGS (); + m_device = netDevice; + m_server = Ipv4Address::GetAny (); + m_socket = 0; + m_refreshEvent = EventId (); + m_requestEvent = EventId (); + m_discoverEvent = EventId (); + m_rebindEvent = EventId (); + m_nextOfferEvent = EventId (); + m_timeout = EventId (); +} + +DhcpClient::~DhcpClient () +{ + NS_LOG_FUNCTION_NOARGS (); +} + +Ptr DhcpClient::GetDhcpClientNetDevice (void) +{ + return m_device; +} + + +void DhcpClient::SetDhcpClientNetDevice (Ptr netDevice) +{ + m_device = netDevice; +} + +Ipv4Address DhcpClient::GetDhcpServer (void) +{ + return m_server; +} + +void +DhcpClient::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + + m_device = 0; + + Application::DoDispose (); +} + +int64_t +DhcpClient::AssignStreams (int64_t stream) +{ + NS_LOG_FUNCTION (this << stream); + m_ran->SetStream (stream); + return 1; +} + +void +DhcpClient::StartApplication (void) +{ + NS_LOG_FUNCTION (this); + + m_remoteAddress = Ipv4Address ("255.255.255.255"); + m_myAddress = Ipv4Address ("0.0.0.0"); + m_gateway = Ipv4Address ("0.0.0.0"); + Ptr ipv4 = GetNode ()->GetObject (); + uint32_t ifIndex = ipv4->GetInterfaceForDevice (m_device); + + // We need to cleanup the type from the stored chaddr, or later we'll fail to compare it. + // Moreover, the length is always 16, because chaddr is 16 bytes. + Address myAddress = m_device->GetAddress (); + NS_LOG_INFO ("My address is " << myAddress); + uint8_t addr[Address::MAX_SIZE]; + std::memset (addr, 0, Address::MAX_SIZE); + uint32_t len = myAddress.CopyTo (addr); + NS_ASSERT_MSG (len <= 16, "DHCP client can not handle a chaddr larger than 16 bytes"); + m_chaddr.CopyFrom (addr, 16); + NS_LOG_INFO ("My m_chaddr is " << m_chaddr); + + bool found = false; + for (uint32_t i = 0; i < ipv4->GetNAddresses (ifIndex); i++) + { + if (ipv4->GetAddress (ifIndex, i).GetLocal () == m_myAddress) + { + found = true; + } + } + if (!found) + { + ipv4->AddAddress (ifIndex, Ipv4InterfaceAddress (Ipv4Address ("0.0.0.0"),Ipv4Mask ("/0"))); + } + if (m_socket == 0) + { + TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory"); + m_socket = Socket::CreateSocket (GetNode (), tid); + InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 68); + m_socket->SetAllowBroadcast (true); + m_socket->Bind (local); + m_socket->BindToNetDevice (m_device); + } + m_socket->SetRecvCallback (MakeCallback (&DhcpClient::NetHandler, this)); + + m_device->AddLinkChangeCallback (MakeCallback (&DhcpClient::LinkStateHandler, this)); + Boot (); + +} + +void +DhcpClient::StopApplication () +{ + NS_LOG_FUNCTION (this); + + Simulator::Remove (m_discoverEvent); + Simulator::Remove (m_requestEvent); + Simulator::Remove (m_rebindEvent); + Simulator::Remove (m_refreshEvent); + Simulator::Remove (m_timeout); + Simulator::Remove (m_nextOfferEvent); + Ptr ipv4 = GetNode ()->GetObject (); + + int32_t ifIndex = ipv4->GetInterfaceForDevice (m_device); + for (uint32_t i = 0; i < ipv4->GetNAddresses (ifIndex); i++) + { + if (ipv4->GetAddress (ifIndex,i).GetLocal () == m_myAddress) + { + ipv4->RemoveAddress (ifIndex, i); + break; + } + } + + m_socket->SetRecvCallback (MakeNullCallback > ()); + m_socket->Close (); +} + +void DhcpClient::LinkStateHandler (void) +{ + NS_LOG_FUNCTION (this); + + if (m_device->IsLinkUp ()) + { + NS_LOG_INFO ("Link up at " << Simulator::Now ().As (Time::S)); + m_socket->SetRecvCallback (MakeCallback (&DhcpClient::NetHandler, this)); + StartApplication (); + } + else + { + NS_LOG_INFO ("Link down at " << Simulator::Now ().As (Time::S)); //reinitialization + Simulator::Remove (m_refreshEvent); //stop refresh timer!!!! + Simulator::Remove (m_rebindEvent); + Simulator::Remove (m_timeout); + m_socket->SetRecvCallback (MakeNullCallback > ()); //stop receiving on this socket !!! + + Ptr ipv4MN = GetNode ()->GetObject (); + int32_t ifIndex = ipv4MN->GetInterfaceForDevice (m_device); + + for (uint32_t i = 0; i < ipv4MN->GetNAddresses (ifIndex); i++) + { + if (ipv4MN->GetAddress (ifIndex,i).GetLocal () == m_myAddress) + { + ipv4MN->RemoveAddress (ifIndex, i); + break; + } + } + + Ipv4StaticRoutingHelper ipv4RoutingHelper; + Ptr staticRouting = ipv4RoutingHelper.GetStaticRouting (ipv4MN); + uint32_t i; + for (i = 0; i < staticRouting->GetNRoutes (); i++) + { + if (staticRouting->GetRoute (i).GetGateway () == m_gateway) + { + staticRouting->RemoveRoute (i); + break; + } + } + } +} + +void DhcpClient::NetHandler (Ptr socket) +{ + NS_LOG_FUNCTION (this << socket); + + Address from; + Ptr packet = m_socket->RecvFrom (from); + DhcpHeader header; + if (packet->RemoveHeader (header) == 0) + { + return; + } + if (header.GetChaddr () != m_chaddr) + { + return; + } + if (m_state == WAIT_OFFER && header.GetType () == DhcpHeader::DHCPOFFER) + { + OfferHandler (header); + } + if (m_state == WAIT_ACK && header.GetType () == DhcpHeader::DHCPACK) + { + Simulator::Remove (m_nextOfferEvent); + AcceptAck (header,from); + } + if (m_state == WAIT_ACK && header.GetType () == DhcpHeader::DHCPNACK) + { + Simulator::Remove (m_nextOfferEvent); + Boot (); + } +} + +void DhcpClient::Boot (void) +{ + NS_LOG_FUNCTION (this); + + DhcpHeader header; + Ptr packet; + packet = Create (); + header.ResetOpt (); + m_tran = (uint32_t) (m_ran->GetValue ()); + header.SetTran (m_tran); + header.SetType (DhcpHeader::DHCPDISCOVER); + header.SetTime (); + header.SetChaddr (m_chaddr); + packet->AddHeader (header); + + if ((m_socket->SendTo (packet, 0, InetSocketAddress (Ipv4Address ("255.255.255.255"), DHCP_PEER_PORT))) >= 0) + { + NS_LOG_INFO ("DHCP DISCOVER sent" ); + } + else + { + NS_LOG_INFO ("Error while sending DHCP DISCOVER to " << m_remoteAddress); + } + m_state = WAIT_OFFER; + m_offered = false; + m_discoverEvent = Simulator::Schedule (m_rtrs, &DhcpClient::Boot, this); +} + +void DhcpClient::OfferHandler (DhcpHeader header) +{ + NS_LOG_FUNCTION (this << header); + + m_offerList.push_back (header); + if (m_offered == false) + { + Simulator::Remove (m_discoverEvent); + m_offered = true; + Simulator::Schedule (m_collect, &DhcpClient::Select, this); + } +} + +void DhcpClient::Select (void) +{ + NS_LOG_FUNCTION (this); + + if (m_offerList.empty ()) + { + Boot (); + return; + } + + DhcpHeader header = m_offerList.front (); + m_offerList.pop_front (); + m_lease = Time (Seconds (header.GetLease ())); + m_renew = Time (Seconds (header.GetRenew ())); + m_rebind = Time (Seconds (header.GetRebind ())); + m_offeredAddress = header.GetYiaddr (); + m_myMask = Ipv4Mask (header.GetMask ()); + m_server = header.GetDhcps (); + m_gateway = header.GetRouter (); + m_offerList.clear (); + m_offered = false; + Request (); +} + +void DhcpClient::Request (void) +{ + NS_LOG_FUNCTION (this); + + DhcpHeader header; + Ptr packet; + if (m_state != REFRESH_LEASE) + { + packet = Create (); + header.ResetOpt (); + header.SetType (DhcpHeader::DHCPREQ); + header.SetTime (); + header.SetTran (m_tran); + header.SetReq (m_offeredAddress); + header.SetChaddr (m_chaddr); + packet->AddHeader (header); + m_socket->SendTo (packet, 0, InetSocketAddress (Ipv4Address ("255.255.255.255"), DHCP_PEER_PORT)); + m_state = WAIT_ACK; + m_nextOfferEvent = Simulator::Schedule (m_nextoffer, &DhcpClient::Select, this); + } + else + { + uint32_t addr = m_myAddress.Get (); + packet = Create ((uint8_t*)&addr, sizeof(addr)); + header.ResetOpt (); + m_tran = (uint32_t) (m_ran->GetValue ()); + header.SetTran (m_tran); + header.SetTime (); + header.SetType (DhcpHeader::DHCPREQ); + header.SetReq (m_myAddress); + m_offeredAddress = m_myAddress; + header.SetChaddr (m_chaddr); + packet->AddHeader (header); + if ((m_socket->SendTo (packet, 0, InetSocketAddress (m_remoteAddress, DHCP_PEER_PORT))) >= 0) + { + NS_LOG_INFO ("DHCP REQUEST sent"); + } + else + { + NS_LOG_INFO ("Error while sending DHCP REQ to " << m_remoteAddress); + } + m_state = WAIT_ACK; + } +} + +void DhcpClient::AcceptAck (DhcpHeader header, Address from) +{ + NS_LOG_FUNCTION (this << header << from); + + Simulator::Remove (m_rebindEvent); + Simulator::Remove (m_refreshEvent); + Simulator::Remove (m_timeout); + NS_LOG_INFO ("DHCP ACK received"); + Ptr ipv4 = GetNode ()->GetObject (); + int32_t ifIndex = ipv4->GetInterfaceForDevice (m_device); + + for (uint32_t i = 0; i < ipv4->GetNAddresses (ifIndex); i++) + { + if (ipv4->GetAddress (ifIndex,i).GetLocal () == m_myAddress) + { + NS_LOG_LOGIC ("Got a new address, removing old one: " << m_myAddress); + ipv4->RemoveAddress (ifIndex, i); + break; + } + } + + ipv4->AddAddress (ifIndex, Ipv4InterfaceAddress (m_offeredAddress, m_myMask)); + ipv4->SetUp (ifIndex); + + InetSocketAddress remote = InetSocketAddress (InetSocketAddress::ConvertFrom (from).GetIpv4 (), DHCP_PEER_PORT); + m_socket->Connect (remote); + if (m_myAddress != m_offeredAddress) + { + m_newLease (m_offeredAddress); + if (m_myAddress != Ipv4Address ("0.0.0.0")) + { + m_expiry (m_myAddress); + } + } + m_myAddress = m_offeredAddress; + Ipv4StaticRoutingHelper ipv4RoutingHelper; + Ptr staticRouting = ipv4RoutingHelper.GetStaticRouting (ipv4); + if (m_gateway == Ipv4Address ("0.0.0.0")) + { + m_gateway = InetSocketAddress::ConvertFrom (from).GetIpv4 (); + } + + staticRouting->SetDefaultRoute (m_gateway, ifIndex, 0); + + m_remoteAddress = InetSocketAddress::ConvertFrom (from).GetIpv4 (); + NS_LOG_INFO ("Current DHCP Server is " << m_remoteAddress); + + m_offerList.clear (); + m_refreshEvent = Simulator::Schedule (m_renew, &DhcpClient::Request, this); + m_rebindEvent = Simulator::Schedule (m_rebind, &DhcpClient::Request, this); + m_timeout = Simulator::Schedule (m_lease, &DhcpClient::RemoveAndStart, this); + m_state = REFRESH_LEASE; +} + +void DhcpClient::RemoveAndStart () +{ + NS_LOG_FUNCTION (this); + + Simulator::Remove (m_nextOfferEvent); + Simulator::Remove (m_refreshEvent); + Simulator::Remove (m_rebindEvent); + Simulator::Remove (m_timeout); + + Ptr ipv4MN = GetNode ()->GetObject (); + int32_t ifIndex = ipv4MN->GetInterfaceForDevice (m_device); + + for (uint32_t i = 0; i < ipv4MN->GetNAddresses (ifIndex); i++) + { + if (ipv4MN->GetAddress (ifIndex,i).GetLocal () == m_myAddress) + { + ipv4MN->RemoveAddress (ifIndex, i); + break; + } + } + m_expiry (m_myAddress); + Ipv4StaticRoutingHelper ipv4RoutingHelper; + Ptr staticRouting = ipv4RoutingHelper.GetStaticRouting (ipv4MN); + uint32_t i; + for (i = 0; i < staticRouting->GetNRoutes (); i++) + { + if (staticRouting->GetRoute (i).GetGateway () == m_gateway) + { + staticRouting->RemoveRoute (i); + break; + } + } + StartApplication (); +} + +} // Namespace ns3 diff --git a/src/internet-apps/model/dhcp-client.h b/src/internet-apps/model/dhcp-client.h new file mode 100644 index 00000000000..7c155239175 --- /dev/null +++ b/src/internet-apps/model/dhcp-client.h @@ -0,0 +1,195 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#ifndef DHCP_CLIENT_H +#define DHCP_CLIENT_H + +#include "ns3/application.h" +#include "ns3/event-id.h" +#include "ns3/ptr.h" +#include "ns3/ipv4-address.h" +#include "ns3/random-variable-stream.h" +#include "ns3/traced-value.h" +#include "dhcp-header.h" +#include + +namespace ns3 { + +class Socket; +class Packet; + +/** + * \ingroup dhcp + * + * \class DhcpClient + * \brief Implements the functionality of a DHCP client + */ +class DhcpClient : public Application +{ +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId + GetTypeId (void); + + DhcpClient (); + virtual ~DhcpClient (); + + /** + * \brief Constructor + * \param netDevice the NetDevice DHCP should work on + */ + DhcpClient (Ptr netDevice); + + /** + * \brief Get the the NetDevice DHCP should work on + * \return the NetDevice DHCP should work on + */ + Ptr GetDhcpClientNetDevice (void); + + /** + * \brief Set the NetDevice DHCP should work on + * \param netDevice the NetDevice DHCP should work on + */ + void SetDhcpClientNetDevice (Ptr netDevice); + + /** + * \brief Get the IPv4Address of current DHCP server + * \return Ipv4Address of current DHCP server + */ + Ipv4Address GetDhcpServer (void); + + /** + * Assign a fixed random variable stream number to the random variables + * used by this model. Return the number of streams (possibly zero) that + * have been assigned. + * + * \param stream First stream index to use + * \return the number of stream indices assigned by this model + */ + int64_t AssignStreams (int64_t stream); + +protected: + virtual void DoDispose (void); + +private: + enum States + { + WAIT_OFFER = 1, //!< State of a client that waits for the offer + REFRESH_LEASE = 2, //!< State of a client that needs to refresh the lease + WAIT_ACK = 9 //!< State of a client that waits for acknowledgment + }; + + static const int DHCP_PEER_PORT = 67; //!< DHCP server port + + /* + * \brief Starts the DHCP client application + */ + virtual void StartApplication (void); + + /* + * \brief Stops the DHCP client application + */ + virtual void StopApplication (void); + + /* + * \brief Handles changes in LinkState + */ + void LinkStateHandler (void); + + /* + * \brief Handles incoming packets from the network + * \param socket Socket bound to port 68 of the DHCP client + */ + void NetHandler (Ptr socket); + + /* + * \brief Sends DHCP DISCOVER and changes the client state to WAIT_OFFER + */ + void Boot (void); + + /* + * \brief Stores DHCP offers in m_offerList + * \param header DhcpHeader of the DHCP OFFER message + */ + void OfferHandler (DhcpHeader header); + + /* + * \brief Selects an OFFER from m_offerList + */ + void Select (void); + + /* + * \brief Sends the DHCP REQUEST message and changes the client state to WAIT_ACK + */ + void Request (void); + + /* + * \brief Receives the DHCP ACK and configures IP address of the client. + * It also triggers the timeout, renew and rebind events. + * \param header DhcpHeader of the DHCP ACK message + * \param from Address of DHCP server that sent the DHCP ACK + */ + void AcceptAck (DhcpHeader header, Address from); + + /* + * \brief Remove the current DHCP information and restart the process + */ + void RemoveAndStart (); + + uint8_t m_state; //!< State of the DHCP client + Ptr m_device; //!< NetDevice pointer + Ptr m_socket; //!< Socket for remote communication + Ipv4Address m_remoteAddress; //!< Initially set to 255.255.255.255 to start DHCP + Ipv4Address m_offeredAddress; //!< Address offered to the client + Ipv4Address m_myAddress; //!< Address assigned to the client + Address m_chaddr; //!< chaddr of the interface (stored as an Address for convenience). + Ipv4Mask m_myMask; //!< Mask of the address assigned + Ipv4Address m_server; //!< Address of the DHCP server + Ipv4Address m_gateway; //!< Address of the gateway + EventId m_requestEvent; //!< Address refresh event + EventId m_discoverEvent; //!< Message retransmission event + EventId m_refreshEvent; //!< Message refresh event + EventId m_rebindEvent; //!< Message rebind event + EventId m_nextOfferEvent; //!< Message next offer event + EventId m_timeout; //!< The timeout period + Time m_lease; //!< Store the lease time of address + Time m_renew; //!< Store the renew time of address + Time m_rebind; //!< Store the rebind time of address + Time m_nextoffer; //!< Time to try the next offer (if request gets no reply) + Ptr m_ran; //!< Uniform random variable for transaction ID + Time m_rtrs; //!< Defining the time for retransmission + Time m_collect; //!< Time for which client should collect offers + bool m_offered; //!< Specify if the client has got any offer + std::list m_offerList; //!< Stores all the offers given to the client + uint32_t m_tran; //!< Stores the current transaction number to be used + TracedCallback m_newLease;//!< Trace of new lease + TracedCallback m_expiry; //!< Trace of lease expire +}; + +} // namespace ns3 + +#endif /* DHCP_CLIENT_H */ diff --git a/src/internet-apps/model/dhcp-header.cc b/src/internet-apps/model/dhcp-header.cc new file mode 100644 index 00000000000..892d3cbb6a4 --- /dev/null +++ b/src/internet-apps/model/dhcp-header.cc @@ -0,0 +1,517 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#include "ns3/assert.h" +#include "ns3/log.h" +#include "ns3/header.h" +#include "ns3/simulator.h" +#include "dhcp-header.h" +#include "ns3/address-utils.h" + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("DhcpHeader"); +NS_OBJECT_ENSURE_REGISTERED (DhcpHeader); + +DhcpHeader::DhcpHeader () +{ + m_hType = 1; + m_hLen = 6; + m_xid = 0; + m_secs = 0; + m_hops = 0; + m_flags = 0; + Ipv4Address addr = Ipv4Address ("0.0.0.0"); + m_yiAddr = addr; + m_ciAddr = addr; + m_siAddr = addr; + m_giAddr = addr; + m_dhcps = addr; + m_req = addr; + m_route = addr; + m_len = 240; + + uint32_t i; + + for (i = 0; i < 64; i++) + { + m_sname[i] = 0; + } + for (i = 0; i < 128; i++) + { + m_file[i] = 0; + } + m_magic_cookie[0] = 99; + m_magic_cookie[1] = 130; + m_magic_cookie[2] = 83; + m_magic_cookie[3] = 99; +} + +DhcpHeader::~DhcpHeader () +{ +} + +void DhcpHeader::SetType (uint8_t type) +{ + if (m_opt[OP_MSGTYPE] == false) + { + m_len += 3; + m_opt[OP_MSGTYPE] = true; + } + m_op = type; + m_bootp = (m_op == 0||m_op == 2) ? 1 : 2; +} + +uint8_t DhcpHeader::GetType (void) const +{ + return m_op; +} + +void DhcpHeader::SetHWType (uint8_t htype, uint8_t hlen) +{ + m_hType = htype; + m_hLen = hlen; +} + +void DhcpHeader::SetTran (uint32_t tran) +{ + m_xid = tran; +} + +uint32_t DhcpHeader::GetTran (void) const +{ + return m_xid; +} + +void DhcpHeader::SetTime () +{ + m_secs = (uint16_t) Simulator::Now ().GetSeconds (); +} + +void DhcpHeader::SetChaddr (Address addr) +{ + std::memset (m_chaddr, 0, 16); + NS_ASSERT_MSG (addr.GetLength () <= 16, "Address length too big"); + addr.CopyTo (m_chaddr); +} + +void DhcpHeader::SetChaddr (uint8_t* addr, uint8_t len) +{ + std::memset (m_chaddr, 0, 16); + NS_ASSERT_MSG (len <= 16, "Address length too big"); + std::memcpy (m_chaddr, addr, len); +} + +Address DhcpHeader::GetChaddr () +{ + Address addr; + addr.CopyFrom (m_chaddr, 16); + return addr; +} + +void DhcpHeader::SetYiaddr (Ipv4Address addr) +{ + m_yiAddr = addr; +} + +Ipv4Address DhcpHeader::GetYiaddr (void) const +{ + return m_yiAddr; +} + +void DhcpHeader::SetDhcps (Ipv4Address addr) +{ + if (m_opt[OP_SERVID] == false) + { + m_len += 6; + m_opt[OP_SERVID] = true; + } + m_dhcps = addr; +} + +Ipv4Address DhcpHeader::GetDhcps (void) const +{ + return m_dhcps; +} + +void DhcpHeader::SetReq (Ipv4Address addr) +{ + if (m_opt[OP_ADDREQ] == false) + { + m_len += 6; + m_opt[OP_ADDREQ] = true; + } + m_req = addr; +} + +Ipv4Address DhcpHeader::GetReq (void) const +{ + return m_req; +} + +void DhcpHeader::SetMask (uint32_t addr) +{ + if (m_opt[OP_MASK] == false) + { + m_len += 6; + m_opt[OP_MASK] = true; + } + m_mask = addr; +} + +uint32_t DhcpHeader::GetMask (void) const +{ + return m_mask; +} + +void DhcpHeader::SetRouter (Ipv4Address addr) +{ + if (m_opt[OP_ROUTE] == false) + { + m_len += 6; + m_opt[OP_ROUTE] = true; + } + m_route = addr; +} + +Ipv4Address DhcpHeader::GetRouter (void) const +{ + return m_route; +} + +void DhcpHeader::SetLease (uint32_t time) +{ + if (m_opt[OP_LEASE] == false) + { + m_len += 6; + m_opt[OP_LEASE] = true; + } + m_lease = time; +} + +uint32_t DhcpHeader::GetLease (void) const +{ + return m_lease; +} + +void DhcpHeader::SetRenew (uint32_t time) +{ + if (m_opt[OP_RENEW] == false) + { + m_len += 6; + m_opt[OP_RENEW] = true; + } + m_renew = time; +} + +uint32_t DhcpHeader::GetRenew (void) const +{ + return m_renew; +} + +void DhcpHeader::SetRebind (uint32_t time) +{ + if (m_opt[OP_REBIND] == false) + { + m_len += 6; + m_opt[OP_REBIND] = true; + } + m_rebind = time; +} + +uint32_t DhcpHeader::GetRebind (void) const +{ + return m_rebind; +} + +void DhcpHeader::ResetOpt () +{ + m_len = 241; + int i; + for (i = 0; i < OP_END; i++) + { + m_opt[i] = false; + } +} + +uint32_t DhcpHeader::GetSerializedSize (void) const +{ + return m_len; +} + +TypeId DhcpHeader::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::DhcpHeader") + .SetParent
        () + .SetGroupName ("Internet-Apps") + .AddConstructor () + ; + return tid; +} + +TypeId DhcpHeader::GetInstanceTypeId (void) const +{ + return GetTypeId (); +} + +void DhcpHeader::Print (std::ostream &os) const +{ + os << "(type=" << m_op << ")"; +} + +void +DhcpHeader::Serialize (Buffer::Iterator start) const +{ + Buffer::Iterator i = start; + i.WriteU8 (m_bootp); + i.WriteU8 (m_hType); + i.WriteU8 (m_hLen); + i.WriteU8 (m_hops); + i.WriteU32 (m_xid); + i.WriteHtonU16 (m_secs); + i.WriteU16 ( m_flags); + WriteTo (i, m_ciAddr); + WriteTo (i, m_yiAddr); + WriteTo (i, m_siAddr); + WriteTo (i, m_giAddr); + i.Write (m_chaddr, 16); + i.Write (m_sname,64); + i.Write (m_file,128); + i.Write (m_magic_cookie,4); + if (m_opt[OP_MASK]) + { + i.WriteU8 (OP_MASK); + i.WriteU8 (4); + i.WriteHtonU32 (m_mask); + } + if (m_opt[OP_MSGTYPE]) + { + i.WriteU8 (OP_MSGTYPE); + i.WriteU8 (1); + i.WriteU8 ((m_op + 1)); + } + if (m_opt[OP_ADDREQ]) + { + i.WriteU8 (OP_ADDREQ); + i.WriteU8 (4); + WriteTo (i, m_req); + } + if (m_opt[OP_SERVID]) + { + i.WriteU8 (OP_SERVID); + i.WriteU8 (4); + WriteTo (i, m_dhcps); + } + if (m_opt[OP_ROUTE]) + { + i.WriteU8 (OP_ROUTE); + i.WriteU8 (4); + WriteTo (i, m_route); + } + if (m_opt[OP_LEASE]) + { + i.WriteU8 (OP_LEASE); + i.WriteU8 (4); + i.WriteHtonU32 (m_lease); + } + if (m_opt[OP_RENEW]) + { + i.WriteU8 (OP_RENEW); + i.WriteU8 (4); + i.WriteHtonU32 (m_renew); + } + if (m_opt[OP_REBIND]) + { + i.WriteU8 (OP_REBIND); + i.WriteU8 (4); + i.WriteHtonU32 (m_rebind); + } + i.WriteU8 (OP_END); +} + +uint32_t DhcpHeader::Deserialize (Buffer::Iterator start) +{ + uint32_t len, clen = start.GetSize (); + if (clen < 240) + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + Buffer::Iterator i = start; + m_bootp = i.ReadU8 (); + m_hType = i.ReadU8 (); + m_hLen = i.ReadU8 (); + m_hops = i.ReadU8 (); + m_xid = i.ReadU32 (); + m_secs = i.ReadNtohU16 (); + m_flags = i.ReadU16 (); + ReadFrom (i, m_ciAddr); + ReadFrom (i, m_yiAddr); + ReadFrom (i, m_siAddr); + ReadFrom (i, m_giAddr); + i.Read (m_chaddr, 16); + i.Read (m_sname, 64); + i.Read (m_file, 128); + i.Read (m_magic_cookie, 4); + if ( m_magic_cookie[0] != 99 || m_magic_cookie[1] != 130 || m_magic_cookie[2] != 83 || m_magic_cookie[3] != 99) + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + len = 240; + uint8_t option; + bool loop = true; + do + { + if (len + 1 <= clen) + { + option = i.ReadU8 (); + len += 1; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + switch (option) + { + case OP_MASK: + if (len + 5 < clen) + { + i.ReadU8 (); + m_mask = i.ReadNtohU32 (); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_ROUTE: + if (len + 5 < clen) + { + i.ReadU8 (); + ReadFrom (i, m_route); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_MSGTYPE: + if (len + 2 < clen) + { + i.ReadU8 (); + m_op = (i.ReadU8 () - 1); + len += 2; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_SERVID: + if (len + 5 < clen) + { + i.ReadU8 (); + ReadFrom (i, m_dhcps); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_ADDREQ: + if (len + 5 < clen) + { + i.ReadU8 (); + ReadFrom (i, m_req); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_LEASE: + if (len + 5 < clen) + { + i.ReadU8 (); + m_lease = i.ReadNtohU32 (); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_RENEW: + if (len + 5 < clen) + { + i.ReadU8 (); + m_renew = i.ReadNtohU32 (); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_REBIND: + if (len + 5 < clen) + { + i.ReadU8 (); + m_rebind = i.ReadNtohU32 (); + len += 5; + } + else + { + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + break; + case OP_END: + loop = false; + break; + default: + NS_LOG_WARN ("Malformed Packet"); + return 0; + } + } + while (loop); + + m_len = len; + return m_len; +} + +} // namespace ns3 diff --git a/src/internet-apps/model/dhcp-header.h b/src/internet-apps/model/dhcp-header.h new file mode 100644 index 00000000000..0b8b0356cfa --- /dev/null +++ b/src/internet-apps/model/dhcp-header.h @@ -0,0 +1,322 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#ifndef DHCP_HEADER_H +#define DHCP_HEADER_H + +#include "ns3/header.h" +#include +#include + +namespace ns3 { + +/** + * \ingroup internet-apps + * \defgroup dhcp DHCPv4 Client and Server + */ + +/** + * \ingroup dhcp + * + * \class DhcpHeader + * \brief BOOTP header with DHCP messages supports the following options: + * Subnet Mask (1), Address Request (50), Refresh Lease Time (51), + * DHCP Message Type (53), DHCP Server ID (54), Renew Time (58), + * Rebind Time (59) and End (255) of BOOTP + + \verbatim + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | op (1) | htype (1) | hlen (1) | hops (1) | + +---------------+---------------+---------------+---------------+ + | xid (4) | + +-------------------------------+-------------------------------+ + | secs (2) | flags (2) | + +-------------------------------+-------------------------------+ + | ciaddr (4) | + +---------------------------------------------------------------+ + | yiaddr (4) | + +---------------------------------------------------------------+ + | siaddr (4) | + +---------------------------------------------------------------+ + | giaddr (4) | + +---------------------------------------------------------------+ + | | + | chaddr (16) | + | | + | | + +---------------------------------------------------------------+ + | | + | sname (64) | + +---------------------------------------------------------------+ + | | + | file (128) | + +---------------------------------------------------------------+ + | | + | options (variable) | + +---------------------------------------------------------------+ + \endverbatim + + */ +class DhcpHeader : public Header +{ +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + + /** + * \brief Constructor + */ + DhcpHeader (); + + /** + * \brief Destructor + */ + ~DhcpHeader (); + + enum Options + { + OP_MASK = 1, //!< BOOTP Option 1: Address Mask + OP_ROUTE = 3, //!< BOOTP Option 3: Router Option + OP_ADDREQ = 50, //!< BOOTP Option 50: Requested Address + OP_LEASE = 51, //!< BOOTP Option 51: Address Lease Time + OP_MSGTYPE = 53, //!< BOOTP Option 53: DHCP Message Type + OP_SERVID = 54, //!< BOOTP Option 54: Server Identifier + OP_RENEW = 58, //!< BOOTP Option 58: Address Renewal Time + OP_REBIND = 59, //!< BOOTP Option 59: Address Rebind Time + OP_END = 255 //!< BOOTP Option 255: END + }; + + enum Messages + { + DHCPDISCOVER = 0, //!< Code for DHCP Discover + DHCPOFFER = 1, //!< Code for DHCP Offer + DHCPREQ = 2, //!< Code for DHCP Request + DHCPACK = 4, //!< Code for DHCP ACK + DHCPNACK = 5 //!< Code for DHCP NACK + }; + + /** + * \brief Set the type of BOOTP and DHCP messages + * \param type The type of message + */ + void SetType (uint8_t type); + + /** + * \brief Return the type of DHCP message + * \return The type of message + */ + uint8_t GetType (void) const; + + /** + * \brief Set the hardware information + * \param htype Hardware type + * \param hlen Hardware length + */ + void SetHWType (uint8_t htype, uint8_t hlen); + + /** + * \brief Set the transaction ID + * \param tran The transaction number + */ + void SetTran (uint32_t tran); + + /** + * \brief Get the transaction id + * \return The transaction id + */ + uint32_t GetTran (void) const; + + /** + * \brief Set the time when message is sent + */ + void SetTime (); + + /** + * \brief Set the Address of the device. + * + * Only the relevant bits are considered (i.e., not the type and length) + * + * \param addr Address of the device + */ + void SetChaddr (Address addr); + + /** + * \brief Set the Address of the device + * \param addr Address of the device + * \param len Address length + */ + void SetChaddr (uint8_t* addr, uint8_t len); + + /** + * \brief Get the Address of the client. + * + * Note: the address is always 16-bytes long. + * + * \return Address of the client + */ + Address GetChaddr (void); + + /** + * \brief Set the IPv4Address of the client + * \param addr The client Ipv4Address + */ + void SetYiaddr (Ipv4Address addr); + + /** + * \brief Get the IPv4Address of the client + * \return IPv4Address of the client + */ + Ipv4Address GetYiaddr (void) const; + + /** + * \brief Set the DHCP server information + * \param addr IPv4Address of the server + */ + void SetDhcps (Ipv4Address addr); + + /** + * \brief Get the information about the DHCP server + * \return IPv4Address of DHCP server + */ + Ipv4Address GetDhcps (void) const; + + /** + * \brief Set the Ipv4Address requested by the client + * \param addr Ipv4Address requested by the client + */ + void SetReq (Ipv4Address addr); + + /** + * \brief Get the IPv4Address requested by the client + * \return IPv4Address requested by the client + */ + Ipv4Address GetReq (void) const; + + /** + * \brief Set the mask of the IPv4Address + * \param addr 32 bit mask + */ + void SetMask (uint32_t addr); + + /** + * \brief Return the mask of the network + * \return 32 bit mask + */ + uint32_t GetMask (void) const; + + /** + * \brief Set the Ipv4Address of gateway to be used + * \param addr The Ipv4Address of the gateway + */ + void SetRouter (Ipv4Address addr); + + /** + * \brief Return the Ipv4Address of gateway to be used + * \return The Ipv4Address of the gateway + */ + Ipv4Address GetRouter (void) const; + + /** + * \brief Set the lease time of the IPv4Address + * \param time 32 bit time + */ + void SetLease (uint32_t time); + + /** + * \brief Return the lease time of the IPv4Address + * \return 32 bit time + */ + uint32_t GetLease (void) const; + + /** + * \brief Set the Renewal time of the IPv4Address + * \param time 32 bit time + */ + void SetRenew (uint32_t time); + + /** + * \brief Return the Renewal time of the address + * \return 32 bit time + */ + uint32_t GetRenew (void) const; + + /** + * \brief Set the Rebind time of the IPv4Address + * \param time 32 bit time + */ + void SetRebind (uint32_t time); + + /** + * \brief Return the Rebind time of the address + * \return 32 bit time + */ + uint32_t GetRebind (void) const; + + /** + * \brief Reset the BOOTP options + */ + void ResetOpt (); + +private: + virtual TypeId GetInstanceTypeId (void) const; + virtual void Print (std::ostream &os) const; + virtual uint32_t GetSerializedSize (void) const; + virtual void Serialize (Buffer::Iterator start) const; + virtual uint32_t Deserialize (Buffer::Iterator start); + + uint8_t m_op; //!< The DHCP Message type + uint8_t m_bootp; //!< The BOOTP Message type + uint8_t m_hType; //!< The hardware type + uint8_t m_hLen; //!< The hardware length + uint8_t m_hops; //!< The number of hops covered by the message + uint32_t m_xid; //!< The transaction number + uint32_t m_mask; //!< The mask of the network + uint32_t m_len; //!< The length of the header + uint16_t m_secs; //!< Seconds elapsed + uint16_t m_flags; //!< BOOTP flags + uint8_t m_chaddr[16]; //!< The address identifier + Ipv4Address m_yiAddr; //!< Your (client) IP address + Ipv4Address m_ciAddr; //!< The IP address of the client + Ipv4Address m_siAddr; //!< Next Server IP address + Ipv4Address m_giAddr; //!< Relay Agent IP address + Ipv4Address m_dhcps; //!< DHCP server IP address + Ipv4Address m_req; //!< Requested Address + Ipv4Address m_route; //!< Router Option Address + uint8_t m_sname[64]; //!< Server name (Padded for now) + uint8_t m_file[128]; //!< File name (Padded for now) + uint8_t m_magic_cookie[4]; //!< DHCP Magic Cookie + uint32_t m_lease; //!< The lease time of the address + uint32_t m_renew; //!< The renewal time for the client + uint32_t m_rebind; //!< The rebinding time for the client + bool m_opt[255]; //!< BOOTP option list +}; + +} // namespace ns3 + +#endif /* DHCP_HEADER_H */ diff --git a/src/internet-apps/model/dhcp-server.cc b/src/internet-apps/model/dhcp-server.cc new file mode 100644 index 00000000000..b4671fb0a4d --- /dev/null +++ b/src/internet-apps/model/dhcp-server.cc @@ -0,0 +1,421 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#include "ns3/log.h" +#include "ns3/assert.h" +#include "ns3/ipv4-address.h" +#include "ns3/nstime.h" +#include "ns3/inet-socket-address.h" +#include "ns3/ipv4-packet-info-tag.h" +#include "ns3/socket.h" +#include "ns3/simulator.h" +#include "ns3/socket-factory.h" +#include "ns3/packet.h" +#include "ns3/uinteger.h" +#include "ns3/config.h" +#include "dhcp-server.h" +#include "dhcp-header.h" +#include "ns3/ipv4.h" +#include + +namespace ns3 { + +NS_LOG_COMPONENT_DEFINE ("DhcpServer"); +NS_OBJECT_ENSURE_REGISTERED (DhcpServer); + +TypeId +DhcpServer::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::DhcpServer") + .SetParent () + .AddConstructor () + .SetGroupName ("Internet-Apps") + .AddAttribute ("LeaseTime", + "Lease for which address will be leased.", + TimeValue (Seconds (30)), + MakeTimeAccessor (&DhcpServer::m_lease), + MakeTimeChecker ()) + .AddAttribute ("RenewTime", + "Time after which client should renew.", + TimeValue (Seconds (15)), + MakeTimeAccessor (&DhcpServer::m_renew), + MakeTimeChecker ()) + .AddAttribute ("RebindTime", + "Time after which client should rebind.", + TimeValue (Seconds (25)), + MakeTimeAccessor (&DhcpServer::m_rebind), + MakeTimeChecker ()) + .AddAttribute ("PoolAddresses", + "Pool of addresses to provide on request.", + Ipv4AddressValue (), + MakeIpv4AddressAccessor (&DhcpServer::m_poolAddress), + MakeIpv4AddressChecker ()) + .AddAttribute ("FirstAddress", + "The First valid address that can be given.", + Ipv4AddressValue (), + MakeIpv4AddressAccessor (&DhcpServer::m_minAddress), + MakeIpv4AddressChecker ()) + .AddAttribute ("LastAddress", + "The Last valid address that can be given.", + Ipv4AddressValue (), + MakeIpv4AddressAccessor (&DhcpServer::m_maxAddress), + MakeIpv4AddressChecker ()) + .AddAttribute ("PoolMask", + "Mask of the pool of addresses.", + Ipv4MaskValue (), + MakeIpv4MaskAccessor (&DhcpServer::m_poolMask), + MakeIpv4MaskChecker ()) + .AddAttribute ("Gateway", + "Address of default gateway", + Ipv4AddressValue (), + MakeIpv4AddressAccessor (&DhcpServer::m_gateway), + MakeIpv4AddressChecker ()) + ; + return tid; +} + +DhcpServer::DhcpServer () +{ + NS_LOG_FUNCTION (this); +} + +DhcpServer::~DhcpServer () +{ + NS_LOG_FUNCTION (this); +} + +void +DhcpServer::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + Application::DoDispose (); +} + +void DhcpServer::StartApplication (void) +{ + NS_LOG_FUNCTION (this); + + NS_ASSERT_MSG (m_minAddress < m_maxAddress,"Invalid Address range"); + + Ipv4Address myOwnAddress; + + if (m_socket) + { + NS_ABORT_MSG ("DHCP daemon is not (yet) meant to be started twice or more."); + } + + uint32_t addrIndex; + + //add the DHCP local address to the leased addresses list, if it is defined! + Ptr ipv4 = GetNode ()->GetObject (); + int32_t ifIndex = ipv4->GetInterfaceForPrefix (m_poolAddress, m_poolMask); + + if (ifIndex < 0) + { + NS_ABORT_MSG ("DHCP daemon must be run on the same subnet it is assigning the addresses."); + } + + for (addrIndex = 0; addrIndex < ipv4->GetNAddresses (ifIndex); addrIndex++) + { + if (ipv4->GetAddress (ifIndex, addrIndex).GetLocal ().CombineMask (m_poolMask) == m_poolAddress && + ipv4->GetAddress (ifIndex, addrIndex).GetLocal ().Get () >= m_minAddress.Get () && + ipv4->GetAddress (ifIndex, addrIndex).GetLocal ().Get () <= m_maxAddress.Get ()) + { + // set infinite GRANTED_LEASED_TIME for my address + + myOwnAddress = ipv4->GetAddress (ifIndex, addrIndex).GetLocal (); + m_leasedAddresses[Address ()] = std::make_pair (myOwnAddress, 0xffffffff); + break; + } + } + + TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory"); + m_socket = Socket::CreateSocket (GetNode (), tid); + InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), PORT); + m_socket->SetAllowBroadcast (true); + m_socket->Bind (local); + m_socket->BindToNetDevice (ipv4->GetNetDevice (ifIndex)); + m_socket->SetRecvPktInfo (true); + + uint32_t range = m_maxAddress.Get () - m_minAddress.Get () + 1; + for (uint32_t searchSeq = 0; searchSeq < range; searchSeq ++) + { + Ipv4Address poolAddress = Ipv4Address (m_minAddress.Get () + searchSeq); + if (poolAddress != myOwnAddress) + { + NS_LOG_LOGIC ("Adding " << poolAddress << " to the pool"); + m_availableAddresses.push_back (poolAddress); + } + } + + m_socket->SetRecvCallback (MakeCallback (&DhcpServer::NetHandler, this)); + m_expiredEvent = Simulator::Schedule (Seconds (1), &DhcpServer::TimerHandler, this); +} + +void DhcpServer::StopApplication () +{ + NS_LOG_FUNCTION (this); + + if (m_socket != 0) + { + m_socket->SetRecvCallback (MakeNullCallback > ()); + } + + m_leasedAddresses.clear (); + Simulator::Remove (m_expiredEvent); +} + +void DhcpServer::TimerHandler () +{ + NS_LOG_FUNCTION (this); + + // Set up timeout events and release of unsolicited addresses from the list + LeasedAddressIter i; + for (i = m_leasedAddresses.begin (); i != m_leasedAddresses.end (); i++) + { + // update the address state + if (i->second.second != 0xffffffff && i->second.second != 0) + { + i->second.second--; + if (i->second.second == 0) + { + NS_LOG_INFO ("Address leased state expired, address removed - " << + "chaddr: " << i->first << + "IP address " << i->second.first); + i->second.second = 0; + m_expiredAddresses.push_front (i->first); + } + } + } + m_expiredEvent = Simulator::Schedule (Seconds (1), &DhcpServer::TimerHandler, this); +} + +void DhcpServer::NetHandler (Ptr socket) +{ + NS_LOG_FUNCTION (this << socket); + + DhcpHeader header; + Ptr packet = 0; + Address from; + packet = m_socket->RecvFrom (from); + + InetSocketAddress senderAddr = InetSocketAddress::ConvertFrom (from); + + Ipv4PacketInfoTag interfaceInfo; + if (!packet->RemovePacketTag (interfaceInfo)) + { + NS_ABORT_MSG ("No incoming interface on DHCP message, aborting."); + } + uint32_t incomingIf = interfaceInfo.GetRecvIf (); + Ptr iDev = GetNode ()->GetDevice (incomingIf); + + if (packet->RemoveHeader (header) == 0) + { + return; + } + if (header.GetType () == DhcpHeader::DHCPDISCOVER) + { + SendOffer (iDev, header, senderAddr); + } + if (header.GetType () == DhcpHeader::DHCPREQ && (header.GetReq ()).Get () >= m_minAddress.Get () && (header.GetReq ()).Get () <= m_maxAddress.Get ()) + { + SendAck (iDev, header, senderAddr); + } +} + +void DhcpServer::SendOffer (Ptr iDev, DhcpHeader header, InetSocketAddress from) +{ + NS_LOG_FUNCTION (this << iDev << header << from); + + DhcpHeader newDhcpHeader; + Address sourceChaddr = header.GetChaddr (); + uint32_t tran = header.GetTran (); + Ptr packet = 0; + bool found = false; + Ipv4Address offeredAddress; + + NS_LOG_INFO ("DHCP DISCOVER from: " << from.GetIpv4 () << " source port: " << from.GetPort ()); + + LeasedAddressIter iter = m_leasedAddresses.find (sourceChaddr); + if (iter != m_leasedAddresses.end ()) + { + // We know this client from some time ago + if (m_leasedAddresses[sourceChaddr].second != 0 && m_leasedAddresses[sourceChaddr].second != 0xffffffff) + { + NS_LOG_LOGIC ("This client is sending a DISCOVER but it has still a lease active - perhaps it didn't shut down gracefully: " << sourceChaddr); + } + + m_expiredAddresses.remove (sourceChaddr); + offeredAddress = m_leasedAddresses[sourceChaddr].first; + + } + else + { + // No previous record of the client, we must find a suitable address and create a record. + if (!m_availableAddresses.empty ()) + { + // use an address never used before (if there is one) + found = true; + offeredAddress = m_availableAddresses.front (); + m_availableAddresses.pop_front (); + } + else + { + // there's still hope: reuse the old ones. + if (!m_expiredAddresses.empty ()) + { + Address oldestChaddr = m_expiredAddresses.back (); + m_expiredAddresses.pop_back (); + offeredAddress = m_leasedAddresses[oldestChaddr].first; + m_leasedAddresses.erase (oldestChaddr); + found = true; + } + } + } + + if (offeredAddress != Ipv4Address ()) + { + m_leasedAddresses[sourceChaddr] = std::make_pair (offeredAddress, m_lease.GetSeconds ()); + + packet = Create (); + newDhcpHeader.ResetOpt (); + newDhcpHeader.SetType (DhcpHeader::DHCPOFFER); + newDhcpHeader.SetChaddr (sourceChaddr); + newDhcpHeader.SetYiaddr (offeredAddress); + + Ptr ipv4 = GetNode ()->GetObject (); + Ipv4Address myAddress = ipv4->SelectSourceAddress (iDev, offeredAddress, Ipv4InterfaceAddress::InterfaceAddressScope_e::GLOBAL); + + newDhcpHeader.SetDhcps (myAddress); + newDhcpHeader.SetMask (m_poolMask.Get ()); + newDhcpHeader.SetTran (tran); + newDhcpHeader.SetLease (m_lease.GetSeconds ()); + newDhcpHeader.SetRenew (m_renew.GetSeconds ()); + newDhcpHeader.SetRebind (m_rebind.GetSeconds ()); + newDhcpHeader.SetTime (); + if (m_gateway != Ipv4Address ()) + { + newDhcpHeader.SetRouter (m_gateway); + } + packet->AddHeader (newDhcpHeader); + + if ((m_socket->SendTo (packet, 0, InetSocketAddress (Ipv4Address ("255.255.255.255"), from.GetPort ()))) >= 0) + { + NS_LOG_INFO ("DHCP OFFER" << " Offered Address: " << offeredAddress); + } + else + { + NS_LOG_INFO ("Error while sending DHCP OFFER"); + } + } +} + +void DhcpServer::SendAck (Ptr iDev, DhcpHeader header, InetSocketAddress from) +{ + NS_LOG_FUNCTION (this << iDev << header << from); + + DhcpHeader newDhcpHeader; + Address sourceChaddr = header.GetChaddr (); + uint32_t tran = header.GetTran (); + Ptr packet = 0; + Ipv4Address address = header.GetReq (); + + NS_LOG_INFO ("DHCP REQUEST from: " << from.GetIpv4 () << + " source port: " << from.GetPort () << + " - refreshed addr: " << address); + + LeasedAddressIter iter; + iter = m_leasedAddresses.find (sourceChaddr); + if (iter != m_leasedAddresses.end ()) + { + // update the lease time of this address - send ACK + (iter->second.second) += m_lease.GetSeconds (); + packet = Create (); + newDhcpHeader.ResetOpt (); + newDhcpHeader.SetType (DhcpHeader::DHCPACK); + newDhcpHeader.SetChaddr (sourceChaddr); + newDhcpHeader.SetYiaddr (address); + newDhcpHeader.SetTran (tran); + newDhcpHeader.SetTime (); + packet->AddHeader (newDhcpHeader); + if (from.GetIpv4 () != address) + { + m_socket->SendTo (packet, 0, InetSocketAddress (Ipv4Address ("255.255.255.255"), from.GetPort ())); + } + else + { + m_socket->SendTo (packet, 0, from); + } + } + else + { + // Deleted or expired lease - send NACK + packet = Create (); + newDhcpHeader.ResetOpt (); + newDhcpHeader.SetType (DhcpHeader::DHCPNACK); + newDhcpHeader.SetChaddr (sourceChaddr); + newDhcpHeader.SetYiaddr (address); + newDhcpHeader.SetTran (tran); + newDhcpHeader.SetTime (); + packet->AddHeader (newDhcpHeader); + if (from.GetIpv4 () != address) + { + m_socket->SendTo (packet, 0, InetSocketAddress (Ipv4Address ("255.255.255.255"), from.GetPort ())); + } + else + { + m_socket->SendTo (packet, 0, from); + } + NS_LOG_INFO ("IP addr does not exists or released!"); + } +} + +void DhcpServer::AddStaticDhcpEntry (Address chaddr, Ipv4Address addr) +{ + NS_LOG_FUNCTION (this << chaddr << addr); + Address cleanedCaddr; + + NS_ASSERT_MSG (addr.Get () >= m_minAddress.Get () && addr.Get () <= m_maxAddress.Get (), + "Required address is not in the pool " << addr << " is not in [" << m_minAddress << ", " << m_maxAddress << "]"); + + // We need to cleanup the type from the stored chaddr, or later we'll fail to compare it. + // Moreover, the length is always 16, because chaddr is 16 bytes. + uint8_t buffer[Address::MAX_SIZE]; + std::memset (buffer, 0, Address::MAX_SIZE); + uint32_t len = chaddr.CopyTo (buffer); + NS_ASSERT_MSG (len <= 16, "DHCP server can not handle a chaddr larger than 16 bytes"); + cleanedCaddr.CopyFrom (buffer, 16); + + NS_ASSERT_MSG (m_leasedAddresses.find (cleanedCaddr) == m_leasedAddresses.end (), + "Client has already an active lease: " << m_leasedAddresses[cleanedCaddr].first); + + AvailableAddress::iterator it = find (m_availableAddresses.begin (), m_availableAddresses.end (), addr); + NS_ASSERT_MSG (it == m_availableAddresses.end (), + "Required address is not available (perhaps it has been already assigned): " << addr); + + m_availableAddresses.remove (addr); + m_leasedAddresses[cleanedCaddr] = std::make_pair (addr, 0xffffffff); +} + +} // Namespace ns3 diff --git a/src/internet-apps/model/dhcp-server.h b/src/internet-apps/model/dhcp-server.h new file mode 100644 index 00000000000..c9a3c5dec48 --- /dev/null +++ b/src/internet-apps/model/dhcp-server.h @@ -0,0 +1,147 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2011 UPB + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Radu Lupu + * Ankit Deepak + * Deepti Rajagopal + * + */ + +#ifndef DHCP_SERVER_H +#define DHCP_SERVER_H + +#include "ns3/application.h" +#include "ns3/event-id.h" +#include "ns3/ptr.h" +#include "ns3/address.h" +#include "ns3/traced-value.h" +#include "ns3/inet-socket-address.h" +#include "dhcp-header.h" +#include + +namespace ns3 { + +class Socket; +class Packet; + +/** + * \ingroup dhcp + * + * \class DhcpServer + * \brief Implements the functionality of a DHCP server + */ +class DhcpServer : public Application +{ +public: + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); + + DhcpServer (); + virtual ~DhcpServer (); + + /** + * \brief Add a static entry to the pool. + * + * \param chaddr The client chaddr. + * \param addr The address to handle to the client. + */ + void AddStaticDhcpEntry (Address chaddr, Ipv4Address addr); + + +protected: + virtual void DoDispose (void); + +private: + static const int PORT = 67; //!< Port number of DHCP server + + /* + * \brief Handles incoming packets from the network + * \param socket Socket bound to port 67 of the DHCP server + */ + void NetHandler (Ptr socket); + + /* + * \brief Sends DHCP offer after receiving DHCP Discover + * \param iDev incoming NetDevice + * \param header DHCP header of the received message + * \param from Address of the DHCP client + */ + void SendOffer (Ptr iDev, DhcpHeader header, InetSocketAddress from); + + /* + * \brief Sends DHCP ACK (or NACK) after receiving Request + * \param iDev incoming NetDevice + * \param header DHCP header of the received message + * \param from Address of the DHCP client + */ + void SendAck (Ptr iDev, DhcpHeader header, InetSocketAddress from); + + /* + * \brief Modifies the remaining lease time of addresses + */ + void TimerHandler (void); + + /* + * \brief Starts the DHCP Server application + */ + virtual void StartApplication (void); + + /* + * \brief Stops the DHCP client application + */ + virtual void StopApplication (void); + + Ptr m_socket; //!< The socket bound to port 67 + Ipv4Address m_poolAddress; //!< The network address available to the server + Ipv4Address m_minAddress; //!< The first address in the address pool + Ipv4Address m_maxAddress; //!< The last address in the address pool + Ipv4Mask m_poolMask; //!< The network mask of the pool + Ipv4Address m_gateway; //!< The gateway address + + /// Leased address container - chaddr + IP addr / lease time + typedef std::map > LeasedAddress; + /// Leased address iterator - chaddr + IP addr / lease time + typedef std::map >::iterator LeasedAddressIter; + /// Leased address const iterator - chaddr + IP addr / lease time + typedef std::map >::const_iterator LeasedAddressCIter; + + /// Expired address container - chaddr + typedef std::list
        ExpiredAddress; + /// Expired address iterator - chaddr + typedef std::list
        ::iterator ExpiredAddressIter; + /// Expired address const iterator - chaddr + typedef std::list
        ::const_iterator ExpiredAddressCIter; + + /// Available address container - IP addr + typedef std::list AvailableAddress; + + LeasedAddress m_leasedAddresses; //!< Leased address and their status (cache memory) + ExpiredAddress m_expiredAddresses; //!< Expired addresses to be reused (chaddr of the clients) + AvailableAddress m_availableAddresses; //!< Available addresses to be used (IP addresses) + Time m_lease; //!< The granted lease time for an address + Time m_renew; //!< The renewal time for an address + Time m_rebind; //!< The rebinding time for an address + EventId m_expiredEvent; //!< The Event to trigger TimerHandler +}; + +} // namespace ns3 + +#endif /* DHCP_SERVER_H */ diff --git a/src/internet-apps/test/dhcp-test.cc b/src/internet-apps/test/dhcp-test.cc new file mode 100644 index 00000000000..619088a868e --- /dev/null +++ b/src/internet-apps/test/dhcp-test.cc @@ -0,0 +1,162 @@ +/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 NITK Surathkal + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Authors: Ankit Deepak + * Deepti Rajagopal + * + */ + +#include "ns3/data-rate.h" +#include "ns3/simple-net-device.h" +#include "ns3/simple-net-device-helper.h" +#include "ns3/internet-stack-helper.h" +#include "ns3/ipv4-address-helper.h" +#include "ns3/dhcp-client.h" +#include "ns3/dhcp-server.h" +#include "ns3/dhcp-helper.h" +#include "ns3/test.h" + +using namespace ns3; + +/** + * \ingroup dhcp + * \defgroup dhcp-test DHCP module tests + */ + + +/** + * \ingroup dhcp-test + * \ingroup tests + * + * \brief DHCP basic tests + */ +class DhcpTestCase : public TestCase +{ +public: + DhcpTestCase (); + virtual ~DhcpTestCase (); + /** + * Triggered by an address lease on a client. + * \param newAddress The leased address. + */ + void LeaseObtained (std::string context, const Ipv4Address& newAddress); +private: + virtual void DoRun (void); + Ipv4Address m_leasedAddress[3]; //!< Address given to the nodes +}; + +DhcpTestCase::DhcpTestCase () + : TestCase ("Dhcp test case ") +{ +} + +DhcpTestCase::~DhcpTestCase () +{ +} + +void +DhcpTestCase::LeaseObtained (std::string context, const Ipv4Address& newAddress) +{ + uint8_t numericalContext = std::stoi (context, nullptr, 10); + + if (numericalContext >=0 && numericalContext <=2) + { + m_leasedAddress[numericalContext] = newAddress; + } +} + +void +DhcpTestCase::DoRun (void) +{ + /*Set up devices*/ + NodeContainer nodes; + NodeContainer routers; + nodes.Create (3); + routers.Create (1); + + NodeContainer net (routers, nodes); + + SimpleNetDeviceHelper simpleNetDevice; + simpleNetDevice.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2))); + simpleNetDevice.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("5Mbps"))); + NetDeviceContainer devNet = simpleNetDevice.Install (net); + + InternetStackHelper tcpip; + tcpip.Install (routers); + tcpip.Install (nodes); + + DhcpHelper dhcpHelper; + + ApplicationContainer dhcpServerApp = dhcpHelper.InstallDhcpServer (devNet.Get (0), Ipv4Address ("172.30.0.12"), + Ipv4Address ("172.30.0.0"), Ipv4Mask ("/24"), + Ipv4Address ("172.30.0.10"), Ipv4Address ("172.30.0.15"), + Ipv4Address ("172.30.0.17")); + dhcpServerApp.Start (Seconds (0.0)); + dhcpServerApp.Stop (Seconds (20.0)); + + DynamicCast (dhcpServerApp.Get (0))->AddStaticDhcpEntry (devNet.Get (3)->GetAddress (), Ipv4Address ("172.30.0.14")); + + NetDeviceContainer dhcpClientNetDevs; + dhcpClientNetDevs.Add (devNet.Get (1)); + dhcpClientNetDevs.Add (devNet.Get (2)); + dhcpClientNetDevs.Add (devNet.Get (3)); + + ApplicationContainer dhcpClientApps = dhcpHelper.InstallDhcpClient (dhcpClientNetDevs); + dhcpClientApps.Start (Seconds (1.0)); + dhcpClientApps.Stop (Seconds (20.0)); + + + dhcpClientApps.Get(0)->TraceConnect ("NewLease", "0", MakeCallback(&DhcpTestCase::LeaseObtained, this)); + dhcpClientApps.Get(1)->TraceConnect ("NewLease", "1", MakeCallback(&DhcpTestCase::LeaseObtained, this)); + dhcpClientApps.Get(2)->TraceConnect ("NewLease", "2", MakeCallback(&DhcpTestCase::LeaseObtained, this)); + + Simulator::Stop (Seconds (21.0)); + + Simulator::Run (); + + NS_TEST_ASSERT_MSG_EQ (m_leasedAddress[0], Ipv4Address ("172.30.0.10"), + m_leasedAddress[0] << " instead of " << "172.30.0.10"); + + NS_TEST_ASSERT_MSG_EQ (m_leasedAddress[1], Ipv4Address ("172.30.0.11"), + m_leasedAddress[1] << " instead of " << "172.30.0.11"); + + NS_TEST_ASSERT_MSG_EQ (m_leasedAddress[2], Ipv4Address ("172.30.0.14"), + m_leasedAddress[2] << " instead of " << "172.30.0.14"); + + Simulator::Destroy (); +} + +/** + * \ingroup dhcp-test + * \ingroup tests + * + * \brief DHCP TestSuite + */ +class DhcpTestSuite : public TestSuite +{ +public: + DhcpTestSuite (); +}; + +DhcpTestSuite::DhcpTestSuite () + : TestSuite ("dhcp", UNIT) +{ + AddTestCase (new DhcpTestCase, TestCase::QUICK); +} + +static DhcpTestSuite dhcpTestSuite; //!< Static variable for test initialization + diff --git a/src/internet-apps/wscript b/src/internet-apps/wscript index 0a3eebde4e7..67cc642e3bc 100644 --- a/src/internet-apps/wscript +++ b/src/internet-apps/wscript @@ -14,9 +14,18 @@ def build(bld): 'model/radvd-prefix.cc', 'model/radvd.cc', 'model/v4ping.cc', + 'model/dhcp-header.cc', + 'model/dhcp-server.cc', + 'model/dhcp-client.cc', 'helper/ping6-helper.cc', 'helper/radvd-helper.cc', 'helper/v4ping-helper.cc', + 'helper/dhcp-helper.cc', + ] + + applications_test = bld.create_ns3_module_test_library('internet-apps') + applications_test.source = [ + 'test/dhcp-test.cc', ] headers = bld(features='ns3header') @@ -27,11 +36,17 @@ def build(bld): 'model/radvd-interface.h', 'model/radvd-prefix.h', 'model/v4ping.h', + 'model/dhcp-header.h', + 'model/dhcp-server.h', + 'model/dhcp-client.h', 'helper/ping6-helper.h', 'helper/v4ping-helper.h', 'helper/radvd-helper.h', + 'helper/dhcp-helper.h', ] + if (bld.env['ENABLE_EXAMPLES']): + bld.recurse('examples') bld.ns3_python_bindings() diff --git a/src/internet/doc/ipv4.rst b/src/internet/doc/ipv4.rst index c240589d3ff..590456fb32f 100644 --- a/src/internet/doc/ipv4.rst +++ b/src/internet/doc/ipv4.rst @@ -11,6 +11,89 @@ IPv4 ---- +This chapter describes the |ns3| IPv4 address assignment and basic components tracking. + +IPv4 addresses assignment +************************* + +In order to use IPv4 on a network, the first thing to do is assigning IPv4 addresses. + +Any IPv4-enabled |ns3| node will have at least one NetDevice: the :cpp:class:`ns3::LoopbackNetDevice`. +The loopback device address is ``127.0.0.1``. +All the other NetDevices will have one (or more) IPv4 addresses. + +Note that, as today, |ns3| does not have a NAT module, and it does not follows the rules about +filtering private addresses (:rfc:`1918`): 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16. +These addresses are routed as any other address. This behaviour could change in the future. + +IPv4 global addresses can be: + +* manually assigned +* assigned though DHCP + +|ns3| can use both methods, and it's quite important to understand the implications of both. + +Manually assigned IPv4 adddresses ++++++++++++++++++++++++++++++++++ + +This is probably the easiest and most used method. As an example: + +:: + + Ptr n0 = CreateObject (); + Ptr n1 = CreateObject (); + NodeContainer net (n0, n1); + CsmaHelper csma; + NetDeviceContainer ndc = csma.Install (net); + + NS_LOG_INFO ("Assign IPv4 Addresses."); + Ipv4AddressHelper ipv4; + ipv4.SetBase (Ipv4Address ("192.168.1.0"), NetMask ("/24")); + Ipv4InterfaceContainer ic = ipv4.Assign (ndc); + +This method will add two global IPv4 addresses to the nodes. + +Note that the addesses are assigned in sequence. As a consequence, the first Node / NetDevice +will have "192.168.1.1", the second "192.168.1.2" and so on. + +It is possible to repeat the above to assign more than one address to a node. +However, due to the :cpp:class:`Ipv4AddressHelper` singleton nature, one should first assign all the +adddresses of a network, then change the network base (``SetBase``), then do a new assignment. + +Alternatively, it is possible to assign a specific address to a node: + +:: + + Ptr n0 = CreateObject (); + NodeContainer net (n0); + CsmaHelper csma; + NetDeviceContainer ndc = csma.Install (net); + + NS_LOG_INFO ("Specifically Assign an IPv4 Address."); + Ipv4AddressHelper ipv4; + Ptr device = ndc.Get (0); + Ptr node = device->GetNode (); + Ptr ipv4proto = node->GetObject (); + int32_t ifIndex = 0; + ifIndex = ipv4proto->GetInterfaceForDevice (device); + Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("192.168.1.42"), NetMask ("/24")); + ipv4proto->AddAddress (ifIndex, ipv4Addr); + + +DHCP assigned IPv4 adddresses ++++++++++++++++++++++++++++++ + +DHCP is available in the internet-apps module. In order to use DHCP you have to have a +:cpp:class:`DhcpServer` application in a node (the DHC server node) and a :cpp:class:`DhcpClient` application in +each of the nodes. Note that it not necessary that all the nodes in a subnet use DHCP. Some +nodes can have static addresses. + +All the DHCP setup is performed though the :cpp:class:`DhcpHelper` class. A complete example is in +``src/internet-apps/examples/dhcp-example.cc``. + +Further info about the DHCP functionalities can be found in the ``internet-apps`` model documentation. + + Tracing in the IPv4 Stack ************************* diff --git a/src/internet/doc/ipv6.rst b/src/internet/doc/ipv6.rst index d0e01e6ff02..96de6039007 100644 --- a/src/internet/doc/ipv6.rst +++ b/src/internet/doc/ipv6.rst @@ -161,7 +161,7 @@ Note that the global addesses will be derived from the MAC address. As a consequ to have addresses similar to ``2001:db8::200:ff:fe00:1``. It is possible to repeat the above to assign more than one global address to a node. -However, due to the ``Ipv6AddressHelper`` singleton nature, one should first assign all the +However, due to the :cpp:class:`Ipv6AddressHelper` singleton nature, one should first assign all the adddresses of a network, then change the network base (``SetBase``), then do a new assignment. Alternatively, it is possible to assign a specific address to a node: From 3dd8aa2aa1d947196b49144eb1380b4f9bae3db5 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Sat, 8 Jul 2017 00:20:09 +0200 Subject: [PATCH 143/551] internet-apps: fix gcc pedantic warnings --- src/internet-apps/model/dhcp-server.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/internet-apps/model/dhcp-server.cc b/src/internet-apps/model/dhcp-server.cc index b4671fb0a4d..eb641329d03 100644 --- a/src/internet-apps/model/dhcp-server.cc +++ b/src/internet-apps/model/dhcp-server.cc @@ -38,6 +38,7 @@ #include "dhcp-header.h" #include "ns3/ipv4.h" #include +#include namespace ns3 { @@ -252,7 +253,6 @@ void DhcpServer::SendOffer (Ptr iDev, DhcpHeader header, InetSocketAd Address sourceChaddr = header.GetChaddr (); uint32_t tran = header.GetTran (); Ptr packet = 0; - bool found = false; Ipv4Address offeredAddress; NS_LOG_INFO ("DHCP DISCOVER from: " << from.GetIpv4 () << " source port: " << from.GetPort ()); @@ -276,7 +276,6 @@ void DhcpServer::SendOffer (Ptr iDev, DhcpHeader header, InetSocketAd if (!m_availableAddresses.empty ()) { // use an address never used before (if there is one) - found = true; offeredAddress = m_availableAddresses.front (); m_availableAddresses.pop_front (); } @@ -289,7 +288,6 @@ void DhcpServer::SendOffer (Ptr iDev, DhcpHeader header, InetSocketAd m_expiredAddresses.pop_back (); offeredAddress = m_leasedAddresses[oldestChaddr].first; m_leasedAddresses.erase (oldestChaddr); - found = true; } } } From fdc17665c9a070d1088ffc9304d214001a30c19d Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Tue, 11 Jul 2017 21:04:28 +0200 Subject: [PATCH 144/551] internet-apps: fix DHCP Doxygen --- src/internet-apps/helper/dhcp-helper.h | 11 ++++++----- src/internet-apps/model/dhcp-client.h | 17 +++++++++-------- src/internet-apps/model/dhcp-header.h | 2 ++ src/internet-apps/model/dhcp-server.h | 12 ++++++------ src/internet-apps/test/dhcp-test.cc | 1 + 5 files changed, 24 insertions(+), 19 deletions(-) diff --git a/src/internet-apps/helper/dhcp-helper.h b/src/internet-apps/helper/dhcp-helper.h index 7fbbe171cbc..cb13b86c8c8 100644 --- a/src/internet-apps/helper/dhcp-helper.h +++ b/src/internet-apps/helper/dhcp-helper.h @@ -61,14 +61,14 @@ class DhcpHelper /** * \brief Install DHCP client of a nodes / NetDevice - * \param netDevice The NetDevice on which DHCP client application has to be installed + * \param netDevice The NetDevice that the DHCP client will use * \return The application container with DHCP client installed */ ApplicationContainer InstallDhcpClient (Ptr netDevice) const; /** * \brief Install DHCP client of a set of nodes / NetDevices - * \param netDevices The NetDevices on which DHCP client application has to be installed + * \param netDevices The NetDevices that the DHCP client will use * \return The application container with DHCP client installed */ ApplicationContainer InstallDhcpClient (NetDeviceContainer netDevices) const; @@ -95,15 +95,16 @@ class DhcpHelper /** * \brief Assign a fixed IP addresses to a net device. * \param netDevice The NetDevice on which the address has to be installed - * \param serverAddr The Ipv4Address - * \param poolMask The network mask + * \param addr The Ipv4Address + * \param mask The network mask + * \return the Ipv4 interface container */ Ipv4InterfaceContainer InstallFixedAddress (Ptr netDevice, Ipv4Address addr, Ipv4Mask mask); private: /** * \brief Function to install DHCP client on a node - * \param node The node on which DHCP client application has to be installed + * \param netDevice The NetDevice on which DHCP client application has to be installed * \return The pointer to the installed DHCP client */ Ptr InstallDhcpClientPriv (Ptr netDevice) const; diff --git a/src/internet-apps/model/dhcp-client.h b/src/internet-apps/model/dhcp-client.h index 7c155239175..90108d23dbb 100644 --- a/src/internet-apps/model/dhcp-client.h +++ b/src/internet-apps/model/dhcp-client.h @@ -96,6 +96,7 @@ class DhcpClient : public Application virtual void DoDispose (void); private: + /// client states enum States { WAIT_OFFER = 1, //!< State of a client that waits for the offer @@ -115,39 +116,39 @@ class DhcpClient : public Application */ virtual void StopApplication (void); - /* + /** * \brief Handles changes in LinkState */ void LinkStateHandler (void); - /* + /** * \brief Handles incoming packets from the network * \param socket Socket bound to port 68 of the DHCP client */ void NetHandler (Ptr socket); - /* + /** * \brief Sends DHCP DISCOVER and changes the client state to WAIT_OFFER */ void Boot (void); - /* + /** * \brief Stores DHCP offers in m_offerList * \param header DhcpHeader of the DHCP OFFER message */ void OfferHandler (DhcpHeader header); - /* + /** * \brief Selects an OFFER from m_offerList */ void Select (void); - /* + /** * \brief Sends the DHCP REQUEST message and changes the client state to WAIT_ACK */ void Request (void); - /* + /** * \brief Receives the DHCP ACK and configures IP address of the client. * It also triggers the timeout, renew and rebind events. * \param header DhcpHeader of the DHCP ACK message @@ -155,7 +156,7 @@ class DhcpClient : public Application */ void AcceptAck (DhcpHeader header, Address from); - /* + /** * \brief Remove the current DHCP information and restart the process */ void RemoveAndStart (); diff --git a/src/internet-apps/model/dhcp-header.h b/src/internet-apps/model/dhcp-header.h index 0b8b0356cfa..a6497adc726 100644 --- a/src/internet-apps/model/dhcp-header.h +++ b/src/internet-apps/model/dhcp-header.h @@ -99,6 +99,7 @@ class DhcpHeader : public Header */ ~DhcpHeader (); + /// BOOTP options enum Options { OP_MASK = 1, //!< BOOTP Option 1: Address Mask @@ -112,6 +113,7 @@ class DhcpHeader : public Header OP_END = 255 //!< BOOTP Option 255: END }; + /// DHCP messages enum Messages { DHCPDISCOVER = 0, //!< Code for DHCP Discover diff --git a/src/internet-apps/model/dhcp-server.h b/src/internet-apps/model/dhcp-server.h index c9a3c5dec48..82fc7ef17d3 100644 --- a/src/internet-apps/model/dhcp-server.h +++ b/src/internet-apps/model/dhcp-server.h @@ -72,13 +72,13 @@ class DhcpServer : public Application private: static const int PORT = 67; //!< Port number of DHCP server - /* + /** * \brief Handles incoming packets from the network * \param socket Socket bound to port 67 of the DHCP server */ void NetHandler (Ptr socket); - /* + /** * \brief Sends DHCP offer after receiving DHCP Discover * \param iDev incoming NetDevice * \param header DHCP header of the received message @@ -86,7 +86,7 @@ class DhcpServer : public Application */ void SendOffer (Ptr iDev, DhcpHeader header, InetSocketAddress from); - /* + /** * \brief Sends DHCP ACK (or NACK) after receiving Request * \param iDev incoming NetDevice * \param header DHCP header of the received message @@ -94,17 +94,17 @@ class DhcpServer : public Application */ void SendAck (Ptr iDev, DhcpHeader header, InetSocketAddress from); - /* + /** * \brief Modifies the remaining lease time of addresses */ void TimerHandler (void); - /* + /** * \brief Starts the DHCP Server application */ virtual void StartApplication (void); - /* + /** * \brief Stops the DHCP client application */ virtual void StopApplication (void); diff --git a/src/internet-apps/test/dhcp-test.cc b/src/internet-apps/test/dhcp-test.cc index 619088a868e..68586e00c75 100644 --- a/src/internet-apps/test/dhcp-test.cc +++ b/src/internet-apps/test/dhcp-test.cc @@ -51,6 +51,7 @@ class DhcpTestCase : public TestCase virtual ~DhcpTestCase (); /** * Triggered by an address lease on a client. + * \param context The test name. * \param newAddress The leased address. */ void LeaseObtained (std::string context, const Ipv4Address& newAddress); From 866b40b2020ab026f2297fa82d1ea632968141fc Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Wed, 12 Jul 2017 19:54:20 +0200 Subject: [PATCH 145/551] internet: (fixes #2762) BindToNetDevice behaviour is not coherent with Linux --- CHANGES.html | 5 ++ RELEASE_NOTES | 1 + src/aodv/model/aodv-routing-protocol.cc | 12 +-- src/dsdv/model/dsdv-routing-protocol.cc | 4 +- src/internet-apps/model/dhcp-client.cc | 2 +- src/internet-apps/model/dhcp-server.cc | 2 +- src/internet/model/ipv4-end-point-demux.cc | 42 ++++++---- src/internet/model/ipv4-end-point-demux.h | 17 ++-- src/internet/model/ipv6-end-point-demux.cc | 67 +++++++-------- src/internet/model/ipv6-end-point-demux.h | 14 +++- src/internet/model/rip.cc | 4 +- src/internet/model/ripng.cc | 4 +- src/internet/model/tcp-l4-protocol.cc | 44 +++++----- src/internet/model/tcp-l4-protocol.h | 20 +++-- src/internet/model/tcp-socket-base.cc | 34 +++----- src/internet/model/udp-l4-protocol.cc | 50 ++++++----- src/internet/model/udp-l4-protocol.h | 21 +++-- src/internet/model/udp-socket-impl.cc | 97 +++++++++++++++------- src/internet/test/ipv4-rip-test.cc | 2 +- src/internet/test/ipv6-ripng-test.cc | 2 +- src/network/model/socket.h | 7 +- src/olsr/model/olsr-routing-protocol.cc | 2 +- src/wave/model/bsm-application.cc | 2 +- 23 files changed, 260 insertions(+), 195 deletions(-) diff --git a/CHANGES.html b/CHANGES.html index 46127524837..e7de8cffbea 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -130,6 +130,11 @@

        Changes to existing API:

        Previously, a socket bound to an unicast address received also subnet-directed broadcast packets. This is not anymore possible. +
      • You can now Bind as many socket as you want to an address/port, provided that they are bound to different NetDevices. + Moreover, BindToNetDevice does not anymore call Bind. In other terms, Bind and BindToNetDevice can be called + in any order. + However, it is suggested to use BindToNetDevice before Bind in order to avoid conflicts. +

        • Changes to build system:

          diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 6ef5725d182..9f12bb68546 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -112,6 +112,7 @@ Bugs fixed - Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast - Bug 2760 - OLSR uses unicast-bound sockets to receive broadcasts - Bug 2761 - Packet has no Traffic ID for CTS frames when A-MPDU is used +- Bug 2762 - BindToNetDevice behaviour is not coherent with Linux Known issues ------------ diff --git a/src/aodv/model/aodv-routing-protocol.cc b/src/aodv/model/aodv-routing-protocol.cc index dc67f88fba0..61f47c27058 100644 --- a/src/aodv/model/aodv-routing-protocol.cc +++ b/src/aodv/model/aodv-routing-protocol.cc @@ -685,8 +685,8 @@ RoutingProtocol::NotifyInterfaceUp (uint32_t i) UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); - socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->SetAllowBroadcast (true); socket->SetIpRecvTtl (true); m_socketAddresses.insert (std::make_pair (socket, iface)); @@ -696,8 +696,8 @@ RoutingProtocol::NotifyInterfaceUp (uint32_t i) UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); - socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->SetAllowBroadcast (true); socket->SetIpRecvTtl (true); m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface)); @@ -795,8 +795,8 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, Ipv4InterfaceAddress address) UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv,this)); - socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->SetAllowBroadcast (true); m_socketAddresses.insert (std::make_pair (socket, iface)); @@ -805,8 +805,8 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, Ipv4InterfaceAddress address) UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); - socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->SetAllowBroadcast (true); socket->SetIpRecvTtl (true); m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface)); @@ -854,8 +854,8 @@ RoutingProtocol::NotifyRemoveAddress (uint32_t i, Ipv4InterfaceAddress address) NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); // Bind to any IP address so that broadcasts can be received - socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetLocal (), AODV_PORT)); socket->SetAllowBroadcast (true); socket->SetIpRecvTtl (true); m_socketAddresses.insert (std::make_pair (socket, iface)); @@ -865,8 +865,8 @@ RoutingProtocol::NotifyRemoveAddress (uint32_t i, Ipv4InterfaceAddress address) UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvAodv, this)); - socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (iface.GetBroadcast (), AODV_PORT)); socket->SetAllowBroadcast (true); socket->SetIpRecvTtl (true); m_socketSubnetBroadcastAddresses.insert (std::make_pair (socket, iface)); diff --git a/src/dsdv/model/dsdv-routing-protocol.cc b/src/dsdv/model/dsdv-routing-protocol.cc index c82627fc573..980f24ba31a 100644 --- a/src/dsdv/model/dsdv-routing-protocol.cc +++ b/src/dsdv/model/dsdv-routing-protocol.cc @@ -976,8 +976,8 @@ RoutingProtocol::NotifyInterfaceUp (uint32_t i) Ptr socket = Socket::CreateSocket (GetObject (),UdpSocketFactory::GetTypeId ()); NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvDsdv,this)); - socket->Bind (InetSocketAddress (Ipv4Address::GetAny (), DSDV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (Ipv4Address::GetAny (), DSDV_PORT)); socket->SetAllowBroadcast (true); socket->SetAttribute ("IpTtl",UintegerValue (1)); m_socketAddresses.insert (std::make_pair (socket,iface)); @@ -1034,8 +1034,8 @@ RoutingProtocol::NotifyAddAddress (uint32_t i, NS_ASSERT (socket != 0); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvDsdv,this)); // Bind to any IP address so that broadcasts can be received - socket->Bind (InetSocketAddress (Ipv4Address::GetAny (), DSDV_PORT)); socket->BindToNetDevice (l3->GetNetDevice (i)); + socket->Bind (InetSocketAddress (Ipv4Address::GetAny (), DSDV_PORT)); socket->SetAllowBroadcast (true); m_socketAddresses.insert (std::make_pair (socket,iface)); Ptr dev = m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (iface.GetLocal ())); diff --git a/src/internet-apps/model/dhcp-client.cc b/src/internet-apps/model/dhcp-client.cc index ee2accfbb28..0f6f0d23b96 100644 --- a/src/internet-apps/model/dhcp-client.cc +++ b/src/internet-apps/model/dhcp-client.cc @@ -192,8 +192,8 @@ DhcpClient::StartApplication (void) m_socket = Socket::CreateSocket (GetNode (), tid); InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 68); m_socket->SetAllowBroadcast (true); - m_socket->Bind (local); m_socket->BindToNetDevice (m_device); + m_socket->Bind (local); } m_socket->SetRecvCallback (MakeCallback (&DhcpClient::NetHandler, this)); diff --git a/src/internet-apps/model/dhcp-server.cc b/src/internet-apps/model/dhcp-server.cc index eb641329d03..13538b5c6bb 100644 --- a/src/internet-apps/model/dhcp-server.cc +++ b/src/internet-apps/model/dhcp-server.cc @@ -155,8 +155,8 @@ void DhcpServer::StartApplication (void) m_socket = Socket::CreateSocket (GetNode (), tid); InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), PORT); m_socket->SetAllowBroadcast (true); - m_socket->Bind (local); m_socket->BindToNetDevice (ipv4->GetNetDevice (ifIndex)); + m_socket->Bind (local); m_socket->SetRecvPktInfo (true); uint32_t range = m_maxAddress.Get () - m_minAddress.Get () + 1; diff --git a/src/internet/model/ipv4-end-point-demux.cc b/src/internet/model/ipv4-end-point-demux.cc index aa61197021e..47658378112 100644 --- a/src/internet/model/ipv4-end-point-demux.cc +++ b/src/internet/model/ipv4-end-point-demux.cc @@ -60,13 +60,14 @@ Ipv4EndPointDemux::LookupPortLocal (uint16_t port) } bool -Ipv4EndPointDemux::LookupLocal (Ipv4Address addr, uint16_t port) +Ipv4EndPointDemux::LookupLocal (Ptr boundNetDevice, Ipv4Address addr, uint16_t port) { NS_LOG_FUNCTION (this << addr << port); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { if ((*i)->GetLocalPort () == port && - (*i)->GetLocalAddress () == addr) + (*i)->GetLocalAddress () == addr && + (*i)->GetBoundNetDevice () == boundNetDevice) { return true; } @@ -107,20 +108,20 @@ Ipv4EndPointDemux::Allocate (Ipv4Address address) } Ipv4EndPoint * -Ipv4EndPointDemux::Allocate (uint16_t port) +Ipv4EndPointDemux::Allocate (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); + NS_LOG_FUNCTION (this << port << boundNetDevice); - return Allocate (Ipv4Address::GetAny (), port); + return Allocate (boundNetDevice, Ipv4Address::GetAny (), port); } Ipv4EndPoint * -Ipv4EndPointDemux::Allocate (Ipv4Address address, uint16_t port) +Ipv4EndPointDemux::Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - if (LookupLocal (address, port)) + NS_LOG_FUNCTION (this << address << port << boundNetDevice); + if (LookupLocal (boundNetDevice, address, port) || LookupLocal (0, address, port)) { - NS_LOG_WARN ("Duplicate address/port; failing."); + NS_LOG_WARN ("Duplicated endpoint."); return 0; } Ipv4EndPoint *endPoint = new Ipv4EndPoint (address, port); @@ -130,19 +131,20 @@ Ipv4EndPointDemux::Allocate (Ipv4Address address, uint16_t port) } Ipv4EndPoint * -Ipv4EndPointDemux::Allocate (Ipv4Address localAddress, uint16_t localPort, +Ipv4EndPointDemux::Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); + NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort << boundNetDevice); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { if ((*i)->GetLocalPort () == localPort && (*i)->GetLocalAddress () == localAddress && (*i)->GetPeerPort () == peerPort && - (*i)->GetPeerAddress () == peerAddress) + (*i)->GetPeerAddress () == peerAddress && + ((*i)->GetBoundNetDevice () == boundNetDevice || (*i)->GetBoundNetDevice () == 0)) { - NS_LOG_WARN ("No way we can allocate this end-point."); - /* no way we can allocate this end-point. */ + NS_LOG_WARN ("Duplicated endpoint."); return 0; } } @@ -323,10 +325,14 @@ Ipv4EndPointDemux::Lookup (Ipv4Address daddr, uint16_t dport, } // Here we find the most exact match - if (!retval4.empty ()) return retval4; - if (!retval3.empty ()) return retval3; - if (!retval2.empty ()) return retval2; - return retval1; // might be empty if no matches + EndPoints retval; + if (!retval4.empty ()) retval = retval4; + else if (!retval3.empty ()) retval = retval3; + else if (!retval2.empty ()) retval = retval2; + else retval = retval1; + + NS_ABORT_MSG_IF (retval.size () > 1, "Too many endpoints - perhaps you created too many sockets without binding them to different NetDevices."); + return retval; // might be empty if no matches } Ipv4EndPoint * diff --git a/src/internet/model/ipv4-end-point-demux.h b/src/internet/model/ipv4-end-point-demux.h index 1666983f7b9..935f91ac4aa 100644 --- a/src/internet/model/ipv4-end-point-demux.h +++ b/src/internet/model/ipv4-end-point-demux.h @@ -72,11 +72,12 @@ class Ipv4EndPointDemux { /** * \brief Lookup for address and port. + * \param boundNetDevice Bound NetDevice (if any) * \param addr address to test * \param port port to test * \return true if there is a match in EndPoints, false otherwise */ - bool LookupLocal (Ipv4Address addr, uint16_t port); + bool LookupLocal (Ptr boundNetDevice, Ipv4Address addr, uint16_t port); /** * \brief lookup for a match with all the parameters. @@ -130,31 +131,33 @@ class Ipv4EndPointDemux { /** * \brief Allocate a Ipv4EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param port local port * \return an Ipv4EndPoint instance */ - Ipv4EndPoint *Allocate (uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate a Ipv4EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param address local address * \param port local port * \return an Ipv4EndPoint instance */ - Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port); /** * \brief Allocate a Ipv4EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address * \param localPort local port * \param peerAddress peer address * \param peerPort peer port * \return an Ipv4EndPoint instance */ - Ipv4EndPoint *Allocate (Ipv4Address localAddress, - uint16_t localPort, - Ipv4Address peerAddress, - uint16_t peerPort); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, + Ipv4Address peerAddress, uint16_t peerPort); /** * \brief Remove a end point. diff --git a/src/internet/model/ipv6-end-point-demux.cc b/src/internet/model/ipv6-end-point-demux.cc index d03383313ef..250a1f4c22a 100644 --- a/src/internet/model/ipv6-end-point-demux.cc +++ b/src/internet/model/ipv6-end-point-demux.cc @@ -58,13 +58,14 @@ bool Ipv6EndPointDemux::LookupPortLocal (uint16_t port) return false; } -bool Ipv6EndPointDemux::LookupLocal (Ipv6Address addr, uint16_t port) +bool Ipv6EndPointDemux::LookupLocal (Ptr boundNetDevice, Ipv6Address addr, uint16_t port) { NS_LOG_FUNCTION (this << addr << port); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { - if ((*i)->GetLocalPort () == port - && (*i)->GetLocalAddress () == addr) + if ((*i)->GetLocalPort () == port && + (*i)->GetLocalAddress () == addr && + (*i)->GetBoundNetDevice () == boundNetDevice) { return true; } @@ -74,7 +75,7 @@ bool Ipv6EndPointDemux::LookupLocal (Ipv6Address addr, uint16_t port) Ipv6EndPoint* Ipv6EndPointDemux::Allocate () { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); uint16_t port = AllocateEphemeralPort (); if (port == 0) { @@ -102,19 +103,19 @@ Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ipv6Address address) return endPoint; } -Ipv6EndPoint* Ipv6EndPointDemux::Allocate (uint16_t port) +Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); + NS_LOG_FUNCTION (this << boundNetDevice << port); - return Allocate (Ipv6Address::GetAny (), port); + return Allocate (boundNetDevice, Ipv6Address::GetAny (), port); } -Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ipv6Address address, uint16_t port) +Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ptr boundNetDevice, Ipv6Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - if (LookupLocal (address, port)) + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + if (LookupLocal (boundNetDevice, address, port) || LookupLocal (0, address, port)) { - NS_LOG_WARN ("Duplicate address/port; failing."); + NS_LOG_WARN ("Duplicated endpoint."); return 0; } Ipv6EndPoint *endPoint = new Ipv6EndPoint (address, port); @@ -123,19 +124,20 @@ Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ipv6Address address, uint16_t port) return endPoint; } -Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ipv6Address localAddress, uint16_t localPort, +Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, Ipv6Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { - if ((*i)->GetLocalPort () == localPort - && (*i)->GetLocalAddress () == localAddress - && (*i)->GetPeerPort () == peerPort - && (*i)->GetPeerAddress () == peerAddress) + if ((*i)->GetLocalPort () == localPort && + (*i)->GetLocalAddress () == localAddress && + (*i)->GetPeerPort () == peerPort && + (*i)->GetPeerAddress () == peerAddress && + ((*i)->GetBoundNetDevice () == boundNetDevice || (*i)->GetBoundNetDevice () == 0)) { - NS_LOG_WARN ("No way we can allocate this end-point."); - /* no way we can allocate this end-point. */ + NS_LOG_WARN ("Duplicated endpoint."); return 0; } } @@ -150,7 +152,7 @@ Ipv6EndPoint* Ipv6EndPointDemux::Allocate (Ipv6Address localAddress, uint16_t lo void Ipv6EndPointDemux::DeAllocate (Ipv6EndPoint *endPoint) { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) { if (*i == endPoint) @@ -275,20 +277,15 @@ Ipv6EndPointDemux::EndPoints Ipv6EndPointDemux::Lookup (Ipv6Address daddr, uint1 } } - /* Here we find the most exact match */ - if (!retval4.empty ()) - { - return retval4; - } - if (!retval3.empty ()) - { - return retval3; - } - if (!retval2.empty ()) - { - return retval2; - } - return retval1; /* might be empty if no matches */ + // Here we find the most exact match + EndPoints retval; + if (!retval4.empty ()) retval = retval4; + else if (!retval3.empty ()) retval = retval3; + else if (!retval2.empty ()) retval = retval2; + else retval = retval1; + + NS_ABORT_MSG_IF (retval.size () > 1, "Too many endpoints - perhaps you created too many sockets without binding them to different NetDevices."); + return retval; // might be empty if no matches } Ipv6EndPoint* Ipv6EndPointDemux::SimpleLookup (Ipv6Address dst, uint16_t dport, Ipv6Address src, uint16_t sport) @@ -333,7 +330,7 @@ Ipv6EndPoint* Ipv6EndPointDemux::SimpleLookup (Ipv6Address dst, uint16_t dport, uint16_t Ipv6EndPointDemux::AllocateEphemeralPort () { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); uint16_t port = m_ephemeral; int count = m_portLast - m_portFirst; do diff --git a/src/internet/model/ipv6-end-point-demux.h b/src/internet/model/ipv6-end-point-demux.h index 04b960b4530..8a0e41dd11f 100644 --- a/src/internet/model/ipv6-end-point-demux.h +++ b/src/internet/model/ipv6-end-point-demux.h @@ -60,11 +60,12 @@ class Ipv6EndPointDemux /** * \brief Lookup for address and port. + * \param boundNetDevice Bound NetDevice (if any) * \param addr address to test * \param port port to test * \return true if there is a match in EndPoints, false otherwise */ - bool LookupLocal (Ipv6Address addr, uint16_t port); + bool LookupLocal (Ptr boundNetDevice, Ipv6Address addr, uint16_t port); /** * \brief lookup for a match with all the parameters. @@ -111,28 +112,33 @@ class Ipv6EndPointDemux /** * \brief Allocate a Ipv6EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param port local port * \return an Ipv6EndPoint instance */ - Ipv6EndPoint * Allocate (uint16_t port); + Ipv6EndPoint * Allocate (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate a Ipv6EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param address local address * \param port local port * \return an Ipv6EndPoint instance */ - Ipv6EndPoint * Allocate (Ipv6Address address, uint16_t port); + Ipv6EndPoint * Allocate (Ptr boundNetDevice, Ipv6Address address, uint16_t port); /** * \brief Allocate a Ipv6EndPoint. + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address * \param localPort local port * \param peerAddress peer address * \param peerPort peer port * \return an Ipv6EndPoint instance */ - Ipv6EndPoint * Allocate (Ipv6Address localAddress, uint16_t localPort, Ipv6Address peerAddress, uint16_t peerPort); + Ipv6EndPoint * Allocate (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, + Ipv6Address peerAddress, uint16_t peerPort); /** * \brief Remove a end point. diff --git a/src/internet/model/rip.cc b/src/internet/model/rip.cc index 58ca129c829..cc96ba8e057 100644 --- a/src/internet/model/rip.cc +++ b/src/internet/model/rip.cc @@ -144,9 +144,9 @@ void Rip::DoInitialize () Ptr theNode = GetObject (); Ptr socket = Socket::CreateSocket (theNode, tid); InetSocketAddress local = InetSocketAddress (address.GetLocal (), RIP_PORT); + socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); int ret = socket->Bind (local); NS_ASSERT_MSG (ret == 0, "Bind unsuccessful"); - socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); socket->SetIpRecvTtl (true); m_sendSocketList[socket] = i; } @@ -343,8 +343,8 @@ void Rip::NotifyInterfaceUp (uint32_t i) Ptr theNode = GetObject (); Ptr socket = Socket::CreateSocket (theNode, tid); InetSocketAddress local = InetSocketAddress (address.GetLocal (), RIP_PORT); - socket->Bind (local); socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); + socket->Bind (local); socket->SetIpRecvTtl (true); m_sendSocketList[socket] = i; } diff --git a/src/internet/model/ripng.cc b/src/internet/model/ripng.cc index f6335208e38..879a145382a 100644 --- a/src/internet/model/ripng.cc +++ b/src/internet/model/ripng.cc @@ -138,9 +138,9 @@ void RipNg::DoInitialize () Ptr theNode = GetObject (); Ptr socket = Socket::CreateSocket (theNode, tid); Inet6SocketAddress local = Inet6SocketAddress (address.GetAddress (), RIPNG_PORT); + socket->BindToNetDevice (m_ipv6->GetNetDevice (i)); int ret = socket->Bind (local); NS_ASSERT_MSG (ret == 0, "Bind unsuccessful"); - socket->BindToNetDevice (m_ipv6->GetNetDevice (i)); socket->ShutdownRecv (); socket->SetIpv6RecvHopLimit (true); m_sendSocketList[socket] = i; @@ -314,8 +314,8 @@ void RipNg::NotifyInterfaceUp (uint32_t i) Ptr theNode = GetObject (); Ptr socket = Socket::CreateSocket (theNode, tid); Inet6SocketAddress local = Inet6SocketAddress (address.GetAddress (), RIPNG_PORT); - socket->Bind (local); socket->BindToNetDevice (m_ipv6->GetNetDevice (i)); + socket->Bind (local); socket->ShutdownRecv (); socket->SetIpv6RecvHopLimit (true); m_sendSocketList[socket] = i; diff --git a/src/internet/model/tcp-l4-protocol.cc b/src/internet/model/tcp-l4-protocol.cc index 5b060a9d1f8..280843850c4 100644 --- a/src/internet/model/tcp-l4-protocol.cc +++ b/src/internet/model/tcp-l4-protocol.cc @@ -205,7 +205,7 @@ TcpL4Protocol::CreateSocket (void) Ipv4EndPoint * TcpL4Protocol::Allocate (void) { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); return m_endPoints->Allocate (); } @@ -217,25 +217,27 @@ TcpL4Protocol::Allocate (Ipv4Address address) } Ipv4EndPoint * -TcpL4Protocol::Allocate (uint16_t port) +TcpL4Protocol::Allocate (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); - return m_endPoints->Allocate (port); + NS_LOG_FUNCTION (this << boundNetDevice << port); + return m_endPoints->Allocate (boundNetDevice, port); } Ipv4EndPoint * -TcpL4Protocol::Allocate (Ipv4Address address, uint16_t port) +TcpL4Protocol::Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - return m_endPoints->Allocate (address, port); + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + return m_endPoints->Allocate (boundNetDevice, address, port); } Ipv4EndPoint * -TcpL4Protocol::Allocate (Ipv4Address localAddress, uint16_t localPort, +TcpL4Protocol::Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); - return m_endPoints->Allocate (localAddress, localPort, + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); + return m_endPoints->Allocate (boundNetDevice, + localAddress, localPort, peerAddress, peerPort); } @@ -249,7 +251,7 @@ TcpL4Protocol::DeAllocate (Ipv4EndPoint *endPoint) Ipv6EndPoint * TcpL4Protocol::Allocate6 (void) { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); return m_endPoints6->Allocate (); } @@ -261,25 +263,27 @@ TcpL4Protocol::Allocate6 (Ipv6Address address) } Ipv6EndPoint * -TcpL4Protocol::Allocate6 (uint16_t port) +TcpL4Protocol::Allocate6 (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); - return m_endPoints6->Allocate (port); + NS_LOG_FUNCTION (this << boundNetDevice << port); + return m_endPoints6->Allocate (boundNetDevice, port); } Ipv6EndPoint * -TcpL4Protocol::Allocate6 (Ipv6Address address, uint16_t port) +TcpL4Protocol::Allocate6 (Ptr boundNetDevice, Ipv6Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - return m_endPoints6->Allocate (address, port); + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + return m_endPoints6->Allocate (boundNetDevice, address, port); } Ipv6EndPoint * -TcpL4Protocol::Allocate6 (Ipv6Address localAddress, uint16_t localPort, +TcpL4Protocol::Allocate6 (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, Ipv6Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); - return m_endPoints6->Allocate (localAddress, localPort, + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); + return m_endPoints6->Allocate (boundNetDevice, + localAddress, localPort, peerAddress, peerPort); } diff --git a/src/internet/model/tcp-l4-protocol.h b/src/internet/model/tcp-l4-protocol.h index 309955a9e50..bbf87b5e9f4 100644 --- a/src/internet/model/tcp-l4-protocol.h +++ b/src/internet/model/tcp-l4-protocol.h @@ -128,26 +128,30 @@ class TcpL4Protocol : public IpL4Protocol { Ipv4EndPoint *Allocate (Ipv4Address address); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param address address to use * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address to use * \param localPort local port to use * \param peerAddress remote address to use * \param peerPort remote port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort, + Ipv4EndPoint *Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort); /** * \brief Allocate an IPv6 Endpoint @@ -162,26 +166,30 @@ class TcpL4Protocol : public IpL4Protocol { Ipv6EndPoint *Allocate6 (Ipv6Address address); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param port port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (uint16_t port); + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param address address to use * \param port port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port); + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, Ipv6Address address, uint16_t port); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address to use * \param localPort local port to use * \param peerAddress remote address to use * \param peerPort remote port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort, + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, Ipv6Address peerAddress, uint16_t peerPort); /** diff --git a/src/internet/model/tcp-socket-base.cc b/src/internet/model/tcp-socket-base.cc index d9dd7a26f29..1a5faa1bbac 100644 --- a/src/internet/model/tcp-socket-base.cc +++ b/src/internet/model/tcp-socket-base.cc @@ -579,7 +579,7 @@ TcpSocketBase::Bind (const Address &address) } else if (ipv4 == Ipv4Address::GetAny () && port != 0) { - m_endPoint = m_tcp->Allocate (port); + m_endPoint = m_tcp->Allocate (GetBoundNetDevice (), port); } else if (ipv4 != Ipv4Address::GetAny () && port == 0) { @@ -587,7 +587,7 @@ TcpSocketBase::Bind (const Address &address) } else if (ipv4 != Ipv4Address::GetAny () && port != 0) { - m_endPoint = m_tcp->Allocate (ipv4, port); + m_endPoint = m_tcp->Allocate (GetBoundNetDevice (), ipv4, port); } if (0 == m_endPoint) { @@ -606,7 +606,7 @@ TcpSocketBase::Bind (const Address &address) } else if (ipv6 == Ipv6Address::GetAny () && port != 0) { - m_endPoint6 = m_tcp->Allocate6 (port); + m_endPoint6 = m_tcp->Allocate6 (GetBoundNetDevice (), port); } else if (ipv6 != Ipv6Address::GetAny () && port == 0) { @@ -614,7 +614,7 @@ TcpSocketBase::Bind (const Address &address) } else if (ipv6 != Ipv6Address::GetAny () && port != 0) { - m_endPoint6 = m_tcp->Allocate6 (ipv6, port); + m_endPoint6 = m_tcp->Allocate6 (GetBoundNetDevice (), ipv6, port); } if (0 == m_endPoint6) { @@ -991,27 +991,15 @@ TcpSocketBase::BindToNetDevice (Ptr netdevice) { NS_LOG_FUNCTION (netdevice); Socket::BindToNetDevice (netdevice); // Includes sanity check - if (m_endPoint == 0) + if (m_endPoint != 0) { - if (Bind () == -1) - { - NS_ASSERT (m_endPoint == 0); - return; - } - NS_ASSERT (m_endPoint != 0); + m_endPoint->BindToNetDevice (netdevice); } - m_endPoint->BindToNetDevice (netdevice); - if (m_endPoint6 == 0) + if (m_endPoint6 != 0) { - if (Bind6 () == -1) - { - NS_ASSERT (m_endPoint6 == 0); - return; - } - NS_ASSERT (m_endPoint6 != 0); + m_endPoint6->BindToNetDevice (netdevice); } - m_endPoint6->BindToNetDevice (netdevice); return; } @@ -2577,7 +2565,8 @@ TcpSocketBase::CompleteFork (Ptr p, const TcpHeader& h, // Get port and address from peer (connecting host) if (InetSocketAddress::IsMatchingType (toAddress)) { - m_endPoint = m_tcp->Allocate (InetSocketAddress::ConvertFrom (toAddress).GetIpv4 (), + m_endPoint = m_tcp->Allocate (GetBoundNetDevice (), + InetSocketAddress::ConvertFrom (toAddress).GetIpv4 (), InetSocketAddress::ConvertFrom (toAddress).GetPort (), InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (), InetSocketAddress::ConvertFrom (fromAddress).GetPort ()); @@ -2585,7 +2574,8 @@ TcpSocketBase::CompleteFork (Ptr p, const TcpHeader& h, } else if (Inet6SocketAddress::IsMatchingType (toAddress)) { - m_endPoint6 = m_tcp->Allocate6 (Inet6SocketAddress::ConvertFrom (toAddress).GetIpv6 (), + m_endPoint6 = m_tcp->Allocate6 (GetBoundNetDevice (), + Inet6SocketAddress::ConvertFrom (toAddress).GetIpv6 (), Inet6SocketAddress::ConvertFrom (toAddress).GetPort (), Inet6SocketAddress::ConvertFrom (fromAddress).GetIpv6 (), Inet6SocketAddress::ConvertFrom (fromAddress).GetPort ()); diff --git a/src/internet/model/udp-l4-protocol.cc b/src/internet/model/udp-l4-protocol.cc index d86ce4683da..5e78bb65398 100644 --- a/src/internet/model/udp-l4-protocol.cc +++ b/src/internet/model/udp-l4-protocol.cc @@ -173,7 +173,7 @@ UdpL4Protocol::CreateSocket (void) Ipv4EndPoint * UdpL4Protocol::Allocate (void) { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); return m_endPoints->Allocate (); } @@ -185,24 +185,26 @@ UdpL4Protocol::Allocate (Ipv4Address address) } Ipv4EndPoint * -UdpL4Protocol::Allocate (uint16_t port) +UdpL4Protocol::Allocate (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); - return m_endPoints->Allocate (port); + NS_LOG_FUNCTION (this << boundNetDevice << port); + return m_endPoints->Allocate (boundNetDevice, port); } Ipv4EndPoint * -UdpL4Protocol::Allocate (Ipv4Address address, uint16_t port) +UdpL4Protocol::Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - return m_endPoints->Allocate (address, port); + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + return m_endPoints->Allocate (boundNetDevice, address, port); } Ipv4EndPoint * -UdpL4Protocol::Allocate (Ipv4Address localAddress, uint16_t localPort, +UdpL4Protocol::Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); - return m_endPoints->Allocate (localAddress, localPort, + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); + return m_endPoints->Allocate (boundNetDevice, + localAddress, localPort, peerAddress, peerPort); } @@ -216,7 +218,7 @@ UdpL4Protocol::DeAllocate (Ipv4EndPoint *endPoint) Ipv6EndPoint * UdpL4Protocol::Allocate6 (void) { - NS_LOG_FUNCTION_NOARGS (); + NS_LOG_FUNCTION (this); return m_endPoints6->Allocate (); } @@ -228,25 +230,27 @@ UdpL4Protocol::Allocate6 (Ipv6Address address) } Ipv6EndPoint * -UdpL4Protocol::Allocate6 (uint16_t port) +UdpL4Protocol::Allocate6 (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); - return m_endPoints6->Allocate (port); + NS_LOG_FUNCTION (this << boundNetDevice << port); + return m_endPoints6->Allocate (boundNetDevice, port); } Ipv6EndPoint * -UdpL4Protocol::Allocate6 (Ipv6Address address, uint16_t port) +UdpL4Protocol::Allocate6 (Ptr boundNetDevice, Ipv6Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - return m_endPoints6->Allocate (address, port); + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + return m_endPoints6->Allocate (boundNetDevice, address, port); } Ipv6EndPoint * -UdpL4Protocol::Allocate6 (Ipv6Address localAddress, uint16_t localPort, - Ipv6Address peerAddress, uint16_t peerPort) -{ - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); - return m_endPoints6->Allocate (localAddress, localPort, - peerAddress, peerPort); +UdpL4Protocol::Allocate6 (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, + Ipv6Address peerAddress, uint16_t peerPort) +{ + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); + return m_endPoints6->Allocate (boundNetDevice, + localAddress, localPort, + peerAddress, peerPort); } void diff --git a/src/internet/model/udp-l4-protocol.h b/src/internet/model/udp-l4-protocol.h index 80cd0a74e6a..eb456904c93 100644 --- a/src/internet/model/udp-l4-protocol.h +++ b/src/internet/model/udp-l4-protocol.h @@ -36,6 +36,7 @@ class Ipv4EndPoint; class Ipv6EndPointDemux; class Ipv6EndPoint; class UdpSocketImpl; +class NetDevice; /** * \ingroup internet @@ -96,26 +97,30 @@ class UdpL4Protocol : public IpL4Protocol { Ipv4EndPoint *Allocate (Ipv4Address address); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param address address to use * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address to use * \param localPort local port to use * \param peerAddress remote address to use * \param peerPort remote port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort, + Ipv4EndPoint *Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort); /** @@ -131,26 +136,30 @@ class UdpL4Protocol : public IpL4Protocol { Ipv6EndPoint *Allocate6 (Ipv6Address address); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param port port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (uint16_t port); + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param address address to use * \param port port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port); + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, Ipv6Address address, uint16_t port); /** * \brief Allocate an IPv6 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address to use * \param localPort local port to use * \param peerAddress remote address to use * \param peerPort remote port to use * \return the Endpoint */ - Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort, + Ipv6EndPoint *Allocate6 (Ptr boundNetDevice, + Ipv6Address localAddress, uint16_t localPort, Ipv6Address peerAddress, uint16_t peerPort); /** diff --git a/src/internet/model/udp-socket-impl.cc b/src/internet/model/udp-socket-impl.cc index ced2901c14b..2721c68a8ab 100644 --- a/src/internet/model/udp-socket-impl.cc +++ b/src/internet/model/udp-socket-impl.cc @@ -233,6 +233,10 @@ UdpSocketImpl::Bind (void) { NS_LOG_FUNCTION_NOARGS (); m_endPoint = m_udp->Allocate (); + if (m_boundnetdevice) + { + m_endPoint->BindToNetDevice (m_boundnetdevice); + } return FinishBind (); } @@ -241,6 +245,10 @@ UdpSocketImpl::Bind6 (void) { NS_LOG_FUNCTION_NOARGS (); m_endPoint6 = m_udp->Allocate6 (); + if (m_boundnetdevice) + { + m_endPoint6->BindToNetDevice (m_boundnetdevice); + } return FinishBind (); } @@ -251,7 +259,7 @@ UdpSocketImpl::Bind (const Address &address) if (InetSocketAddress::IsMatchingType (address)) { - NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated (maybe you used BindToNetDevice before Bind)."); + NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated."); InetSocketAddress transport = InetSocketAddress::ConvertFrom (address); Ipv4Address ipv4 = transport.GetIpv4 (); @@ -263,7 +271,7 @@ UdpSocketImpl::Bind (const Address &address) } else if (ipv4 == Ipv4Address::GetAny () && port != 0) { - m_endPoint = m_udp->Allocate (port); + m_endPoint = m_udp->Allocate (GetBoundNetDevice (), port); } else if (ipv4 != Ipv4Address::GetAny () && port == 0) { @@ -271,17 +279,22 @@ UdpSocketImpl::Bind (const Address &address) } else if (ipv4 != Ipv4Address::GetAny () && port != 0) { - m_endPoint = m_udp->Allocate (ipv4, port); + m_endPoint = m_udp->Allocate (GetBoundNetDevice (), ipv4, port); } if (0 == m_endPoint) { m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL; return -1; } + if (m_boundnetdevice) + { + m_endPoint->BindToNetDevice (m_boundnetdevice); + } + } else if (Inet6SocketAddress::IsMatchingType (address)) { - NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated (maybe you used BindToNetDevice before Bind)."); + NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated."); Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address); Ipv6Address ipv6 = transport.GetIpv6 (); @@ -292,7 +305,7 @@ UdpSocketImpl::Bind (const Address &address) } else if (ipv6 == Ipv6Address::GetAny () && port != 0) { - m_endPoint6 = m_udp->Allocate6 (port); + m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), port); } else if (ipv6 != Ipv6Address::GetAny () && port == 0) { @@ -300,19 +313,32 @@ UdpSocketImpl::Bind (const Address &address) } else if (ipv6 != Ipv6Address::GetAny () && port != 0) { - m_endPoint6 = m_udp->Allocate6 (ipv6, port); + m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), ipv6, port); } if (0 == m_endPoint6) { m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL; return -1; } + if (m_boundnetdevice) + { + m_endPoint6->BindToNetDevice (m_boundnetdevice); + } + if (ipv6.IsMulticast ()) { Ptr ipv6l3 = m_node->GetObject (); if (ipv6l3) { - ipv6l3->AddMulticastAddress (ipv6); + if (m_boundnetdevice == 0) + { + ipv6l3->AddMulticastAddress (ipv6); + } + else + { + uint32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice); + ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index); + } } } } @@ -928,37 +954,46 @@ UdpSocketImpl::BindToNetDevice (Ptr netdevice) { NS_LOG_FUNCTION (netdevice); + Ptr oldBoundNetDevice = m_boundnetdevice; + Socket::BindToNetDevice (netdevice); // Includes sanity check - if (m_endPoint == 0) + if (m_endPoint != 0) { - if (Bind () == -1) - { - NS_ASSERT (m_endPoint == 0); - return; - } - NS_ASSERT (m_endPoint != 0); + m_endPoint->BindToNetDevice (netdevice); } - m_endPoint->BindToNetDevice (netdevice); - if (m_endPoint6 == 0) + if (m_endPoint6 != 0) { - if (Bind6 () == -1) - { - NS_ASSERT (m_endPoint6 == 0); - return; - } - NS_ASSERT (m_endPoint6 != 0); - } - m_endPoint6->BindToNetDevice (netdevice); + m_endPoint6->BindToNetDevice (netdevice); - if (m_endPoint6->GetLocalAddress ().IsMulticast ()) - { - Ptr ipv6l3 = m_node->GetObject (); - if (ipv6l3) + // The following is to fix the multicast distribution inside the node + // and to upgrade it to the actual bound NetDevice. + if (m_endPoint6->GetLocalAddress ().IsMulticast ()) { - uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice); - ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ()); - ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index); + Ptr ipv6l3 = m_node->GetObject (); + if (ipv6l3) + { + // Cleanup old one + if (oldBoundNetDevice) + { + uint32_t index = ipv6l3->GetInterfaceForDevice (oldBoundNetDevice); + ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress (), index); + } + else + { + ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ()); + } + // add new one + if (netdevice) + { + uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice); + ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index); + } + else + { + ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress ()); + } + } } } diff --git a/src/internet/test/ipv4-rip-test.cc b/src/internet/test/ipv4-rip-test.cc index 84df8ff253e..e66c86402b7 100644 --- a/src/internet/test/ipv4-rip-test.cc +++ b/src/internet/test/ipv4-rip-test.cc @@ -665,8 +665,8 @@ Ipv4RipSplitHorizonStrategyTest::DoRun (void) // Create the UDP sockets Ptr rxSocketFactory = listener->GetObject (); Ptr rxSocket = rxSocketFactory->CreateSocket (); - NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("224.0.0.9"), 520)), 0, "trivial"); rxSocket->BindToNetDevice (listenerDev); + NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("224.0.0.9"), 520)), 0, "trivial"); rxSocket->SetRecvCallback (MakeCallback (&Ipv4RipSplitHorizonStrategyTest::ReceivePktProbe, this)); // ------ Now the tests ------------ diff --git a/src/internet/test/ipv6-ripng-test.cc b/src/internet/test/ipv6-ripng-test.cc index 32d40ac9ec9..2c42c72ef78 100644 --- a/src/internet/test/ipv6-ripng-test.cc +++ b/src/internet/test/ipv6-ripng-test.cc @@ -662,8 +662,8 @@ Ipv6RipngSplitHorizonStrategyTest::DoRun (void) // Create the UDP sockets Ptr rxSocketFactory = listener->GetObject (); Ptr rxSocket = rxSocketFactory->CreateSocket (); - NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (Inet6SocketAddress (Ipv6Address ("ff02::9"), 521)), 0, "trivial"); rxSocket->BindToNetDevice (listenerDev); + NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (Inet6SocketAddress (Ipv6Address ("ff02::9"), 521)), 0, "trivial"); rxSocket->SetRecvCallback (MakeCallback (&Ipv6RipngSplitHorizonStrategyTest::ReceivePktProbe, this)); // ------ Now the tests ------------ diff --git a/src/network/model/socket.h b/src/network/model/socket.h index 2493acba900..8b6feb8cbc1 100644 --- a/src/network/model/socket.h +++ b/src/network/model/socket.h @@ -616,16 +616,13 @@ class Socket : public Object * is also possible to bind to mismatching device and address, even if * the socket can not receive any packets as a result. * - * \warning BindToNetDevice should be used \a after Bind. Otherwise - * it will perform a Bind itself. - * - * \param netdevice Pointer to Netdevice of desired interface + * \param netdevice Pointer to NetDevice of desired interface * \returns nothing */ virtual void BindToNetDevice (Ptr netdevice); /** - * \brief Returns socket's bound netdevice, if any. + * \brief Returns socket's bound NetDevice, if any. * * This method corresponds to using getsockopt() SO_BINDTODEVICE * of real network or BSD sockets. diff --git a/src/olsr/model/olsr-routing-protocol.cc b/src/olsr/model/olsr-routing-protocol.cc index 768df682c73..1c316882c46 100644 --- a/src/olsr/model/olsr-routing-protocol.cc +++ b/src/olsr/model/olsr-routing-protocol.cc @@ -368,11 +368,11 @@ void RoutingProtocol::DoInitialize () socket->SetAllowBroadcast (true); InetSocketAddress inetAddr (m_ipv4->GetAddress (i, 0).GetLocal (), OLSR_PORT_NUMBER); socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvOlsr, this)); + socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); if (socket->Bind (inetAddr)) { NS_FATAL_ERROR ("Failed to bind() OLSR socket"); } - socket->BindToNetDevice (m_ipv4->GetNetDevice (i)); socket->SetRecvPktInfo (true); m_sendSockets[socket] = m_ipv4->GetAddress (i, 0); diff --git a/src/wave/model/bsm-application.cc b/src/wave/model/bsm-application.cc index e912641ea54..3c46bdcd11a 100644 --- a/src/wave/model/bsm-application.cc +++ b/src/wave/model/bsm-application.cc @@ -101,8 +101,8 @@ void BsmApplication::StartApplication () // Called at time specified by Start Ptr recvSink = Socket::CreateSocket (GetNode (m_nodeId), tid); recvSink->SetRecvCallback (MakeCallback (&BsmApplication::ReceiveWavePacket, this)); InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), wavePort); - recvSink->Bind (local); recvSink->BindToNetDevice (GetNetDevice (m_nodeId)); + recvSink->Bind (local); recvSink->SetAllowBroadcast (true); // dest is broadcast address From ab356654ca8b670bc4982ad0fae9c97672fa970a Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 13 Jul 2017 12:54:17 +0300 Subject: [PATCH 146/551] lte: Simplify operator > of SequenceNumber10 --- src/lte/model/lte-rlc-sequence-number.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/lte/model/lte-rlc-sequence-number.h b/src/lte/model/lte-rlc-sequence-number.h index 2106a9191e9..e2d835fcc1e 100644 --- a/src/lte/model/lte-rlc-sequence-number.h +++ b/src/lte/model/lte-rlc-sequence-number.h @@ -153,9 +153,9 @@ class SequenceNumber10 */ bool operator > (const SequenceNumber10 &other) const { - SequenceNumber10 v1 ((m_value - m_modulusBase) % 1024); - SequenceNumber10 v2 ((other.m_value - other.m_modulusBase) % 1024); - return ( v1.GetValue () > v2.GetValue () ); + uint16_t v1 = (m_value - m_modulusBase) % 1024; + uint16_t v2 = (other.m_value - other.m_modulusBase) % 1024; + return v1 > v2; } /** From 77b2ad8c7b077960326f2345eb83cf27882dea14 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 13 Jul 2017 13:31:59 +0300 Subject: [PATCH 147/551] lte: Assert that compared SequenceNumber10 have the same base --- src/lte/model/lte-rlc-sequence-number.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/lte/model/lte-rlc-sequence-number.h b/src/lte/model/lte-rlc-sequence-number.h index e2d835fcc1e..91268d89f57 100644 --- a/src/lte/model/lte-rlc-sequence-number.h +++ b/src/lte/model/lte-rlc-sequence-number.h @@ -21,6 +21,8 @@ #ifndef LTE_RLC_SEQUENCE_NUMBER_H #define LTE_RLC_SEQUENCE_NUMBER_H +#include + #include #include #include @@ -153,6 +155,7 @@ class SequenceNumber10 */ bool operator > (const SequenceNumber10 &other) const { + NS_ASSERT (m_modulusBase == other.m_modulusBase); uint16_t v1 = (m_value - m_modulusBase) % 1024; uint16_t v2 = (other.m_value - other.m_modulusBase) % 1024; return v1 > v2; From 4474e760641e6bd306b6f440ede307446a918657 Mon Sep 17 00:00:00 2001 From: Junling Bu Date: Thu, 13 Jul 2017 22:31:43 -0700 Subject: [PATCH 148/551] fix Doxygen typo --- src/internet-apps/helper/v4ping-helper.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/internet-apps/helper/v4ping-helper.h b/src/internet-apps/helper/v4ping-helper.h index 34d439a896e..524abcd2a8f 100644 --- a/src/internet-apps/helper/v4ping-helper.h +++ b/src/internet-apps/helper/v4ping-helper.h @@ -29,7 +29,7 @@ namespace ns3 { /** * \ingroup v4ping - * \brief Create a IPv5 ping application and associate it to a node + * \brief Create a IPv4 ping application and associate it to a node * * This class creates one or multiple instances of ns3::V4Ping and associates * it/them to one/multiple node(s). From 16b177df77eeeb17ba201137ec68dbab66e15576 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 5 Jun 2017 13:43:06 +0300 Subject: [PATCH 149/551] lte: Simplify fix for #2731 (changeset 39839e91252e) --- src/lte/model/lte-rlc-am.cc | 71 ++++++++----------------------------- 1 file changed, 15 insertions(+), 56 deletions(-) diff --git a/src/lte/model/lte-rlc-am.cc b/src/lte/model/lte-rlc-am.cc index 9874eb7ab13..980b5666725 100644 --- a/src/lte/model/lte-rlc-am.cc +++ b/src/lte/model/lte-rlc-am.cc @@ -1689,63 +1689,22 @@ LteRlcAm::ExpirePollRetransmitTimer (void) || (m_vtS == m_vtMs)) { NS_LOG_INFO ("txonBuffer and retxBuffer empty. Move PDUs up to = " << m_vtS.GetValue () - 1 << " to retxBuffer"); - uint16_t sn = 0; - uint16_t acked = m_vtA.GetValue(); - uint16_t sent = m_vtS.GetValue (); - if(acked <= sent) //If no overflow, no change. + for (SequenceNumber10 sn = m_vtA; sn < m_vtS; sn++) { - for ( sn = m_vtA.GetValue(); sn < m_vtS.GetValue (); sn++ ) - { - bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; - - if ( pduAvailable ) - { - NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); - m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); - m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; - m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); - - m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); - m_txedBuffer.at (sn).m_pdu = 0; - m_txedBuffer.at (sn).m_retxCount = 0; - } - } - } - else//If overflow happened, we retransmit from acked sequence to 1023, then from 0 to sent sequence. - { - for ( sn = m_vtA.GetValue(); sn < 1024; sn++ ) - { - bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; - - if ( pduAvailable ) - { - NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); - m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); - m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; - m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); - - m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); - m_txedBuffer.at (sn).m_pdu = 0; - m_txedBuffer.at (sn).m_retxCount = 0; - } - } - - for ( sn = 0; sn < m_vtS.GetValue (); sn++ ) - { - bool pduAvailable = m_txedBuffer.at (sn).m_pdu != 0; - - if ( pduAvailable ) - { - NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); - m_retxBuffer.at (sn).m_pdu = m_txedBuffer.at (sn).m_pdu->Copy (); - m_retxBuffer.at (sn).m_retxCount = m_txedBuffer.at (sn).m_retxCount; - m_retxBufferSize += m_retxBuffer.at (sn).m_pdu->GetSize (); - - m_txedBufferSize -= m_txedBuffer.at (sn).m_pdu->GetSize (); - m_txedBuffer.at (sn).m_pdu = 0; - m_txedBuffer.at (sn).m_retxCount = 0; - } - } + bool pduAvailable = m_txedBuffer.at (sn.GetValue ()).m_pdu != 0; + + if ( pduAvailable ) + { + uint16_t snValue = sn.GetValue (); + NS_LOG_INFO ("Move PDU " << sn << " from txedBuffer to retxBuffer"); + m_retxBuffer.at (snValue).m_pdu = m_txedBuffer.at (snValue).m_pdu->Copy (); + m_retxBuffer.at (snValue).m_retxCount = m_txedBuffer.at (snValue).m_retxCount; + m_retxBufferSize += m_retxBuffer.at (snValue).m_pdu->GetSize (); + + m_txedBufferSize -= m_txedBuffer.at (snValue).m_pdu->GetSize (); + m_txedBuffer.at (snValue).m_pdu = 0; + m_txedBuffer.at (snValue).m_retxCount = 0; + } } } From b3e84511866aa501d9918edbdb8c870532bc764e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 6 Jun 2017 20:05:04 +0300 Subject: [PATCH 150/551] lte: Add m_componentCarrierId to UeManager to track primary CC --- src/lte/model/lte-enb-rrc.cc | 1 + src/lte/model/lte-enb-rrc.h | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index c2377e633fa..7e6280bca35 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -143,6 +143,7 @@ UeManager::UeManager (Ptr rrc, uint16_t rnti, State s) : m_lastAllocatedDrbid (0), m_rnti (rnti), m_imsi (0), + m_componentCarrierId (0), m_lastRrcTransactionIdentifier (0), m_rrc (rrc), m_state (s), diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 49a6113dd0f..2799d51d912 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -488,6 +488,10 @@ class UeManager : public Object * unique UE identifier. */ uint64_t m_imsi; + /** + * ID of the primary CC for this UE + */ + uint8_t m_componentCarrierId; uint8_t m_lastRrcTransactionIdentifier; ///< last RRC transaction identifier From 29b3a4822d0ad2d97ddee64c6799fec308857573 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 6 Jun 2017 20:15:54 +0300 Subject: [PATCH 151/551] lte: Use m_componentCarrierId --- src/lte/model/lte-enb-rrc.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 7e6280bca35..c82e871b234 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -251,7 +251,7 @@ UeManager::DoInitialize () // MacSapUserForRlc in the ComponentCarrierManager MacSapUser LteMacSapUser* MacSapUserForRlc = m_rrc->m_ccmRrcSapProvider->ConfigureSignalBearer(lcinfo, rlc->GetLteMacSapUser ()); // Signal Channel are only on Primary Carrier - m_rrc->m_cmacSapProvider.at (0)->AddLc (lcinfo, MacSapUserForRlc); + m_rrc->m_cmacSapProvider.at (m_componentCarrierId)->AddLc (lcinfo, MacSapUserForRlc); m_rrc->m_ccmRrcSapProvider->AddLc (lcinfo, MacSapUserForRlc); } @@ -605,7 +605,7 @@ UeManager::PrepareHandover (uint16_t cellId) hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity = m_rrc->m_cellId; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication = m_rrc->m_sib1.cellAccessRelatedInfo.csgIndication; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = m_rrc->m_sib1.cellAccessRelatedInfo.csgIdentity; - LteEnbCmacSapProvider::RachConfig rc = m_rrc->m_cmacSapProvider.at (0)->GetRachConfig (); + LteEnbCmacSapProvider::RachConfig rc = m_rrc->m_cmacSapProvider.at (m_componentCarrierId)->GetRachConfig (); hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.raResponseWindowSize = rc.raResponseWindowSize; From 78a71372d02f116e38392509d7245b9b0dae0974 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 15:41:01 +0300 Subject: [PATCH 152/551] lte: Make PathlossModel attribute a TypeId instead of String --- src/lte/helper/lte-helper.cc | 8 ++++---- src/lte/helper/lte-helper.h | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index f4deab50252..b75b9135cd0 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -141,9 +141,9 @@ TypeId LteHelper::GetTypeId (void) "The type of pathloss model to be used. " "The allowed values for this attributes are the type names " "of any class inheriting from ns3::PropagationLossModel.", - StringValue ("ns3::FriisPropagationLossModel"), - MakeStringAccessor (&LteHelper::SetPathlossModelType), - MakeStringChecker ()) + TypeIdValue (FriisPropagationLossModel::GetTypeId ()), + MakeTypeIdAccessor (&LteHelper::SetPathlossModelType), + MakeTypeIdChecker ()) .AddAttribute ("FadingModel", "The type of fading model to be used." "The allowed values for this attributes are the type names " @@ -385,7 +385,7 @@ LteHelper::SetUeComponentCarrierManagerAttribute (std::string n, const Attribute } void -LteHelper::SetPathlossModelType (std::string type) +LteHelper::SetPathlossModelType (TypeId type) { NS_LOG_FUNCTION (this << type); m_pathlossModelFactory = ObjectFactory (); diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index 0508765a873..946a3266a1e 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -134,7 +134,7 @@ class LteHelper : public Object * inheriting from ns3::PropagationLossModel, for example: * "ns3::FriisPropagationLossModel" */ - void SetPathlossModelType (std::string type); + void SetPathlossModelType (TypeId type); /** * Set an attribute for the path loss models to be created. From 6816e8a8d6ed1e5d313cd35b70f484744f3c8002 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 15:50:33 +0300 Subject: [PATCH 153/551] lte: Remove limit of 2 on number of CCs --- src/lte/model/lte-enb-rrc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index c82e871b234..9ba690f9579 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1660,7 +1660,7 @@ LteEnbRrc::GetTypeId (void) "Number of Component Carriers ", UintegerValue (1), MakeIntegerAccessor (&LteEnbRrc::m_numberOfComponentCarriers), - MakeIntegerChecker (MIN_NO_CC, 2)) // to change, currently the CC number is liited to 2 + MakeIntegerChecker (MIN_NO_CC, MAX_NO_CC)) // Handover related attributes .AddAttribute ("AdmitHandoverRequest", From 64fe2ac28a419e47a1cd000061fcf5664a5f22f8 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 15:54:09 +0300 Subject: [PATCH 154/551] lte: Remove redundant numberOfCarriers argument from LteEnbRrc::ConfigureCarriers --- src/lte/helper/lte-helper.cc | 2 +- src/lte/model/lte-enb-rrc.cc | 33 ++++++++++++--------------------- src/lte/model/lte-enb-rrc.h | 3 +-- 3 files changed, 14 insertions(+), 24 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index b75b9135cd0..57d360d4922 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -592,7 +592,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) Ptr rrc = CreateObject (); Ptr ccmEnbManager = m_enbComponentCarrierManagerFactory.Create (); - rrc->ConfigureCarriers(ccMap, m_noOfCcs); + rrc->ConfigureCarriers (ccMap); //ComponentCarrierManager SAP rrc->SetLteCcmRrcSapProvider (ccmEnbManager->GetLteCcmRrcSapProvider ()); diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 9ba690f9579..bdffd6d39ca 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1496,33 +1496,24 @@ LteEnbRrc::LteEnbRrc () m_ffrRrcSapProvider.push_back (0); } -void LteEnbRrc::ConfigureCarriers(std::map> ccPhyConf, uint16_t numberOfComponentCarriers) +void +LteEnbRrc::ConfigureCarriers (std::map> ccPhyConf) { NS_ASSERT_MSG (!m_carriersConfigured, "Secondary carriers can be configured only once."); m_componentCarrierPhyConf = ccPhyConf; - m_numberOfComponentCarriers = numberOfComponentCarriers; + m_numberOfComponentCarriers = ccPhyConf.size (); + + NS_ASSERT (m_numberOfComponentCarriers >= MIN_NO_CC && m_numberOfComponentCarriers <= MAX_NO_CC); - if (m_numberOfComponentCarriers < MIN_NO_CC || m_numberOfComponentCarriers > MAX_NO_CC) + for (uint8_t i = 1; i < m_numberOfComponentCarriers; i++) { - // this check is neede in order to maintain backward compatibility with scripts and tests - // if case lte-helper is not used (like in several tests) the m_numberOfComponentCarriers - // is not set and then an error is rised - // In this case m_numberOfComponentCarriers is set to 1 - m_numberOfComponentCarriers = MIN_NO_CC; + m_cphySapUser.push_back (new MemberLteEnbCphySapUser (this)); + m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this)); + m_ffrRrcSapUser.push_back (new MemberLteFfrRrcSapUser (this)); + m_cphySapProvider.push_back (0); + m_cmacSapProvider.push_back (0); + m_ffrRrcSapProvider.push_back (0); } - - if (m_numberOfComponentCarriers > MIN_NO_CC) - { - for ( uint8_t i = 1; i < m_numberOfComponentCarriers ; i++) - { - m_cphySapUser.push_back (new MemberLteEnbCphySapUser (this)); - m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this)); - m_ffrRrcSapUser.push_back (new MemberLteFfrRrcSapUser (this)); - m_cphySapProvider.push_back (0); - m_cmacSapProvider.push_back (0); - m_ffrRrcSapProvider.push_back (0); - } - } m_carriersConfigured = true; Object::DoInitialize (); } diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 2799d51d912..a61dd896fb1 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -855,9 +855,8 @@ class LteEnbRrc : public Object /** * \brief Configure carriers. * \param ccPhyConf the component carrier configuration - * \param numberOfCarriers the number of carriers */ - void ConfigureCarriers (std::map> ccPhyConf, uint16_t numberOfCarriers); + void ConfigureCarriers (std::map> ccPhyConf); /** * set the cell id of this eNB From b80a732f2d389f936f94ef6b661c6209e1525c12 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 15:57:52 +0300 Subject: [PATCH 155/551] lte: Assert that number of CCs and size of CC map match --- src/lte/helper/lte-helper.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index 57d360d4922..14b5f54cb72 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -540,6 +540,7 @@ LteHelper::InstallSingleEnbDevice (Ptr n) ccMap [it->first] = cc; } NS_ABORT_MSG_IF (m_useCa && ccMap.size()<2, "You have to either specify carriers or disable carrier aggregation"); + NS_ASSERT (ccMap.size () == m_noOfCcs); for (std::map >::iterator it = ccMap.begin (); it != ccMap.end (); ++it) { From 9c95cd7c1b536c0242315073c5100336f118c3cc Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 16:14:46 +0300 Subject: [PATCH 156/551] lte: Assign different Cell IDs to different CCs --- src/lte/helper/lte-helper.cc | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index 14b5f54cb72..213e5253202 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -78,7 +78,7 @@ NS_OBJECT_ENSURE_REGISTERED (LteHelper); LteHelper::LteHelper (void) : m_fadingStreamsAssigned (false), m_imsiCounter (0), - m_cellIdCounter (0) + m_cellIdCounter {1} { NS_LOG_FUNCTION (this); m_enbNetDeviceFactory.SetTypeId (LteEnbNetDevice::GetTypeId ()); @@ -513,9 +513,7 @@ LteHelper::InstallUeDevice (NodeContainer c) Ptr LteHelper::InstallSingleEnbDevice (Ptr n) { - - NS_ABORT_MSG_IF (m_cellIdCounter == 65535, "max num eNBs exceeded"); - uint16_t cellId = ++m_cellIdCounter; + uint16_t cellId = m_cellIdCounter; // \todo Remove, eNB has no cell ID Ptr dev = m_enbNetDeviceFactory.Create (); Ptr handoverAlgorithm = m_handoverAlgorithmFactory.Create (); @@ -536,7 +534,8 @@ LteHelper::InstallSingleEnbDevice (Ptr n) cc->SetDlEarfcn(it->second.GetDlEarfcn()); cc->SetUlEarfcn(it->second.GetUlEarfcn()); cc->SetAsPrimary(it->second.IsPrimary()); - cc->SetCellId (cellId); + NS_ABORT_MSG_IF (m_cellIdCounter == 65535, "max num cells exceeded"); + cc->SetCellId (m_cellIdCounter++); ccMap [it->first] = cc; } NS_ABORT_MSG_IF (m_useCa && ccMap.size()<2, "You have to either specify carriers or disable carrier aggregation"); From 1cf7c74ee0b557f20fc8416a4fb1bdfbba4edea9 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 7 Jun 2017 17:37:34 +0300 Subject: [PATCH 157/551] lte: Skip primary CC instead of first in UeManager::BuildNonCriticalExtentionConfigurationCa --- src/lte/model/lte-enb-rrc.cc | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index bdffd6d39ca..ad8c283d9e8 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1399,14 +1399,18 @@ UeManager::BuildNonCriticalExtentionConfigurationCa () std::list SccCon; // sCellToReleaseList is always empty since no Scc is released - auto it = m_rrc->m_componentCarrierPhyConf.begin(); - it++; - for (;it!=m_rrc->m_componentCarrierPhyConf.end(); it++) + for (auto &it: m_rrc->m_componentCarrierPhyConf) { + uint8_t ccId = it.first; - uint8_t ccId = it->first; - Ptr eNbCcm = it->second; + // Skip primary CC. + if (ccId == m_componentCarrierId) + { + continue; + } + + Ptr eNbCcm = it.second; LteRrcSap::SCellToAddMod component; component.sCellIndex = ccId; component.cellIdentification.physCellId = eNbCcm->GetCellId (); From b9842ebe43ab83943b77aa7e5293040bd7d1ff49 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 8 Jun 2017 18:30:23 +0300 Subject: [PATCH 158/551] lte: Add LteEnbRrc::CellToComponentCarrierId --- src/lte/model/lte-enb-rrc.cc | 14 ++++++++++++++ src/lte/model/lte-enb-rrc.h | 9 +++++++++ 2 files changed, 23 insertions(+) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index ad8c283d9e8..08e29fec49a 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -2099,6 +2099,20 @@ LteEnbRrc::SetCellId (uint16_t cellId, uint8_t ccIndex) m_cphySapProvider[ccIndex]->SetSystemInformationBlockType1 (m_sib1); } +uint8_t +LteEnbRrc::CellToComponentCarrierId (uint16_t cellId) +{ + NS_LOG_FUNCTION (this << cellId); + for (auto &it: m_componentCarrierPhyConf) + { + if (it.second->GetCellId () == cellId) + { + return it.first; + } + } + NS_FATAL_ERROR ("Cell " << cellId << " not found in CC map"); +} + bool LteEnbRrc::SendData (Ptr packet) { diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index a61dd896fb1..0aaaa2881b9 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -873,6 +873,15 @@ class LteEnbRrc : public Object */ void SetCellId (uint16_t m_cellId, uint8_t ccIndex); + /** + * convert the cell id to component carrier id + * + * \param cellId Cell ID + * + * \return corresponding component carrier id + */ + uint8_t CellToComponentCarrierId (uint16_t cellId); + /** * Enqueue an IP data packet on the proper bearer for downlink * transmission. Normally expected to be called by the NetDevice From 3ab6a5680bc4ec2d541e0e1d998d2ed640d2e746 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 8 Jun 2017 18:30:34 +0300 Subject: [PATCH 159/551] lte: Set CC id of UeManager to the serial number of EnbRrcMemberLteEnbCmacSapUser --- src/lte/model/lte-enb-rrc.cc | 28 +++++++++++++++------------- src/lte/model/lte-enb-rrc.h | 9 ++++++--- 2 files changed, 21 insertions(+), 16 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 08e29fec49a..e4ced6ef8fb 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -65,7 +65,7 @@ class EnbRrcMemberLteEnbCmacSapUser : public LteEnbCmacSapUser * * \param rrc ENB RRC */ - EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc); + EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc, uint8_t componentCarrierId); virtual uint16_t AllocateTemporaryCellRnti (); virtual void NotifyLcConfigResult (uint16_t rnti, uint8_t lcid, bool success); @@ -73,17 +73,19 @@ class EnbRrcMemberLteEnbCmacSapUser : public LteEnbCmacSapUser private: LteEnbRrc* m_rrc; ///< the RRC + uint8_t m_componentCarrierId; ///< Component carrier ID }; -EnbRrcMemberLteEnbCmacSapUser::EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc) +EnbRrcMemberLteEnbCmacSapUser::EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc, uint8_t componentCarrierId) : m_rrc (rrc) + , m_componentCarrierId {componentCarrierId} { } uint16_t EnbRrcMemberLteEnbCmacSapUser::AllocateTemporaryCellRnti () { - return m_rrc->DoAllocateTemporaryCellRnti (); + return m_rrc->DoAllocateTemporaryCellRnti (m_componentCarrierId); } void @@ -139,11 +141,11 @@ UeManager::UeManager () } -UeManager::UeManager (Ptr rrc, uint16_t rnti, State s) +UeManager::UeManager (Ptr rrc, uint16_t rnti, State s, uint8_t componentCarrierId) : m_lastAllocatedDrbid (0), m_rnti (rnti), m_imsi (0), - m_componentCarrierId (0), + m_componentCarrierId (componentCarrierId), m_lastRrcTransactionIdentifier (0), m_rrc (rrc), m_state (s), @@ -1486,7 +1488,7 @@ LteEnbRrc::LteEnbRrc () m_carriersConfigured (false) { NS_LOG_FUNCTION (this); - m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this)); + m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this, 0)); m_handoverManagementSapUser = new MemberLteHandoverManagementSapUser (this); m_anrSapUser = new MemberLteAnrSapUser (this); m_ffrRrcSapUser.push_back (new MemberLteFfrRrcSapUser (this)); @@ -1512,7 +1514,7 @@ LteEnbRrc::ConfigureCarriers (std::map> ccPhyC for (uint8_t i = 1; i < m_numberOfComponentCarriers; i++) { m_cphySapUser.push_back (new MemberLteEnbCphySapUser (this)); - m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this)); + m_cmacSapUser.push_back (new EnbRrcMemberLteEnbCmacSapUser (this, i)); m_ffrRrcSapUser.push_back (new MemberLteFfrRrcSapUser (this)); m_cphySapProvider.push_back (0); m_cmacSapProvider.push_back (0); @@ -2280,7 +2282,7 @@ LteEnbRrc::DoRecvHandoverRequest (EpcX2SapUser::HandoverRequestParams req) return; } - uint16_t rnti = AddUe (UeManager::HANDOVER_JOINING); + uint16_t rnti = AddUe (UeManager::HANDOVER_JOINING, CellToComponentCarrierId (req.targetCellId)); LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue anrcrv = m_cmacSapProvider.at (0)->AllocateNcRaPreamble (rnti); if (anrcrv.valid == false) { @@ -2460,10 +2462,10 @@ LteEnbRrc::DoRecvUeData (EpcX2SapUser::UeDataParams params) uint16_t -LteEnbRrc::DoAllocateTemporaryCellRnti () +LteEnbRrc::DoAllocateTemporaryCellRnti (uint8_t componentCarrierId) { - NS_LOG_FUNCTION (this); - return AddUe (UeManager::INITIAL_RANDOM_ACCESS); + NS_LOG_FUNCTION (this << +componentCarrierId); + return AddUe (UeManager::INITIAL_RANDOM_ACCESS, componentCarrierId); } void @@ -2576,7 +2578,7 @@ LteEnbRrc::DoSendLoadInformation (EpcX2Sap::LoadInformationParams params) } uint16_t -LteEnbRrc::AddUe (UeManager::State state) +LteEnbRrc::AddUe (UeManager::State state, uint8_t componentCarrierId) { NS_LOG_FUNCTION (this); bool found = false; @@ -2594,7 +2596,7 @@ LteEnbRrc::AddUe (UeManager::State state) NS_ASSERT_MSG (found, "no more RNTIs available (do you have more than 65535 UEs in a cell?)"); m_lastAllocatedRnti = rnti; - Ptr ueManager = CreateObject (this, rnti, state); + Ptr ueManager = CreateObject (this, rnti, state, componentCarrierId); m_ccmRrcSapProvider-> AddUe (rnti, (uint8_t)state); m_ueMap.insert (std::pair > (rnti, ueManager)); ueManager->Initialize (); diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 0aaaa2881b9..c4460af438f 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -104,10 +104,11 @@ class UeManager : public Object * \param rrc pointer to the LteEnbRrc holding this UeManager * \param rnti RNTI of the UE * \param s initial state of the UeManager + * \param componentCarrierId primary component carrier ID * * \return */ - UeManager (Ptr rrc, uint16_t rnti, State s); + UeManager (Ptr rrc, uint16_t rnti, State s, uint8_t componentCarrierId); virtual ~UeManager (void); @@ -1140,9 +1141,10 @@ class LteEnbRrc : public Object /** * Allocate temporary cell RNTI function * + * \param componentCarrierId ID of the primary component carrier * \return temporary RNTI */ - uint16_t DoAllocateTemporaryCellRnti (); + uint16_t DoAllocateTemporaryCellRnti (uint8_t componentCarrierId); /** * Notify LC config result function * @@ -1223,10 +1225,11 @@ class LteEnbRrc : public Object * * target cell RNTI allocation upon handover * * \param state the initial state of the UeManager + * \param componentCarrierId primary component carrier ID of the UeManager * * \return the newly allocated RNTI */ - uint16_t AddUe (UeManager::State state); + uint16_t AddUe (UeManager::State state, uint8_t componentCarrierId); /** * remove a UE from the cell From 8e73f66586ab24e009f549568f140ca4eb1c8129 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 8 Jun 2017 15:46:34 +0300 Subject: [PATCH 160/551] lte: Keep one SIB1 per component carrier in LteEnbRrc Each SIB1 has its own bandwidth cell ID. --- src/lte/model/lte-enb-rrc.cc | 53 ++++++++++++++++++++---------------- src/lte/model/lte-enb-rrc.h | 2 +- 2 files changed, 31 insertions(+), 24 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index e4ced6ef8fb..479e8a17cb1 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -603,10 +603,10 @@ UeManager::PrepareHandover (uint16_t cellId) hpi.asConfig.sourceRadioResourceConfig = GetRadioResourceConfigForHandoverPreparationInfo (); hpi.asConfig.sourceMasterInformationBlock.dlBandwidth = m_rrc->m_dlBandwidth; hpi.asConfig.sourceMasterInformationBlock.systemFrameNumber = 0; - hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = m_rrc->m_sib1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity; + hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity = m_rrc->m_cellId; - hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication = m_rrc->m_sib1.cellAccessRelatedInfo.csgIndication; - hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = m_rrc->m_sib1.cellAccessRelatedInfo.csgIdentity; + hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.csgIndication; + hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.csgIdentity; LteEnbCmacSapProvider::RachConfig rc = m_rrc->m_cmacSapProvider.at (m_componentCarrierId)->GetRachConfig (); hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; hpi.asConfig.sourceSystemInformationBlockType2.radioResourceConfigCommon.rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; @@ -2052,22 +2052,26 @@ LteEnbRrc::ConfigureCell (std::map> ccPhyConf) m_ueMeasConfig.haveSmeasure = false; m_ueMeasConfig.haveSpeedStatePars = false; - // Enabling MIB transmission - LteRrcSap::MasterInformationBlock mib; - mib.dlBandwidth = m_dlBandwidth; - mib.systemFrameNumber = 0; - // Enabling SIB1 transmission with default values - m_sib1.cellAccessRelatedInfo.cellIdentity = cellId; - m_sib1.cellAccessRelatedInfo.csgIndication = false; - m_sib1.cellAccessRelatedInfo.csgIdentity = 0; - m_sib1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = 0; // not used - m_sib1.cellSelectionInfo.qQualMin = -34; // not used, set as minimum value - m_sib1.cellSelectionInfo.qRxLevMin = m_qRxLevMin; // set as minimum value - + m_sib1.clear (); + m_sib1.reserve (ccPhyConf.size ()); for (const auto &it: ccPhyConf) { + // Enabling MIB transmission + LteRrcSap::MasterInformationBlock mib; + mib.dlBandwidth = it.second->GetDlBandwidth (); + mib.systemFrameNumber = 0; m_cphySapProvider.at (it.first)->SetMasterInformationBlock (mib); - m_cphySapProvider.at (it.first)->SetSystemInformationBlockType1 (m_sib1); + + // Enabling SIB1 transmission with default values + LteRrcSap::SystemInformationBlockType1 sib1; + sib1.cellAccessRelatedInfo.cellIdentity = it.second->GetCellId (); + sib1.cellAccessRelatedInfo.csgIndication = false; + sib1.cellAccessRelatedInfo.csgIdentity = 0; + sib1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = 0; // not used + sib1.cellSelectionInfo.qQualMin = -34; // not used, set as minimum value + sib1.cellSelectionInfo.qRxLevMin = m_qRxLevMin; // set as minimum value + m_sib1.push_back (sib1); + m_cphySapProvider.at (it.first)->SetSystemInformationBlockType1 (sib1); } /* * Enabling transmission of other SIB. The first time System Information is @@ -2088,8 +2092,8 @@ LteEnbRrc::SetCellId (uint16_t cellId) m_cellId = cellId; // update SIB1 too - m_sib1.cellAccessRelatedInfo.cellIdentity = cellId; - m_cphySapProvider.at (0)->SetSystemInformationBlockType1 (m_sib1); + m_sib1.at (0).cellAccessRelatedInfo.cellIdentity = cellId; + m_cphySapProvider.at (0)->SetSystemInformationBlockType1 (m_sib1.at (0)); } void @@ -2097,8 +2101,8 @@ LteEnbRrc::SetCellId (uint16_t cellId, uint8_t ccIndex) { m_cellId = cellId; // update SIB1 too - m_sib1.cellAccessRelatedInfo.cellIdentity = cellId; - m_cphySapProvider[ccIndex]->SetSystemInformationBlockType1 (m_sib1); + m_sib1.at (ccIndex).cellAccessRelatedInfo.cellIdentity = cellId; + m_cphySapProvider.at (ccIndex)->SetSystemInformationBlockType1 (m_sib1.at (ccIndex)); } uint8_t @@ -2677,9 +2681,12 @@ void LteEnbRrc::SetCsgId (uint32_t csgId, bool csgIndication) { NS_LOG_FUNCTION (this << csgId << csgIndication); - m_sib1.cellAccessRelatedInfo.csgIdentity = csgId; - m_sib1.cellAccessRelatedInfo.csgIndication = csgIndication; - m_cphySapProvider.at (0)->SetSystemInformationBlockType1 (m_sib1); + for (uint8_t componentCarrierId = 0; componentCarrierId < m_sib1.size (); componentCarrierId++) + { + m_sib1.at (componentCarrierId).cellAccessRelatedInfo.csgIdentity = csgId; + m_sib1.at (componentCarrierId).cellAccessRelatedInfo.csgIndication = csgIndication; + m_cphySapProvider.at (componentCarrierId)->SetSystemInformationBlockType1 (m_sib1.at (componentCarrierId)); + } } void diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index c4460af438f..f94ec65c372 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -1413,7 +1413,7 @@ class LteEnbRrc : public Object uint16_t m_lastAllocatedRnti; /// The System Information Block Type 1 that is currently broadcasted over BCH. - LteRrcSap::SystemInformationBlockType1 m_sib1; + std::vector m_sib1; /** * The `UeMap` attribute. List of UeManager by C-RNTI. From 66be4b489e48edb7583fd1338c7ec305dc39c4b4 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 9 Jun 2017 14:04:14 +0300 Subject: [PATCH 161/551] lte: Fix NonCriticalExtension serialization Range for EARFCN is from 0 to MAX_EARFCN and range for PCI is from 1 to 65536 --- src/lte/model/lte-rrc-header.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 543aa2184d8..1af4422d450 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1740,7 +1740,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const cellIdentification_r10.set(0,1); // dl-CarrierFreq-r10 SerializeSequence (cellIdentification_r10, false); - SerializeInteger (it->cellIdentification.physCellId,1,MAX_EARFCN); + SerializeInteger (it->cellIdentification.physCellId,1,65536); SerializeInteger (it->cellIdentification.dlCarrierFreq,1,MAX_EARFCN); //Serialize RadioResourceConfigCommonSCell @@ -2634,7 +2634,7 @@ RrcAsn1Header::Print (std::ostream &os) const bIterator = DeserializeInteger (&n1,1,65536,bIterator); ci->physCellId = n1; int n2; - bIterator = DeserializeInteger (&n2,1,65536,bIterator); + bIterator = DeserializeInteger (&n2,1,MAX_EARFCN,bIterator); ci->dlCarrierFreq = n2; return bIterator; From 43ae267d6a9e5e449fd501758a4f31dab50be5ff Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 9 Jun 2017 15:32:38 +0300 Subject: [PATCH 162/551] lte: Test that UE can attach to any cell in cross-CC scenario --- .../test/lte-test-secondary-cell-selection.cc | 196 ++++++++++++++++++ .../test/lte-test-secondary-cell-selection.h | 113 ++++++++++ src/lte/wscript | 1 + 3 files changed, 310 insertions(+) create mode 100644 src/lte/test/lte-test-secondary-cell-selection.cc create mode 100644 src/lte/test/lte-test-secondary-cell-selection.h diff --git a/src/lte/test/lte-test-secondary-cell-selection.cc b/src/lte/test/lte-test-secondary-cell-selection.cc new file mode 100644 index 00000000000..7ab33435635 --- /dev/null +++ b/src/lte/test/lte-test-secondary-cell-selection.cc @@ -0,0 +1,196 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 Alexander Krotov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Alexander Krotov + * + */ + +#include "lte-test-secondary-cell-selection.h" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ns3; + +NS_LOG_COMPONENT_DEFINE ("LteSecondaryCellSelectionTest"); + +/* + * Test Suite + */ + +LteSecondaryCellSelectionTestSuite::LteSecondaryCellSelectionTestSuite () + : TestSuite ("lte-secondary-cell-selection", SYSTEM) +{ + // REAL RRC PROTOCOL + + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, real RRC, RngRun=1", false, 1), TestCase::QUICK); + + // IDEAL RRC PROTOCOL + + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, ideal RRC, RngRun=1", true, 1), TestCase::QUICK); + +} // end of LteSecondaryCellSelectionTestSuite::LteSecondaryCellSelectionTestSuite () + +static LteSecondaryCellSelectionTestSuite g_lteSecondaryCellSelectionTestSuite; + +/* + * Test Case + */ + +LteSecondaryCellSelectionTestCase::LteSecondaryCellSelectionTestCase ( + std::string name, bool isIdealRrc, int64_t rngRun) + : TestCase (name), + m_isIdealRrc (isIdealRrc), + m_rngRun (rngRun) +{ + NS_LOG_FUNCTION (this << GetName ()); +} + + +LteSecondaryCellSelectionTestCase::~LteSecondaryCellSelectionTestCase () +{ + NS_LOG_FUNCTION (this << GetName ()); +} + +void +LteSecondaryCellSelectionTestCase::DoRun () +{ + NS_LOG_FUNCTION (this << GetName ()); + + Config::SetGlobal ("RngRun", IntegerValue (m_rngRun)); + + // Create helpers. + auto lteHelper = CreateObject (); + lteHelper->SetAttribute ("PathlossModel", TypeIdValue (ns3::FriisSpectrumPropagationLossModel::GetTypeId ())); + lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (m_isIdealRrc)); + lteHelper->SetAttribute ("NumberOfComponentCarriers", UintegerValue (2)); + + auto epcHelper = CreateObject (); + lteHelper->SetEpcHelper (epcHelper); + + auto cch = CreateObject (); + cch->SetUlEarfcn (100 + 18000); + cch->SetDlEarfcn (100); + cch->SetUlBandwidth (25); + cch->SetDlBandwidth (25); + cch->SetNumberOfComponentCarriers (2); + + const auto ccm = cch->EquallySpacedCcs (); + lteHelper->SetCcPhyParams (ccm); + + // Create nodes. + auto enbNode = CreateObject (); + NodeContainer ueNodes; + ueNodes.Create (2); + + MobilityHelper mobility; + mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); + mobility.Install (enbNode); + mobility.Install (ueNodes); + + // Physical layer. + auto enbDev = DynamicCast (lteHelper->InstallEnbDevice (enbNode).Get (0)); + auto ueDevs = lteHelper->InstallUeDevice (ueNodes); + + // Network layer. + InternetStackHelper internet; + internet.Install (ueNodes); + epcHelper->AssignUeIpv4Address (ueDevs); + + for (auto &it: ccm) + { + std::cerr << "Assign " << it.second.GetDlEarfcn () << std::endl; + DynamicCast (ueDevs.Get (it.first))->SetDlEarfcn (it.second.GetDlEarfcn ()); + } + + // Enable Idle mode cell selection. + lteHelper->Attach (ueDevs); + + // Connect to trace sources in UEs + Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/StateTransition", + MakeCallback (&LteSecondaryCellSelectionTestCase::StateTransitionCallback, + this)); + Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/InitialSecondaryCellSelectionEndOk", + MakeCallback (&LteSecondaryCellSelectionTestCase::InitialSecondaryCellSelectionEndOkCallback, + this)); + Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/ConnectionEstablished", + MakeCallback (&LteSecondaryCellSelectionTestCase::ConnectionEstablishedCallback, + this)); + + // Run simulation. + Simulator::Stop (Seconds (2.0)); + Simulator::Run (); + + for (auto &it: enbDev->GetCcMap ()) + { + auto ueDev = DynamicCast (ueDevs.Get (it.first)); + uint16_t expectedCellId = it.second->GetCellId (); + uint16_t actualCellId = ueDev->GetRrc ()->GetCellId (); + NS_TEST_ASSERT_MSG_EQ (expectedCellId, actualCellId, "IMSI " << ueDev->GetImsi () << " has attached to an unexpected cell"); + + NS_TEST_ASSERT_MSG_EQ (m_lastState.at (ueDev->GetImsi ()), + LteUeRrc::CONNECTED_NORMALLY, + "UE " << ueDev->GetImsi () + << " is not at CONNECTED_NORMALLY state"); + } + + // Destroy simulator. + Simulator::Destroy (); +} // end of void LteSecondaryCellSelectionTestCase::DoRun () + + +void +LteSecondaryCellSelectionTestCase::StateTransitionCallback ( + std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti, + LteUeRrc::State oldState, LteUeRrc::State newState) +{ + NS_LOG_FUNCTION (this << imsi << cellId << rnti << oldState << newState); + m_lastState[imsi] = newState; +} + + +void +LteSecondaryCellSelectionTestCase::InitialSecondaryCellSelectionEndOkCallback ( + std::string context, uint64_t imsi, uint16_t cellId) +{ + NS_LOG_FUNCTION (this << imsi << cellId); +} + +void +LteSecondaryCellSelectionTestCase::ConnectionEstablishedCallback ( + std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti) +{ + NS_LOG_FUNCTION (this << imsi << cellId << rnti); +} diff --git a/src/lte/test/lte-test-secondary-cell-selection.h b/src/lte/test/lte-test-secondary-cell-selection.h new file mode 100644 index 00000000000..014c65b86a9 --- /dev/null +++ b/src/lte/test/lte-test-secondary-cell-selection.h @@ -0,0 +1,113 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 Alexander Krotov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Alexander Krotov + * + */ + +#ifndef LTE_TEST_SECONDARY_CELL_SELECTION_H +#define LTE_TEST_SECONDARY_CELL_SELECTION_H + +#include +#include +#include +#include +#include +#include + +using namespace ns3; + +/** + * \brief Test suite for executing the secondary cell selection test cases. + * + * \sa ns3::LteSecondaryCellSelectionTestCase + */ +class LteSecondaryCellSelectionTestSuite : public TestSuite +{ +public: + LteSecondaryCellSelectionTestSuite (); +}; + + + + +/** + * \ingroup lte + * + * \brief Testing the initial cell selection procedure by UE at IDLE state in + * the beginning of simulation with multiple component carriers. + */ +class LteSecondaryCellSelectionTestCase : public TestCase +{ +public: + /** + * \brief Creates an instance of the initial cell selection test case. + * \param name name of this test + * \param isIdealRrc if true, simulation uses Ideal RRC protocol, otherwise + * simulation uses Real RRC protocol + * \param rngRun the number of run to be used by the random number generator + */ + LteSecondaryCellSelectionTestCase (std::string name, bool isIdealRrc, int64_t rngRun); + + virtual ~LteSecondaryCellSelectionTestCase (); + +private: + /** + * \brief Setup the simulation according to the configuration set by the + * class constructor, run it, and verify the result. + */ + virtual void DoRun (); + + /** + * \brief State transition callback function + * \param context the context string + * \param imsi the IMSI + * \param cellId the cell ID + * \param rnti the RNTI + * \param oldState the old state + * \param newState the new state + */ + void StateTransitionCallback (std::string context, uint64_t imsi, + uint16_t cellId, uint16_t rnti, + LteUeRrc::State oldState, LteUeRrc::State newState); + /** + * \brief Initial cell selection end ok callback function + * \param context the context string + * \param imsi the IMSI + * \param cellId the cell ID + */ + void InitialSecondaryCellSelectionEndOkCallback (std::string context, uint64_t imsi, + uint16_t cellId); + /** + * \brief Connection established callback function + * \param context the context string + * \param imsi the IMSI + * \param cellId the cell ID + * \param rnti the RNTI + */ + void ConnectionEstablishedCallback (std::string context, uint64_t imsi, + uint16_t cellId, uint16_t rnti); + + bool m_isIdealRrc; ///< whether the LTE is configured to use ideal RRC + int64_t m_rngRun; ///< rng run + + /// The current UE RRC state. + std::map m_lastState; + +}; // end of class LteSecondaryCellSelectionTestCase + +#endif /* LTE_TEST_SECONDARY_CELL_SELECTION_H */ diff --git a/src/lte/wscript b/src/lte/wscript index e5e14836d96..9db4eddc7b3 100644 --- a/src/lte/wscript +++ b/src/lte/wscript @@ -178,6 +178,7 @@ def build(bld): 'test/test-asn1-encoding.cc', 'test/lte-test-ue-measurements.cc', 'test/lte-test-cell-selection.cc', + 'test/lte-test-secondary-cell-selection.cc', 'test/test-lte-handover-delay.cc', 'test/test-lte-handover-target.cc', 'test/lte-test-deactivate-bearer.cc', From d35b539d49fcd3596f8164849bf896aade049465 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 12:50:27 +0300 Subject: [PATCH 163/551] lte: Add LteEnbNetDevice::HasCellId --- src/lte/model/lte-enb-net-device.cc | 13 +++++++++++++ src/lte/model/lte-enb-net-device.h | 6 ++++++ 2 files changed, 19 insertions(+) diff --git a/src/lte/model/lte-enb-net-device.cc b/src/lte/model/lte-enb-net-device.cc index 8b4c5d284ff..0b54d8e5646 100644 --- a/src/lte/model/lte-enb-net-device.cc +++ b/src/lte/model/lte-enb-net-device.cc @@ -225,6 +225,19 @@ LteEnbNetDevice::GetCellId () const return m_cellId; } +bool +LteEnbNetDevice::HasCellId (uint16_t cellId) const +{ + for (auto &it: m_ccMap) + { + if (it.second->GetCellId () == cellId) + { + return true; + } + } + return false; +} + uint8_t LteEnbNetDevice::GetUlBandwidth () const { diff --git a/src/lte/model/lte-enb-net-device.h b/src/lte/model/lte-enb-net-device.h index 30d768c527d..a90e624a7a3 100644 --- a/src/lte/model/lte-enb-net-device.h +++ b/src/lte/model/lte-enb-net-device.h @@ -107,6 +107,12 @@ class LteEnbNetDevice : public LteNetDevice */ uint16_t GetCellId () const; + /** + * \param cellId cell ID + * \return true if cellId is served by this eNB + */ + bool HasCellId (uint16_t cellId) const; + /** * \return the uplink bandwidth in RBs */ From a4a4dbf0c805b8e2024d31d7c2b9559c465edbcf Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 12:58:39 +0300 Subject: [PATCH 164/551] lte: Allow BSR to be received on any CC in NoOpComponentCarrierManager --- src/lte/model/no-op-component-carrier-manager.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/lte/model/no-op-component-carrier-manager.cc b/src/lte/model/no-op-component-carrier-manager.cc index e78722c7f8b..f24db925f98 100644 --- a/src/lte/model/no-op-component-carrier-manager.cc +++ b/src/lte/model/no-op-component-carrier-manager.cc @@ -369,7 +369,6 @@ void NoOpComponentCarrierManager::DoUlReceiveMacCe (MacCeListElement_s bsr, uint8_t componentCarrierId) { NS_LOG_FUNCTION (this); - NS_ASSERT_MSG (componentCarrierId == 0, "Received BSR from a ComponentCarrier not allowed, ComponentCarrierId = " << componentCarrierId); NS_ASSERT_MSG (bsr.m_macCeType == MacCeListElement_s::BSR, "Received a Control Message not allowed " << bsr.m_macCeType); if ( bsr.m_macCeType == MacCeListElement_s::BSR) { @@ -393,7 +392,7 @@ NoOpComponentCarrierManager::DoUlReceiveMacCe (MacCeListElement_s bsr, uint8_t c // to the primary carrier component newBsr.m_macCeValue.m_bufferStatus.at (i) = BufferSizeLevelBsr::BufferSize2BsrId (buffer); } - std::map< uint8_t,LteCcmMacSapProvider*>::iterator sapIt = m_ccmMacSapProviderMap.find (0); + auto sapIt = m_ccmMacSapProviderMap.find (componentCarrierId); if (sapIt == m_ccmMacSapProviderMap.end ()) { NS_FATAL_ERROR ("Sap not found in the CcmMacSapProviderMap"); From 42f0c37e6a76043c5ec853f9a958f1c14e16b5fc Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 13:58:13 +0300 Subject: [PATCH 165/551] lte: Send SIB2 on all component carriers --- src/lte/model/lte-enb-rrc.cc | 36 ++++++++++++++----------- src/lte/model/lte-rrc-protocol-ideal.cc | 8 +++--- src/lte/model/lte-rrc-protocol-ideal.h | 3 ++- src/lte/model/lte-rrc-protocol-real.cc | 8 +++--- src/lte/model/lte-rrc-protocol-real.h | 6 +++-- src/lte/model/lte-rrc-sap.h | 9 ++++--- 6 files changed, 40 insertions(+), 30 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 479e8a17cb1..21b16ad3b36 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -2833,25 +2833,31 @@ LteEnbRrc::SendSystemInformation () { // NS_LOG_FUNCTION (this); + for (auto &it: m_componentCarrierPhyConf) + { + uint8_t ccId = it.first; + + LteRrcSap::SystemInformation si; + si.haveSib2 = true; + si.sib2.freqInfo.ulCarrierFreq = it.second->GetUlEarfcn (); + si.sib2.freqInfo.ulBandwidth = it.second->GetUlBandwidth (); + si.sib2.radioResourceConfigCommon.pdschConfigCommon.referenceSignalPower = m_cphySapProvider.at (ccId)->GetReferenceSignalPower (); + si.sib2.radioResourceConfigCommon.pdschConfigCommon.pb = 0; + + LteEnbCmacSapProvider::RachConfig rc = m_cmacSapProvider.at (ccId)->GetRachConfig (); + LteRrcSap::RachConfigCommon rachConfigCommon; + rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; + rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; + rachConfigCommon.raSupervisionInfo.raResponseWindowSize = rc.raResponseWindowSize; + si.sib2.radioResourceConfigCommon.rachConfigCommon = rachConfigCommon; + + m_rrcSapUser->SendSystemInformation (it.second->GetCellId (), si); + } + /* * For simplicity, we use the same periodicity for all SIBs. Note that in real * systems the periodicy of each SIBs could be different. */ - LteRrcSap::SystemInformation si; - si.haveSib2 = true; - si.sib2.freqInfo.ulCarrierFreq = m_ulEarfcn; - si.sib2.freqInfo.ulBandwidth = m_ulBandwidth; - si.sib2.radioResourceConfigCommon.pdschConfigCommon.referenceSignalPower = m_cphySapProvider.at (0)->GetReferenceSignalPower (); - si.sib2.radioResourceConfigCommon.pdschConfigCommon.pb = 0; - - LteEnbCmacSapProvider::RachConfig rc = m_cmacSapProvider.at (0)->GetRachConfig (); - LteRrcSap::RachConfigCommon rachConfigCommon; - rachConfigCommon.preambleInfo.numberOfRaPreambles = rc.numberOfRaPreambles; - rachConfigCommon.raSupervisionInfo.preambleTransMax = rc.preambleTransMax; - rachConfigCommon.raSupervisionInfo.raResponseWindowSize = rc.raResponseWindowSize; - si.sib2.radioResourceConfigCommon.rachConfigCommon = rachConfigCommon; - - m_rrcSapUser->SendSystemInformation (si); Simulator::Schedule (m_systemInformationPeriodicity, &LteEnbRrc::SendSystemInformation, this); } diff --git a/src/lte/model/lte-rrc-protocol-ideal.cc b/src/lte/model/lte-rrc-protocol-ideal.cc index 704896b2fa3..3295bc0cc0f 100644 --- a/src/lte/model/lte-rrc-protocol-ideal.cc +++ b/src/lte/model/lte-rrc-protocol-ideal.cc @@ -196,7 +196,7 @@ LteUeRrcProtocolIdeal::SetEnbRrcSapProvider () } else { - if (enbDev->GetCellId () == cellId) + if (enbDev->HasCellId (cellId)) { found = true; break; @@ -329,9 +329,9 @@ LteEnbRrcProtocolIdeal::DoRemoveUe (uint16_t rnti) } void -LteEnbRrcProtocolIdeal::DoSendSystemInformation (LteRrcSap::SystemInformation msg) +LteEnbRrcProtocolIdeal::DoSendSystemInformation (uint16_t cellId, LteRrcSap::SystemInformation msg) { - NS_LOG_FUNCTION (this << m_cellId); + NS_LOG_FUNCTION (this << cellId); // walk list of all nodes to get UEs with this cellId Ptr ueRrc; for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) @@ -345,7 +345,7 @@ LteEnbRrcProtocolIdeal::DoSendSystemInformation (LteRrcSap::SystemInformation ms { Ptr ueRrc = ueDev->GetRrc (); NS_LOG_LOGIC ("considering UE IMSI " << ueDev->GetImsi () << " that has cellId " << ueRrc->GetCellId ()); - if (ueRrc->GetCellId () == m_cellId) + if (ueRrc->GetCellId () == cellId) { NS_LOG_LOGIC ("sending SI to IMSI " << ueDev->GetImsi ()); ueRrc->GetLteUeRrcSapProvider ()->RecvSystemInformation (msg); diff --git a/src/lte/model/lte-rrc-protocol-ideal.h b/src/lte/model/lte-rrc-protocol-ideal.h index 9071d4deef6..065858a179c 100644 --- a/src/lte/model/lte-rrc-protocol-ideal.h +++ b/src/lte/model/lte-rrc-protocol-ideal.h @@ -220,9 +220,10 @@ class LteEnbRrcProtocolIdeal : public Object /** * Send system information function * + * \param cellId cell ID * \param msg LteRrcSap::SystemInformation */ - void DoSendSystemInformation (LteRrcSap::SystemInformation msg); + void DoSendSystemInformation (uint16_t cellId, LteRrcSap::SystemInformation msg); /** * Send system information function * diff --git a/src/lte/model/lte-rrc-protocol-real.cc b/src/lte/model/lte-rrc-protocol-real.cc index a2e2c32f055..bbe75ad6635 100644 --- a/src/lte/model/lte-rrc-protocol-real.cc +++ b/src/lte/model/lte-rrc-protocol-real.cc @@ -256,7 +256,7 @@ LteUeRrcProtocolReal::SetEnbRrcSapProvider () } else { - if (enbDev->GetCellId () == cellId) + if (enbDev->HasCellId (cellId)) { found = true; break; @@ -504,9 +504,9 @@ LteEnbRrcProtocolReal::DoRemoveUe (uint16_t rnti) } void -LteEnbRrcProtocolReal::DoSendSystemInformation (LteRrcSap::SystemInformation msg) +LteEnbRrcProtocolReal::DoSendSystemInformation (uint16_t cellId, LteRrcSap::SystemInformation msg) { - NS_LOG_FUNCTION (this << m_cellId); + NS_LOG_FUNCTION (this << cellId); // walk list of all nodes to get UEs with this cellId Ptr ueRrc; for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i) @@ -520,7 +520,7 @@ LteEnbRrcProtocolReal::DoSendSystemInformation (LteRrcSap::SystemInformation msg { Ptr ueRrc = ueDev->GetRrc (); NS_LOG_LOGIC ("considering UE IMSI " << ueDev->GetImsi () << " that has cellId " << ueRrc->GetCellId ()); - if (ueRrc->GetCellId () == m_cellId) + if (ueRrc->GetCellId () == cellId) { NS_LOG_LOGIC ("sending SI to IMSI " << ueDev->GetImsi ()); ueRrc->GetLteUeRrcSapProvider ()->RecvSystemInformation (msg); diff --git a/src/lte/model/lte-rrc-protocol-real.h b/src/lte/model/lte-rrc-protocol-real.h index e9cd9e4a62a..a90ef8b7411 100644 --- a/src/lte/model/lte-rrc-protocol-real.h +++ b/src/lte/model/lte-rrc-protocol-real.h @@ -247,15 +247,17 @@ class LteEnbRrcProtocolReal : public Object /** * Send system information function * + * \param cellId cell ID * \param msg LteRrcSap::SystemInformation */ - void DoSendSystemInformation (LteRrcSap::SystemInformation msg); + void DoSendSystemInformation (uint16_t cellId, LteRrcSap::SystemInformation msg); /** * Send system information function * + * \param cellId cell ID * \param msg LteRrcSap::SystemInformation */ - void SendSystemInformation (LteRrcSap::SystemInformation msg); + void SendSystemInformation (uint16_t cellId, LteRrcSap::SystemInformation msg); /** * Send RRC connection setup function * diff --git a/src/lte/model/lte-rrc-sap.h b/src/lte/model/lte-rrc-sap.h index f5832db8882..106c343b29f 100644 --- a/src/lte/model/lte-rrc-sap.h +++ b/src/lte/model/lte-rrc-sap.h @@ -1086,9 +1086,10 @@ class LteEnbRrcSapUser : public LteRrcSap * \brief Send a _SystemInformation_ message to all attached UEs * during a system information acquisition procedure * (Section 5.2.2 of TS 36.331). + * \param cellId cell ID * \param msg the message */ - virtual void SendSystemInformation (SystemInformation msg) = 0; + virtual void SendSystemInformation (uint16_t cellId, SystemInformation msg) = 0; /** * \brief Send an _RRCConnectionSetup_ message to a UE @@ -1475,7 +1476,7 @@ class MemberLteEnbRrcSapUser : public LteEnbRrcSapUser virtual void SetupUe (uint16_t rnti, SetupUeParameters params); virtual void RemoveUe (uint16_t rnti); - virtual void SendSystemInformation (SystemInformation msg); + virtual void SendSystemInformation (uint16_t cellId, SystemInformation msg); virtual void SendRrcConnectionSetup (uint16_t rnti, RrcConnectionSetup msg); virtual void SendRrcConnectionReconfiguration (uint16_t rnti, RrcConnectionReconfiguration msg); virtual void SendRrcConnectionReestablishment (uint16_t rnti, RrcConnectionReestablishment msg); @@ -1519,9 +1520,9 @@ MemberLteEnbRrcSapUser::RemoveUe (uint16_t rnti) template void -MemberLteEnbRrcSapUser::SendSystemInformation (SystemInformation msg) +MemberLteEnbRrcSapUser::SendSystemInformation (uint16_t cellId, SystemInformation msg) { - m_owner->DoSendSystemInformation (msg); + m_owner->DoSendSystemInformation (cellId, msg); } template From e8a3362842af62a05feb15d3c8f2201025ae3cfa Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 14:54:56 +0300 Subject: [PATCH 166/551] lte: LteEnbRrc: configure SRB0 on primary component carrier, not 0 --- src/lte/model/lte-enb-rrc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 21b16ad3b36..6c9c04e109a 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -211,7 +211,7 @@ UeManager::DoInitialize () // MacSapUserForRlc in the ComponentCarrierManager MacSapUser LteMacSapUser* lteMacSapUser = m_rrc->m_ccmRrcSapProvider->ConfigureSignalBearer(lcinfo, rlc->GetLteMacSapUser ()); // Signal Channel are only on Primary Carrier - m_rrc->m_cmacSapProvider.at (0)->AddLc (lcinfo, lteMacSapUser); + m_rrc->m_cmacSapProvider.at (m_componentCarrierId)->AddLc (lcinfo, lteMacSapUser); m_rrc->m_ccmRrcSapProvider->AddLc (lcinfo, lteMacSapUser); } From a110e7f990c1082856cae50464f214a60bb8c83a Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 15:02:59 +0300 Subject: [PATCH 167/551] lte: use .at () instead of writing an error to stdout in LteEnbRrcProtocolReal --- src/lte/model/lte-rrc-protocol-real.cc | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/src/lte/model/lte-rrc-protocol-real.cc b/src/lte/model/lte-rrc-protocol-real.cc index bbe75ad6635..79dee41f53b 100644 --- a/src/lte/model/lte-rrc-protocol-real.cc +++ b/src/lte/model/lte-rrc-protocol-real.cc @@ -549,14 +549,7 @@ LteEnbRrcProtocolReal::DoSendRrcConnectionSetup (uint16_t rnti, LteRrcSap::RrcCo transmitPdcpPduParameters.rnti = rnti; transmitPdcpPduParameters.lcid = 0; - if (m_setupUeParametersMap.find (rnti) == m_setupUeParametersMap.end () ) - { - std::cout << "RNTI not found in Enb setup parameters Map!" << std::endl; - } - else - { - m_setupUeParametersMap[rnti].srb0SapProvider->TransmitPdcpPdu (transmitPdcpPduParameters); - } + m_setupUeParametersMap.at (rnti).srb0SapProvider->TransmitPdcpPdu (transmitPdcpPduParameters); } void From 33a52a970b9e7682ab6f96e7fae2db815ba84899 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 17:55:46 +0300 Subject: [PATCH 168/551] lte: Shift component carrier ID in RRC messages so they start with 1 --- src/lte/model/lte-enb-rrc.cc | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 6c9c04e109a..92f852db703 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1406,11 +1406,16 @@ UeManager::BuildNonCriticalExtentionConfigurationCa () { uint8_t ccId = it.first; - // Skip primary CC. if (ccId == m_componentCarrierId) { + // Skip primary CC. continue; } + else if (ccId < m_componentCarrierId) + { + // Shift all IDs below PCC forward so PCC can use CC ID 1. + ccId++; + } Ptr eNbCcm = it.second; LteRrcSap::SCellToAddMod component; From 3bfd55a3c9e99e11a5344d0f8c365641e5d3e060 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 19:07:22 +0300 Subject: [PATCH 169/551] lte: Add LteCcmRrcSapUser::GetUeManager --- src/lte/model/lte-ccm-rrc-sap.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/lte/model/lte-ccm-rrc-sap.h b/src/lte/model/lte-ccm-rrc-sap.h index c2e4601a656..f007e2e851e 100644 --- a/src/lte/model/lte-ccm-rrc-sap.h +++ b/src/lte/model/lte-ccm-rrc-sap.h @@ -203,6 +203,14 @@ class LteCcmRrcSapUser */ virtual void ReleaseLcs (uint16_t rnti, uint8_t lcid) = 0; + /** + * Get UE manager by RNTI + * + * \param rnti RNTI + * \return UE manager + */ + virtual Ptr GetUeManager (uint16_t rnti) = 0; + }; // end of class LteCcmRrcSapUser /// MemberLteCcmRrcSapProvider class @@ -296,6 +304,7 @@ class MemberLteCcmRrcSapUser : public LteCcmRrcSapUser virtual void ReleaseLcs (uint16_t rnti, uint8_t lcid); virtual uint8_t AddUeMeasReportConfigForComponentCarrier (LteRrcSap::ReportConfigEutra reportConfig); virtual void TriggerComponentCarrier (uint16_t rnti, uint16_t targetCellId); + virtual Ptr GetUeManager (uint16_t rnti); private: C* m_owner; ///< the owner class @@ -337,6 +346,13 @@ MemberLteCcmRrcSapUser::TriggerComponentCarrier (uint16_t rnti, uint16_t targ NS_FATAL_ERROR ("Function should not be called because it is not implemented."); } +template +Ptr +MemberLteCcmRrcSapUser::GetUeManager (uint16_t rnti) +{ + return m_owner->GetUeManager (rnti); +} + } // end of namespace ns3 From c778f5c3291d8616d41cfda19bda4d0f09c2dd51 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 19:15:42 +0300 Subject: [PATCH 170/551] lte: Add UeManager::GetComponentCarrierId () --- src/lte/model/lte-enb-rrc.cc | 6 ++++++ src/lte/model/lte-enb-rrc.h | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 92f852db703..4910f2720c5 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1151,6 +1151,12 @@ UeManager::GetImsi (void) const return m_imsi; } +uint8_t +UeManager::GetComponentCarrierId () const +{ + return m_componentCarrierId; +} + uint16_t UeManager::GetSrsConfigurationIndex (void) const { diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index f94ec65c372..efd83b6aa88 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -322,6 +322,12 @@ class UeManager : public Object */ uint64_t GetImsi (void) const; + /** + * + * \return the primary component carrier ID + */ + uint8_t GetComponentCarrierId () const; + /** * * \return the SRS Configuration Index From e7b361b324ebc770ceb428c0316770a595016248 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 13 Jun 2017 19:43:11 +0300 Subject: [PATCH 171/551] lte: Send BSR to primary component carrier instead of first --- src/lte/model/no-op-component-carrier-manager.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/lte/model/no-op-component-carrier-manager.cc b/src/lte/model/no-op-component-carrier-manager.cc index f24db925f98..9bf7288568c 100644 --- a/src/lte/model/no-op-component-carrier-manager.cc +++ b/src/lte/model/no-op-component-carrier-manager.cc @@ -92,7 +92,8 @@ void NoOpComponentCarrierManager::DoReportBufferStatus (LteMacSapProvider::ReportBufferStatusParameters params) { NS_LOG_FUNCTION (this); - std::map ::iterator it = m_macSapProvidersMap.find (0); + auto ueManager = m_ccmRrcSapUser->GetUeManager (params.rnti); + std::map ::iterator it = m_macSapProvidersMap.find (ueManager->GetComponentCarrierId ()); NS_ASSERT_MSG (it != m_macSapProvidersMap.end (), "could not find Sap for ComponentCarrier "); it->second->ReportBufferStatus (params); } From 27840ea1c9775f790342ef19420497a9fd3e3ce9 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 14 Jun 2017 12:40:55 +0300 Subject: [PATCH 172/551] lte: Add LteEnbRrc::ComponentCarrierToCellId --- src/lte/model/lte-enb-rrc.cc | 7 +++++++ src/lte/model/lte-enb-rrc.h | 9 +++++++++ 2 files changed, 16 insertions(+) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 4910f2720c5..accb0e377e8 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -2130,6 +2130,13 @@ LteEnbRrc::CellToComponentCarrierId (uint16_t cellId) NS_FATAL_ERROR ("Cell " << cellId << " not found in CC map"); } +uint16_t +LteEnbRrc::ComponentCarrierToCellId (uint8_t componentCarrierId) +{ + NS_LOG_FUNCTION (this << componentCarrierId); + return m_componentCarrierPhyConf.at (componentCarrierId)->GetCellId (); +} + bool LteEnbRrc::SendData (Ptr packet) { diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index efd83b6aa88..21372d28e8b 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -889,6 +889,15 @@ class LteEnbRrc : public Object */ uint8_t CellToComponentCarrierId (uint16_t cellId); + /** + * convert the component carrier id to cell id + * + * \param componentCarrierId component carrier ID + * + * \return corresponding cell ID + */ + uint16_t ComponentCarrierToCellId (uint8_t componentCarrierId); + /** * Enqueue an IP data packet on the proper bearer for downlink * transmission. Normally expected to be called by the NetDevice From c94bf26d8bd299787469245d99527dfe051fcc92 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 15:03:26 +0300 Subject: [PATCH 173/551] lte: Remove LteEnbRrc::m_cellId --- src/lte/model/lte-enb-rrc.cc | 50 ++++++++++++++++-------------------- src/lte/model/lte-enb-rrc.h | 2 -- 2 files changed, 22 insertions(+), 30 deletions(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index accb0e377e8..0870b0585b0 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -589,7 +589,7 @@ UeManager::PrepareHandover (uint16_t cellId) EpcX2SapProvider::HandoverRequestParams params; params.oldEnbUeX2apId = m_rnti; params.cause = EpcX2SapProvider::HandoverDesirableForRadioReason; - params.sourceCellId = m_rrc->m_cellId; + params.sourceCellId = m_rrc->ComponentCarrierToCellId (m_componentCarrierId); params.targetCellId = cellId; params.mmeUeS1apId = m_imsi; params.ueAggregateMaxBitRateDownlink = 200 * 1000; @@ -604,7 +604,7 @@ UeManager::PrepareHandover (uint16_t cellId) hpi.asConfig.sourceMasterInformationBlock.dlBandwidth = m_rrc->m_dlBandwidth; hpi.asConfig.sourceMasterInformationBlock.systemFrameNumber = 0; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity; - hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity = m_rrc->m_cellId; + hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.cellIdentity = m_rrc->ComponentCarrierToCellId (m_componentCarrierId); hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIndication = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.csgIndication; hpi.asConfig.sourceSystemInformationBlockType1.cellAccessRelatedInfo.csgIdentity = m_rrc->m_sib1.at (m_componentCarrierId).cellAccessRelatedInfo.csgIdentity; LteEnbCmacSapProvider::RachConfig rc = m_rrc->m_cmacSapProvider.at (m_componentCarrierId)->GetRachConfig (); @@ -655,7 +655,7 @@ UeManager::RecvHandoverRequestAck (EpcX2SapUser::HandoverRequestAckParams params &LteEnbRrc::HandoverLeavingTimeout, m_rrc, m_rnti); NS_ASSERT (handoverCommand.haveMobilityControlInfo); - m_rrc->m_handoverStartTrace (m_imsi, m_rrc->m_cellId, m_rnti, handoverCommand.mobilityControlInfo.targetPhysCellId); + m_rrc->m_handoverStartTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti, handoverCommand.mobilityControlInfo.targetPhysCellId); EpcX2SapProvider::SnStatusTransferParams sst; sst.oldEnbUeX2apId = params.oldEnbUeX2apId; @@ -738,7 +738,7 @@ UeManager::SendData (uint8_t bid, Ptr p) NS_LOG_LOGIC ("forwarding data to target eNB over X2-U"); uint8_t drbid = Bid2Drbid (bid); EpcX2Sap::UeDataParams params; - params.sourceCellId = m_rrc->m_cellId; + params.sourceCellId = m_rrc->ComponentCarrierToCellId (m_componentCarrierId); params.targetCellId = m_targetCellId; params.gtpTeid = GetDataRadioBearerInfo (drbid)->m_gtpTeid; params.ueData = p; @@ -787,7 +787,7 @@ UeManager::SendUeContextRelease () ueCtxReleaseParams.targetCellId = m_targetCellId; m_rrc->m_x2SapProvider->SendUeContextRelease (ueCtxReleaseParams); SwitchToState (CONNECTED_NORMALLY); - m_rrc->m_handoverEndOkTrace (m_imsi, m_rrc->m_cellId, m_rnti); + m_rrc->m_handoverEndOkTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti); break; default: @@ -924,7 +924,7 @@ UeManager::RecvRrcConnectionSetupCompleted (LteRrcSap::RrcConnectionSetupComplet StartDataRadioBearers (); } SwitchToState (CONNECTED_NORMALLY); - m_rrc->m_connectionEstablishedTrace (m_imsi, m_rrc->m_cellId, m_rnti); + m_rrc->m_connectionEstablishedTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti); break; default: @@ -960,7 +960,7 @@ UeManager::RecvRrcConnectionReconfigurationCompleted (LteRrcSap::RrcConnectionRe m_needPhyMacConfiguration = false; } SwitchToState (CONNECTED_NORMALLY); - m_rrc->m_connectionReconfigurationTrace (m_imsi, m_rrc->m_cellId, m_rnti); + m_rrc->m_connectionReconfigurationTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti); break; // This case is added to NS-3 in order to handle bearer de-activation scenario for CONNECTED state UE @@ -978,7 +978,7 @@ UeManager::RecvRrcConnectionReconfigurationCompleted (LteRrcSap::RrcConnectionRe NS_LOG_INFO ("Send PATH SWITCH REQUEST to the MME"); EpcEnbS1SapProvider::PathSwitchRequestParameters params; params.rnti = m_rnti; - params.cellId = m_rrc->m_cellId; + params.cellId = m_rrc->ComponentCarrierToCellId (m_componentCarrierId); params.mmeUeS1Id = m_imsi; SwitchToState (HANDOVER_PATH_SWITCH); for (std::map >::iterator it = m_drbMap.begin (); @@ -1042,7 +1042,7 @@ UeManager::RecvMeasurementReport (LteRrcSap::MeasurementReport msg) << " measResultListEutra " << msg.measResults.measResultListEutra.size () << " haveScellsMeas " << msg.measResults.haveScellsMeas << " measScellResultList " << msg.measResults.measScellResultList.measResultScell.size ()); - NS_LOG_LOGIC ("serving cellId " << m_rrc->m_cellId + NS_LOG_LOGIC ("serving cellId " << m_rrc->ComponentCarrierToCellId (m_componentCarrierId) << " RSRP " << (uint16_t) msg.measResults.rsrpResult << " RSRQ " << (uint16_t) msg.measResults.rsrqResult); @@ -1099,7 +1099,7 @@ UeManager::RecvMeasurementReport (LteRrcSap::MeasurementReport msg) ///Report any measurements to ComponentCarrierManager, so it can react to any change or activate the SCC m_rrc->m_ccmRrcSapProvider->ReportUeMeas (m_rnti, msg.measResults); // fire a trace source - m_rrc->m_recvMeasurementReportTrace (m_imsi, m_rrc->m_cellId, m_rnti, msg); + m_rrc->m_recvMeasurementReportTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti, msg); } // end of UeManager::RecvMeasurementReport @@ -1358,7 +1358,7 @@ UeManager::SwitchToState (State newState) m_state = newState; NS_LOG_INFO (this << " IMSI " << m_imsi << " RNTI " << m_rnti << " UeManager " << ToString (oldState) << " --> " << ToString (newState)); - m_stateTransitionTrace (m_imsi, m_rrc->m_cellId, m_rnti, oldState, newState); + m_stateTransitionTrace (m_imsi, m_rrc->ComponentCarrierToCellId (m_componentCarrierId), m_rnti, oldState, newState); switch (newState) { @@ -1918,7 +1918,7 @@ LteEnbRrc::GetUeManager (uint16_t rnti) NS_LOG_FUNCTION (this << (uint32_t) rnti); NS_ASSERT (0 != rnti); std::map >::iterator it = m_ueMap.find (rnti); - NS_ASSERT_MSG (it != m_ueMap.end (), "RNTI " << rnti << " not found in eNB with cellId " << m_cellId); + NS_ASSERT_MSG (it != m_ueMap.end (), "UE manager for RNTI " << rnti << " not found"); return it->second; } @@ -2019,7 +2019,6 @@ LteEnbRrc::ConfigureCell (std::map> ccPhyConf) uint8_t dlBandwidth = it->second->GetDlBandwidth (); uint32_t ulEarfcn = it->second->GetUlEarfcn (); uint32_t dlEarfcn = it->second->GetDlEarfcn (); - uint16_t cellId = it->second->GetCellId (); NS_LOG_FUNCTION (this << (uint16_t) ulBandwidth << (uint16_t) dlBandwidth << ulEarfcn << dlEarfcn); NS_ASSERT (!m_configured); @@ -2038,7 +2037,6 @@ LteEnbRrc::ConfigureCell (std::map> ccPhyConf) m_ulEarfcn = ulEarfcn; m_dlBandwidth = dlBandwidth; m_ulBandwidth = ulBandwidth; - m_cellId = cellId; /* * Initializing the list of UE measurement configuration (m_ueMeasConfig). @@ -2100,9 +2098,7 @@ LteEnbRrc::ConfigureCell (std::map> ccPhyConf) void LteEnbRrc::SetCellId (uint16_t cellId) { - m_cellId = cellId; - - // update SIB1 too + // update SIB1 m_sib1.at (0).cellAccessRelatedInfo.cellIdentity = cellId; m_cphySapProvider.at (0)->SetSystemInformationBlockType1 (m_sib1.at (0)); } @@ -2110,8 +2106,7 @@ LteEnbRrc::SetCellId (uint16_t cellId) void LteEnbRrc::SetCellId (uint16_t cellId, uint8_t ccIndex) { - m_cellId = cellId; - // update SIB1 too + // update SIB1 m_sib1.at (ccIndex).cellAccessRelatedInfo.cellIdentity = cellId; m_cphySapProvider.at (ccIndex)->SetSystemInformationBlockType1 (m_sib1.at (ccIndex)); } @@ -2289,8 +2284,6 @@ LteEnbRrc::DoRecvHandoverRequest (EpcX2SapUser::HandoverRequestParams req) NS_LOG_LOGIC ("targetCellId = " << req.targetCellId); NS_LOG_LOGIC ("mmeUeS1apId = " << req.mmeUeS1apId); - NS_ASSERT (req.targetCellId == m_cellId); - if (m_admitHandoverRequest == false) { NS_LOG_INFO ("rejecting handover request from cellId " << req.sourceCellId); @@ -2336,7 +2329,7 @@ LteEnbRrc::DoRecvHandoverRequest (EpcX2SapUser::HandoverRequestParams req) LteRrcSap::RrcConnectionReconfiguration handoverCommand = ueManager->GetRrcConnectionReconfigurationForHandover (); handoverCommand.haveMobilityControlInfo = true; - handoverCommand.mobilityControlInfo.targetPhysCellId = m_cellId; + handoverCommand.mobilityControlInfo.targetPhysCellId = req.targetCellId; handoverCommand.mobilityControlInfo.haveCarrierFreq = true; handoverCommand.mobilityControlInfo.carrierFreq.dlCarrierFreq = m_dlEarfcn; handoverCommand.mobilityControlInfo.carrierFreq.ulCarrierFreq = m_ulEarfcn; @@ -2530,12 +2523,15 @@ LteEnbRrc::DoTriggerHandover (uint16_t rnti, uint16_t targetCellId) bool isHandoverAllowed = true; + Ptr ueManager = GetUeManager (rnti); + NS_ASSERT_MSG (ueManager != 0, "Cannot find UE context with RNTI " << rnti); + if (m_anrSapProvider != 0) { // ensure that proper neighbour relationship exists between source and target cells bool noHo = m_anrSapProvider->GetNoHo (targetCellId); bool noX2 = m_anrSapProvider->GetNoX2 (targetCellId); - NS_LOG_DEBUG (this << " cellId=" << m_cellId + NS_LOG_DEBUG (this << " cellId=" << ComponentCarrierToCellId (ueManager->GetComponentCarrierId ()) << " targetCellId=" << targetCellId << " NRT.NoHo=" << noHo << " NRT.NoX2=" << noX2); @@ -2547,9 +2543,6 @@ LteEnbRrc::DoTriggerHandover (uint16_t rnti, uint16_t targetCellId) } } - Ptr ueManager = GetUeManager (rnti); - NS_ASSERT_MSG (ueManager != 0, "Cannot find UE context with RNTI " << rnti); - if (ueManager->GetState () != UeManager::CONNECTED_NORMALLY) { isHandoverAllowed = false; @@ -2622,8 +2615,9 @@ LteEnbRrc::AddUe (UeManager::State state, uint8_t componentCarrierId) m_ccmRrcSapProvider-> AddUe (rnti, (uint8_t)state); m_ueMap.insert (std::pair > (rnti, ueManager)); ueManager->Initialize (); - NS_LOG_DEBUG (this << " New UE RNTI " << rnti << " cellId " << m_cellId << " srs CI " << ueManager->GetSrsConfigurationIndex ()); - m_newUeContextTrace (m_cellId, rnti); + const uint16_t cellId = ComponentCarrierToCellId (componentCarrierId); + NS_LOG_DEBUG (this << " New UE RNTI " << rnti << " cellId " << cellId << " srs CI " << ueManager->GetSrsConfigurationIndex ()); + m_newUeContextTrace (cellId, rnti); return rnti; } diff --git a/src/lte/model/lte-enb-rrc.h b/src/lte/model/lte-enb-rrc.h index 21372d28e8b..1c206d7d144 100644 --- a/src/lte/model/lte-enb-rrc.h +++ b/src/lte/model/lte-enb-rrc.h @@ -1414,8 +1414,6 @@ class LteEnbRrc : public Object /// True if ConfigureCell() has been completed. bool m_configured; - /// Cell identifier. Must be unique across the simulation. - uint16_t m_cellId; /// Downlink E-UTRA Absolute Radio Frequency Channel Number. uint32_t m_dlEarfcn; /// Uplink E-UTRA Absolute Radio Frequency Channel Number. From c56596b64ebdbb6230b75f1de4c47e065117a7cd Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 16:18:43 +0300 Subject: [PATCH 174/551] lte: Fix limitation on number of component carriers in LteHelper --- src/lte/helper/lte-helper.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/helper/lte-helper.cc b/src/lte/helper/lte-helper.cc index 213e5253202..864d48b4962 100644 --- a/src/lte/helper/lte-helper.cc +++ b/src/lte/helper/lte-helper.cc @@ -196,7 +196,7 @@ TypeId LteHelper::GetTypeId (void) "If it is more than one and m_useCa is false, it will raise an error ", UintegerValue (1), MakeUintegerAccessor (&LteHelper::m_noOfCcs), - MakeUintegerChecker (1, 3)) + MakeUintegerChecker (MIN_NO_CC, MAX_NO_CC)) ; return tid; } From 700b02acd406591607b2fff3a124a89bdebdeb87 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 16:32:05 +0300 Subject: [PATCH 175/551] lte: Add variable number of component carriers to LteSecondaryCellSelectionTestCase --- .../test/lte-test-secondary-cell-selection.cc | 17 ++++++++++------- .../test/lte-test-secondary-cell-selection.h | 4 +++- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/src/lte/test/lte-test-secondary-cell-selection.cc b/src/lte/test/lte-test-secondary-cell-selection.cc index 7ab33435635..2fdbee1790f 100644 --- a/src/lte/test/lte-test-secondary-cell-selection.cc +++ b/src/lte/test/lte-test-secondary-cell-selection.cc @@ -55,11 +55,13 @@ LteSecondaryCellSelectionTestSuite::LteSecondaryCellSelectionTestSuite () { // REAL RRC PROTOCOL - AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, real RRC, RngRun=1", false, 1), TestCase::QUICK); + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, real RRC, RngRun=1", false, 1, 2), TestCase::QUICK); + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, real RRC, RngRun=1", false, 1, 4), TestCase::QUICK); // IDEAL RRC PROTOCOL - AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, ideal RRC, RngRun=1", true, 1), TestCase::QUICK); + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, ideal RRC, RngRun=1", true, 1, 2), TestCase::QUICK); + AddTestCase (new LteSecondaryCellSelectionTestCase ("EPC, ideal RRC, RngRun=1", true, 1, 4), TestCase::QUICK); } // end of LteSecondaryCellSelectionTestSuite::LteSecondaryCellSelectionTestSuite () @@ -70,10 +72,11 @@ static LteSecondaryCellSelectionTestSuite g_lteSecondaryCellSelectionTestSuite; */ LteSecondaryCellSelectionTestCase::LteSecondaryCellSelectionTestCase ( - std::string name, bool isIdealRrc, int64_t rngRun) + std::string name, bool isIdealRrc, int64_t rngRun, uint8_t numberOfComponentCarriers) : TestCase (name), m_isIdealRrc (isIdealRrc), - m_rngRun (rngRun) + m_rngRun (rngRun), + m_numberOfComponentCarriers (numberOfComponentCarriers) { NS_LOG_FUNCTION (this << GetName ()); } @@ -95,7 +98,7 @@ LteSecondaryCellSelectionTestCase::DoRun () auto lteHelper = CreateObject (); lteHelper->SetAttribute ("PathlossModel", TypeIdValue (ns3::FriisSpectrumPropagationLossModel::GetTypeId ())); lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (m_isIdealRrc)); - lteHelper->SetAttribute ("NumberOfComponentCarriers", UintegerValue (2)); + lteHelper->SetAttribute ("NumberOfComponentCarriers", UintegerValue (m_numberOfComponentCarriers)); auto epcHelper = CreateObject (); lteHelper->SetEpcHelper (epcHelper); @@ -105,7 +108,7 @@ LteSecondaryCellSelectionTestCase::DoRun () cch->SetDlEarfcn (100); cch->SetUlBandwidth (25); cch->SetDlBandwidth (25); - cch->SetNumberOfComponentCarriers (2); + cch->SetNumberOfComponentCarriers (m_numberOfComponentCarriers); const auto ccm = cch->EquallySpacedCcs (); lteHelper->SetCcPhyParams (ccm); @@ -113,7 +116,7 @@ LteSecondaryCellSelectionTestCase::DoRun () // Create nodes. auto enbNode = CreateObject (); NodeContainer ueNodes; - ueNodes.Create (2); + ueNodes.Create (m_numberOfComponentCarriers); MobilityHelper mobility; mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); diff --git a/src/lte/test/lte-test-secondary-cell-selection.h b/src/lte/test/lte-test-secondary-cell-selection.h index 014c65b86a9..3ea7a94fcf4 100644 --- a/src/lte/test/lte-test-secondary-cell-selection.h +++ b/src/lte/test/lte-test-secondary-cell-selection.h @@ -60,8 +60,9 @@ class LteSecondaryCellSelectionTestCase : public TestCase * \param isIdealRrc if true, simulation uses Ideal RRC protocol, otherwise * simulation uses Real RRC protocol * \param rngRun the number of run to be used by the random number generator + * \param numberOfComponentCarriers number of component carriers */ - LteSecondaryCellSelectionTestCase (std::string name, bool isIdealRrc, int64_t rngRun); + LteSecondaryCellSelectionTestCase (std::string name, bool isIdealRrc, int64_t rngRun, uint8_t numberOfComponentCarriers); virtual ~LteSecondaryCellSelectionTestCase (); @@ -104,6 +105,7 @@ class LteSecondaryCellSelectionTestCase : public TestCase bool m_isIdealRrc; ///< whether the LTE is configured to use ideal RRC int64_t m_rngRun; ///< rng run + uint8_t m_numberOfComponentCarriers; ///< number of component carriers /// The current UE RRC state. std::map m_lastState; From 28a0524f72abbba6ee2f1b844a173224a128c9e2 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 17:50:52 +0300 Subject: [PATCH 176/551] lte: Fix noncriticalExtension_v1020 serialization --- src/lte/model/lte-rrc-header.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 1af4422d450..02cfa878266 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1717,7 +1717,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const { // 3 optional fields. Extension marker not present. std::bitset<3> noncriticalExtension_v1020; - noncriticalExtension_v1020.set (1,0); // No sCellToRealeaseList-r10 + noncriticalExtension_v1020.set (2,0); // No sCellToRealeaseList-r10 noncriticalExtension_v1020.set (1,1); // sCellToAddModList-r10 noncriticalExtension_v1020.set (0,0); // No nonCriticalExtension RRCConnectionReconfiguration-v1130-IEs SerializeSequence (noncriticalExtension_v1020,false); @@ -2591,6 +2591,10 @@ RrcAsn1Header::Print (std::ostream &os) const // Continue to deserialize futere Release optional fields std::bitset<3> nonCriticalExtension_v1020; bIterator = DeserializeSequence (&nonCriticalExtension_v1020, false, bIterator); + NS_ASSERT (!nonCriticalExtension_v1020[2]); // No sCellToRealeaseList-r10 + NS_ASSERT (nonCriticalExtension_v1020[1]); // sCellToAddModList-r10 + NS_ASSERT (!nonCriticalExtension_v1020[0]); // No nonCriticalExtension RRCConnectionReconfiguration-v1130-IEs + int numElems; bIterator = DeserializeSequenceOf (&numElems,MAX_OBJECT_ID,1,bIterator); nonCriticalExtension->sCellsToAddModList.clear (); From a22b88a5f4e101d97a667a6c4333b2d708afc47d Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 18:34:48 +0300 Subject: [PATCH 177/551] lte: RRC header deserialization fix: alpha is not EARFCN --- src/lte/model/lte-rrc-header.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 02cfa878266..8cff3911d74 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -2687,7 +2687,7 @@ RrcAsn1Header::Print (std::ostream &os) const std::bitset<2> UlPowerControlCommonSCell_r10; bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bIterator); - bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); + bIterator = DeserializeInteger (&n,0,65536,bIterator); rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = n; std::bitset<1> prachConfigSCell_r10; From bd16ea1381229343bb3ee65b314fbf8ec490afaf Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 20:06:27 +0300 Subject: [PATCH 178/551] lte: Update iterator in RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell --- src/lte/model/lte-rrc-header.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 8cff3911d74..dae8fd51c33 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -2705,7 +2705,7 @@ RrcAsn1Header::Print (std::ostream &os) const NS_LOG_FUNCTION (this); std::bitset<1> RadioResourceConfigDedicatedSCell_r10; bIterator = DeserializeSequence (&RadioResourceConfigDedicatedSCell_r10,false,bIterator); - DeserializePhysicalConfigDedicatedSCell (&rrcdsc->physicalConfigDedicatedSCell, bIterator); + bIterator = DeserializePhysicalConfigDedicatedSCell (&rrcdsc->physicalConfigDedicatedSCell, bIterator); return bIterator; } From 304fe486f5ca144f7c2bb6a6c825aead74425b7e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 20:10:32 +0300 Subject: [PATCH 179/551] lte: Use struct variables instead of temporary ones --- src/lte/model/lte-rrc-header.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index dae8fd51c33..2f0ac838702 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1769,7 +1769,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const radioResourceConfigCommonSCell_r10.set (0,rrccsc.haveUlConfiguration); // UlConfiguration SerializeSequence (radioResourceConfigCommonSCell_r10,false); - if (radioResourceConfigCommonSCell_r10[1]) + if (rrccsc.haveNonUlConfiguration) { // 5 optional fields. Extension marker not present. std::bitset<5> nonUlConfiguration_r10; @@ -1796,7 +1796,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const SerializeInteger (rrccsc.nonUlConfiguration.pdschConfigCommon.pb,0,3); } - if (radioResourceConfigCommonSCell_r10[0]) + if (rrccsc.haveUlConfiguration) { //Serialize Ul Configuration // 7 optional fields. Extension marker present. @@ -1860,7 +1860,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const pcdscOpt.set (0,pcdsc.haveUlConfiguration); SerializeSequence (pcdscOpt, true); - if (pcdscOpt[1]) + if (pcdsc.haveNonUlConfiguration) { //Serialize NonUl configuration std::bitset<4> nulOpt; @@ -1906,7 +1906,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const } - if (pcdscOpt[0]) + if (pcdsc.haveUlConfiguration) { //Serialize Ul Configuration std::bitset<7> ulOpt; From 69d75e13f23a8d55b072322672560c49e3714e21 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 19 Jun 2017 20:11:32 +0300 Subject: [PATCH 180/551] lte: Add assertions and fatal errors to RrcAsn1Header deserialization code --- src/lte/model/lte-rrc-header.cc | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 2f0ac838702..69f04c0296f 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -2606,13 +2606,16 @@ RrcAsn1Header::Print (std::ostream &os) const LteRrcSap::SCellToAddMod sctam; // Deserialize sCellIndex + NS_ASSERT (sCellToAddMod_r10[3]); // sCellIndex int n; bIterator = DeserializeInteger (&n,1,MAX_OBJECT_ID,bIterator); sctam.sCellIndex = n; // Deserialize CellIdentification + NS_ASSERT (sCellToAddMod_r10[2]); // CellIdentification bIterator = DeserializeCellIdentification (&sctam.cellIdentification, bIterator); // Deserialize RadioResourceConfigCommonSCell + NS_ASSERT (sCellToAddMod_r10[1]); bIterator = DeserializeRadioResourceConfigCommonSCell (&sctam.radioResourceConfigCommonSCell, bIterator); if (sCellToAddMod_r10[0]) { @@ -2634,10 +2637,12 @@ RrcAsn1Header::Print (std::ostream &os) const NS_LOG_FUNCTION (this); std::bitset<2> cellIdentification_r10; bIterator = DeserializeSequence (&cellIdentification_r10,false,bIterator); + NS_ASSERT(cellIdentification_r10[1]); // phyCellId-r10 int n1; bIterator = DeserializeInteger (&n1,1,65536,bIterator); ci->physCellId = n1; int n2; + NS_ASSERT (cellIdentification_r10[0]); // dl-CarrierFreq-r10 bIterator = DeserializeInteger (&n2,1,MAX_EARFCN,bIterator); ci->dlCarrierFreq = n2; @@ -2723,6 +2728,8 @@ RrcAsn1Header::Print (std::ostream &os) const std::bitset<4> nulOpt; bIterator = DeserializeSequence (&nulOpt,false,bIterator); pcdsc->haveAntennaInfoDedicated = nulOpt[3]; + NS_ASSERT(!nulOpt[2]); // crossCarrierSchedulingConfig-r10 NOT IMplemented + NS_ASSERT(!nulOpt[1]); // csi-RS-Config-r10 Not Implemented pcdsc->havePdschConfigDedicated = nulOpt[0]; if (pcdsc->haveAntennaInfoDedicated) @@ -2746,6 +2753,7 @@ RrcAsn1Header::Print (std::ostream &os) const if (codebookSubsetRestrictionPresent[0]) { // Deserialize codebookSubsetRestriction + NS_FATAL_ERROR ("Not implemented yet"); // ... } @@ -2759,6 +2767,7 @@ RrcAsn1Header::Print (std::ostream &os) const else if (txantennaselchosen == 1) { // Deserialize ue-TransmitAntennaSelection setup + NS_FATAL_ERROR ("Not implemented yet"); // ... } } @@ -2784,7 +2793,12 @@ RrcAsn1Header::Print (std::ostream &os) const std::bitset<7> ulOpt; bIterator = DeserializeSequence (&ulOpt,false,bIterator); pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; + NS_ASSERT(!ulOpt[5]); // pusch-ConfigDedicatedSCell-r10 not present + NS_ASSERT(!ulOpt[4]); // uplinkPowerControlDedicatedSCell-r10 not present + NS_ASSERT(!ulOpt[3]); // cqi-ReportConfigSCell-r10 not present pcdsc->haveSoundingRsUlConfigDedicated = ulOpt[2]; + NS_ASSERT(!ulOpt[1]); // soundingRS-UL-ConfigDedicated-v1020 not present + NS_ASSERT(!ulOpt[0]); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not present if (pcdsc->haveAntennaInfoUlDedicated) { @@ -2807,6 +2821,7 @@ RrcAsn1Header::Print (std::ostream &os) const if (codebookSubsetRestrictionPresent[0]) { // Deserialize codebookSubsetRestriction + NS_FATAL_ERROR ("Not implemented yet"); // ... } @@ -2820,6 +2835,7 @@ RrcAsn1Header::Print (std::ostream &os) const else if (txantennaselchosen == 1) { // Deserialize ue-TransmitAntennaSelection setup + NS_FATAL_ERROR ("Not implemented yet"); // ... } } From 7960f278cc98c65f612fb58cb1e9ec3c2b2c63bb Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 22 Jun 2017 11:02:42 +0300 Subject: [PATCH 181/551] lte: Use Cell ID from RRC messages in LteUeRrc --- src/lte/model/lte-ue-rrc.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/lte/model/lte-ue-rrc.cc b/src/lte/model/lte-ue-rrc.cc index 99f01d1ec68..4fe0abdf1c6 100644 --- a/src/lte/model/lte-ue-rrc.cc +++ b/src/lte/model/lte-ue-rrc.cc @@ -1237,6 +1237,7 @@ LteUeRrc::ApplyRadioResourceConfigDedicatedSecondaryCarrier (LteRrcSap::NonCriti uint8_t ccId = scell.sCellIndex; + uint16_t physCellId = scell.cellIdentification.physCellId; uint8_t ulBand = scell.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulBandwidth; uint32_t ulEarfcn = scell.radioResourceConfigCommonSCell.ulConfiguration.ulFreqInfo.ulCarrierFreq; uint8_t dlBand = scell.radioResourceConfigCommonSCell.nonUlConfiguration.dlBandwidth; @@ -1244,7 +1245,7 @@ LteUeRrc::ApplyRadioResourceConfigDedicatedSecondaryCarrier (LteRrcSap::NonCriti uint8_t txMode = scell.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.antennaInfo.transmissionMode; uint8_t srsIndex = scell.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.soundingRsUlConfigDedicated.srsConfigIndex; - m_cphySapProvider.at (ccId)->SynchronizeWithEnb (m_cellId, dlEarfcn); + m_cphySapProvider.at (ccId)->SynchronizeWithEnb (physCellId, dlEarfcn); m_cphySapProvider.at (ccId)->SetDlBandwidth (dlBand); m_cphySapProvider.at (ccId)->ConfigureUplink (ulEarfcn, ulBand); m_cphySapProvider.at (ccId)->ConfigureReferenceSignalPower (scell.radioResourceConfigCommonSCell.nonUlConfiguration.pdschConfigCommon.referenceSignalPower); From 02bf6932d602a1f316fabfec5fa33f6ce98586bc Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 22 Jun 2017 11:24:06 +0300 Subject: [PATCH 182/551] lte: Do not assume that first carrier is primary in RrComponentCarrierManager --- src/lte/model/no-op-component-carrier-manager.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/lte/model/no-op-component-carrier-manager.cc b/src/lte/model/no-op-component-carrier-manager.cc index 9bf7288568c..fb3bb2cdd8c 100644 --- a/src/lte/model/no-op-component-carrier-manager.cc +++ b/src/lte/model/no-op-component-carrier-manager.cc @@ -446,15 +446,15 @@ RrComponentCarrierManager::DoReportBufferStatus (LteMacSapProvider::ReportBuffer NS_ASSERT_MSG( m_enabledComponentCarrier.find(params.rnti)!=m_enabledComponentCarrier.end(), " UE with provided RNTI not found. RNTI:"<second; + if (params.lcid == 0 || params.lcid == 1 || numberOfCarriersForUe == 1) { - NS_LOG_INFO("Buffer status for lcId=0 and lcId=1 forwarded to the primary carrier."); - m_macSapProvidersMap.find(0)->second->ReportBufferStatus(params); - + NS_LOG_INFO("Buffer status forwarded to the primary carrier."); + auto ueManager = m_ccmRrcSapUser->GetUeManager (params.rnti); + m_macSapProvidersMap.at (ueManager->GetComponentCarrierId ())->ReportBufferStatus (params); } else { - uint32_t numberOfCarriersForUe = m_enabledComponentCarrier.find(params.rnti)->second; params.retxQueueSize /= numberOfCarriersForUe; params.txQueueSize /= numberOfCarriersForUe; for ( uint16_t i = 0; i < numberOfCarriersForUe ; i++) @@ -510,8 +510,8 @@ RrComponentCarrierManager::DoUlReceiveMacCe (MacCeListElement_s bsr, uint8_t com } else { - NS_ASSERT_MSG (m_ccmMacSapProviderMap[0], "Mac sap provider does not exist."); - m_ccmMacSapProviderMap[0]->ReportMacCeToScheduler(bsr); + auto ueManager = m_ccmRrcSapUser->GetUeManager (bsr.m_rnti); + m_ccmMacSapProviderMap.at (ueManager->GetComponentCarrierId ())->ReportMacCeToScheduler (bsr); } } From 8ec290a20225f3171af3a683b3469bac69e5f60e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 22 Jun 2017 15:44:16 +0300 Subject: [PATCH 183/551] lte: Test that throughput scales linearly with number of component carriers even when UE primary CC is attached to non-default eNB component carrier. --- .../lte-test-aggregation-throughput-scale.cc | 168 ++++++++++++++++++ .../lte-test-aggregation-throughput-scale.h | 70 ++++++++ src/lte/wscript | 1 + 3 files changed, 239 insertions(+) create mode 100644 src/lte/test/lte-test-aggregation-throughput-scale.cc create mode 100644 src/lte/test/lte-test-aggregation-throughput-scale.h diff --git a/src/lte/test/lte-test-aggregation-throughput-scale.cc b/src/lte/test/lte-test-aggregation-throughput-scale.cc new file mode 100644 index 00000000000..85e071a2a79 --- /dev/null +++ b/src/lte/test/lte-test-aggregation-throughput-scale.cc @@ -0,0 +1,168 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 Alexander Krotov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Alexander Krotov + * + */ + +#include "lte-test-aggregation-throughput-scale.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ns3; + +NS_LOG_COMPONENT_DEFINE ("LteAggregationThroughputScaleTest"); + +LteAggregationThroughputScaleTestSuite::LteAggregationThroughputScaleTestSuite () + : TestSuite ("lte-aggregation-throughput-scale", SYSTEM) +{ + AddTestCase (new LteAggregationThroughputScaleTestCase ("Carrier aggregation throughput scale"), TestCase::QUICK); +} + +static LteAggregationThroughputScaleTestSuite g_lteAggregationThroughputScaleTestSuite; + +LteAggregationThroughputScaleTestCase::LteAggregationThroughputScaleTestCase (std::string name) + : TestCase (name) +{ + NS_LOG_FUNCTION (this << GetName ()); +} + + +LteAggregationThroughputScaleTestCase::~LteAggregationThroughputScaleTestCase () +{ + NS_LOG_FUNCTION (this << GetName ()); +} + +double +LteAggregationThroughputScaleTestCase::GetThroughput (uint8_t numberOfComponentCarriers) +{ + NS_LOG_FUNCTION (this << GetName ()); + + auto lteHelper = CreateObject (); + lteHelper->SetAttribute ("PathlossModel", TypeIdValue (ns3::FriisSpectrumPropagationLossModel::GetTypeId ())); + lteHelper->SetAttribute ("NumberOfComponentCarriers", UintegerValue (numberOfComponentCarriers)); + lteHelper->SetAttribute ("EnbComponentCarrierManager", StringValue ("ns3::RrComponentCarrierManager")); + + auto epcHelper = CreateObject (); + lteHelper->SetEpcHelper (epcHelper); + + auto cch = CreateObject (); + cch->SetUlEarfcn (100 + 18000); + cch->SetDlEarfcn (100); + cch->SetUlBandwidth (25); + cch->SetDlBandwidth (25); + cch->SetNumberOfComponentCarriers (numberOfComponentCarriers); + + const auto ccm = cch->EquallySpacedCcs (); + lteHelper->SetCcPhyParams (ccm); + + auto enbNode = CreateObject (); + auto ueNode = CreateObject (); + auto pgwNode = epcHelper->GetPgwNode (); + + MobilityHelper mobility; + mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); + mobility.Install (enbNode); + mobility.Install (ueNode); + + InternetStackHelper internet; + internet.Install (ueNode); + + Ipv4AddressHelper ipv4h; + ipv4h.SetBase ("1.0.0.0", "255.0.0.0"); + + Ipv4StaticRoutingHelper ipv4RoutingHelper; + auto ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject ()); + ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1); + + auto enbDev = DynamicCast (lteHelper->InstallEnbDevice (enbNode).Get (0)); + auto ueDevs = lteHelper->InstallUeDevice (ueNode); + auto ueDev = DynamicCast (ueDevs.Get (0)); + + Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (ueDevs); + + // Attach to last CC as primary + ueDev->SetDlEarfcn (ccm.at (numberOfComponentCarriers - 1).GetDlEarfcn ()); + lteHelper->Attach (ueDevs); + m_expectedCellId = enbDev->GetCcMap ().at (numberOfComponentCarriers - 1)->GetCellId (); + + // Applications + const uint16_t port = 21; + + ApplicationContainer apps; + + auto sink = CreateObject (); + sink->SetAttribute ("Protocol", StringValue ("ns3::UdpSocketFactory")); + sink->SetAttribute ("Local", AddressValue (InetSocketAddress (ueIpIface.GetAddress (0), port))); + ueNode->AddApplication (sink); + apps.Add (sink); + + auto client = CreateObject (); + client->SetAttribute ("RemotePort", UintegerValue (port)); + client->SetAttribute ("MaxPackets", UintegerValue (1000000)); + client->SetAttribute ("Interval", TimeValue (Seconds (0.0001))); + client->SetAttribute ("PacketSize", UintegerValue (1000)); + client->SetAttribute ("RemoteAddress", AddressValue (ueIpIface.GetAddress (0))); + pgwNode->AddApplication (client); + + apps.Add (client); + apps.Start (Seconds (1.0)); + + Simulator::Stop (Seconds (2.0)); + Simulator::Run (); + + m_actualCellId = ueDev->GetRrc ()->GetCellId (); + + Simulator::Destroy (); + return 8e-6 * sink->GetTotalRx (); +} + +void +LteAggregationThroughputScaleTestCase::DoRun () +{ + std::vector throughputs; + for (uint8_t i = 1; i <= 4; i++) + { + throughputs.push_back (GetThroughput (i) / i); + NS_TEST_ASSERT_MSG_EQ (m_expectedCellId, m_actualCellId, "UE has attached to an unexpected cell"); + } + double average = std::accumulate(begin (throughputs), end (throughputs), 0.0) / throughputs.size (); + for (double throughput: throughputs) + { + NS_TEST_ASSERT_MSG_EQ_TOL (throughput, average, average * 0.01, "Throughput does not scale with number of component carriers"); + } +} diff --git a/src/lte/test/lte-test-aggregation-throughput-scale.h b/src/lte/test/lte-test-aggregation-throughput-scale.h new file mode 100644 index 00000000000..ca8775f1d11 --- /dev/null +++ b/src/lte/test/lte-test-aggregation-throughput-scale.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ +/* + * Copyright (c) 2017 Alexander Krotov + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Alexander Krotov + * + */ + +#ifndef LTE_AGGREGATION_THROUGHPUT_SCALE_H +#define LTE_AGGREGATION_THROUGHPUT_SCALE_H + +#include + +using namespace ns3; + +/** + * \brief Test suite for executing carrier aggregation throughput scaling test case. + * + * \sa ns3::LteAggregationThroughputScaleTestCase + */ +class LteAggregationThroughputScaleTestSuite : public TestSuite +{ +public: + LteAggregationThroughputScaleTestSuite (); +}; + +/** + * \ingroup lte + * + * \brief Testing that UE throughput scales linearly with number of component carriers. + * Also attaches UE to last component carrier to make sure no code assumes + * that primary carrier is first. + */ +class LteAggregationThroughputScaleTestCase : public TestCase +{ +public: + /** + * \brief Creates an instance of the carrier aggregation throughput scaling test case. + * \param name name of this test + */ + LteAggregationThroughputScaleTestCase (std::string name); + + virtual ~LteAggregationThroughputScaleTestCase (); + +private: + /** + * \brief Setup the simulation, run it, and verify the result. + */ + virtual void DoRun (); + + double GetThroughput (uint8_t numberOfComponentCarriers); + + uint16_t m_expectedCellId; //< Cell ID UE is expected to attach to + uint16_t m_actualCellId; //< Cell ID UE has attached to +}; + +#endif /* LTE_AGGREGATION_THROUGHPUT_SCALE_H */ diff --git a/src/lte/wscript b/src/lte/wscript index 9db4eddc7b3..c02ff06de67 100644 --- a/src/lte/wscript +++ b/src/lte/wscript @@ -190,6 +190,7 @@ def build(bld): 'test/lte-test-cqi-generation.cc', 'test/lte-simple-spectrum-phy.cc', 'test/lte-test-carrier-aggregation.cc', + 'test/lte-test-aggregation-throughput-scale.cc', ] headers = bld(features='ns3header') From 04917b2f92c6407178928b1d70006bb62c9a6dd7 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 23 Jun 2017 15:53:05 +0300 Subject: [PATCH 184/551] lte: Refactor LteHandoverDelayTestCase for multiple CCs Also remove point-to-point helper and remote host as it is not used. --- src/lte/test/test-lte-handover-delay.cc | 126 +++++++++--------------- 1 file changed, 49 insertions(+), 77 deletions(-) diff --git a/src/lte/test/test-lte-handover-delay.cc b/src/lte/test/test-lte-handover-delay.cc index 7d3a4a2b283..e89002615dc 100644 --- a/src/lte/test/test-lte-handover-delay.cc +++ b/src/lte/test/test-lte-handover-delay.cc @@ -16,6 +16,7 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Author: Budiarto Herman + * Alexander Krotov */ #include @@ -67,9 +68,10 @@ class LteHandoverDelayTestCase : public TestCase * \param delayThreshold the delay threshold * \param simulationDuration duration of the simulation */ - LteHandoverDelayTestCase (bool useIdealRrc, Time handoverTime, + LteHandoverDelayTestCase (uint8_t numberOfComponentCarriers, bool useIdealRrc, Time handoverTime, Time delayThreshold, Time simulationDuration) : TestCase ("Verifying that the time needed for handover is under a specified threshold"), + m_numberOfComponentCarriers (numberOfComponentCarriers), m_useIdealRrc (useIdealRrc), m_handoverTime (handoverTime), m_delayThreshold (delayThreshold), @@ -120,6 +122,7 @@ class LteHandoverDelayTestCase : public TestCase void EnbHandoverEndOkCallback (std::string context, uint64_t imsi, uint16_t cellid, uint16_t rnti); + uint8_t m_numberOfComponentCarriers; bool m_useIdealRrc; ///< use ideal RRC? Time m_handoverTime; ///< handover time Time m_delayThreshold; ///< the delay threshold @@ -136,59 +139,38 @@ LteHandoverDelayTestCase::DoRun () NS_LOG_INFO ("-----test case: ideal RRC = " << m_useIdealRrc << " handover time = " << m_handoverTime.GetSeconds () << "-----"); - Ptr lteHelper = CreateObject (); - Ptr epcHelper = CreateObject (); - lteHelper->SetEpcHelper (epcHelper); - lteHelper->SetAttribute ("UseIdealRrc", BooleanValue(m_useIdealRrc)); - - // SETUP A REMOTE HOST - - NodeContainer remoteHosts; - remoteHosts.Create (1); - InternetStackHelper inetStackHelper; - inetStackHelper.Install (remoteHosts); - - // SETUP POINT-TO-POINT CONNECTION BETWEEN REMOTE HOST AND EPC - - PointToPointHelper p2pHelper; - p2pHelper.SetDeviceAttribute ("DataRate", - DataRateValue (DataRate ("100Gb/s"))); - p2pHelper.SetDeviceAttribute ("Mtu", UintegerValue (1500)); - p2pHelper.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010))); - - NetDeviceContainer inetDevs = p2pHelper.Install (epcHelper->GetPgwNode (), - remoteHosts.Get (0)); - - Ipv4AddressHelper addrHelper; - addrHelper.SetBase ("10.1.1.0", "255.255.255.0"); - Ipv4InterfaceContainer inetIfs; - inetIfs = addrHelper.Assign (inetDevs); - - // SETUP ROUTING - - Ipv4StaticRoutingHelper ipRoutingHelper; - Ptr remoteHostRouting = - ipRoutingHelper.GetStaticRouting (remoteHosts.Get (0)->GetObject ()); - remoteHostRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), - Ipv4Mask ("255.0.0.0"), 1); - - // CREATE NODES - - NodeContainer enbNodes; - NodeContainer ueNodes; - enbNodes.Create (2); - ueNodes.Create (1); + /* + * Helpers. + */ + auto epcHelper = CreateObject (); - /** + auto lteHelper = CreateObject (); + lteHelper->SetEpcHelper (epcHelper); + lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (m_useIdealRrc)); + lteHelper->SetAttribute ("NumberOfComponentCarriers", UintegerValue (m_numberOfComponentCarriers)); + + auto ccHelper = CreateObject (); + ccHelper->SetUlEarfcn (100 + 18000); + ccHelper->SetDlEarfcn (100); + ccHelper->SetUlBandwidth (25); + ccHelper->SetDlBandwidth (25); + ccHelper->SetNumberOfComponentCarriers (m_numberOfComponentCarriers); + + /* + * Physical layer. + * * eNodeB 0 UE eNodeB 1 * * x ----------------------- x ----------------------- x * 500 m 500 m */ + // Create nodes. + NodeContainer enbNodes; + enbNodes.Create (2); + auto ueNode = CreateObject (); - // SETUP MOBILITY - - Ptr posAlloc = CreateObject (); + // Setup mobility + auto posAlloc = CreateObject (); posAlloc->Add (Vector (0, 0, 0)); posAlloc->Add (Vector (1000, 0, 0)); posAlloc->Add (Vector (500, 0, 0)); @@ -197,30 +179,23 @@ LteHandoverDelayTestCase::DoRun () mobilityHelper.SetMobilityModel ("ns3::ConstantPositionMobilityModel"); mobilityHelper.SetPositionAllocator (posAlloc); mobilityHelper.Install (enbNodes); - mobilityHelper.Install (ueNodes); - - // SETUP LTE DEVICES + mobilityHelper.Install (ueNode); - NetDeviceContainer enbDevs; - NetDeviceContainer ueDevs; - enbDevs = lteHelper->InstallEnbDevice (enbNodes); - ueDevs = lteHelper->InstallUeDevice (ueNodes); - - // SETUP INTERNET IN UE + /* + * Link layer. + */ + auto enbDevs = lteHelper->InstallEnbDevice (enbNodes); + auto ueDev = lteHelper->InstallUeDevice (ueNode).Get (0); - inetStackHelper.Install(ueNodes); + /* + * Network layer. + */ + InternetStackHelper inetStackHelper; + inetStackHelper.Install (ueNode); Ipv4InterfaceContainer ueIfs; - ueIfs = epcHelper->AssignUeIpv4Address (ueDevs); - - // SETUP DEFAULT GATEWAY FOR UE - - Ptr ueStaticRouting = - ipRoutingHelper.GetStaticRouting (ueNodes.Get (0)->GetObject ()); - ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), - 1); - - // INSTALLING TRACES + ueIfs = epcHelper->AssignUeIpv4Address (ueDev); + // Setup traces. Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/HandoverStart", MakeCallback (&LteHandoverDelayTestCase::UeHandoverStartCallback, this)); Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/HandoverEndOk", @@ -231,15 +206,12 @@ LteHandoverDelayTestCase::DoRun () Config::Connect ("/NodeList/*/DeviceList/*/LteEnbRrc/HandoverEndOk", MakeCallback (&LteHandoverDelayTestCase::EnbHandoverEndOkCallback, this)); - // SIMULATION - + // Prepare handover. lteHelper->AddX2Interface (enbNodes); - lteHelper->Attach (ueDevs.Get(0), enbDevs.Get(0)); - lteHelper->HandoverRequest (m_handoverTime, ueDevs.Get (0), enbDevs.Get (0), - enbDevs.Get (1)); - // disable error model in dl ctrl channel - //Config::Set ("/NodeList/*/DeviceList/*/LteUePhy/DlSpectrumPhy/CtrlErrorModelEnabled", - // BooleanValue (false)); + lteHelper->Attach (ueDev, enbDevs.Get(0)); + lteHelper->HandoverRequest (m_handoverTime, ueDev, enbDevs.Get (0), enbDevs.Get (1)); + + // Run simulation. Simulator::Stop (m_simulationDuration); Simulator::Run (); Simulator::Destroy (); @@ -318,7 +290,7 @@ static class LteHandoverDelayTestSuite : public TestSuite { // arguments: useIdealRrc, handoverTime, delayThreshold, simulationDuration AddTestCase ( - new LteHandoverDelayTestCase (true, handoverTime, Seconds (0.005), + new LteHandoverDelayTestCase (1, true, handoverTime, Seconds (0.005), Seconds (0.200)), TestCase::QUICK); } @@ -329,7 +301,7 @@ static class LteHandoverDelayTestSuite : public TestSuite { // arguments: useIdealRrc, handoverTime, delayThreshold, simulationDuration AddTestCase ( - new LteHandoverDelayTestCase (false, handoverTime, Seconds (0.020), + new LteHandoverDelayTestCase (1, false, handoverTime, Seconds (0.020), Seconds (0.200)), TestCase::QUICK); } } From 013c5b9a340c49e984a981f8775b1b6979ce60a2 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 3 Jul 2017 11:09:29 +0300 Subject: [PATCH 185/551] lte: Print uint8_t as integer --- src/lte/model/lte-enb-rrc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index 0870b0585b0..47ed0aeaec4 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -2128,7 +2128,7 @@ LteEnbRrc::CellToComponentCarrierId (uint16_t cellId) uint16_t LteEnbRrc::ComponentCarrierToCellId (uint8_t componentCarrierId) { - NS_LOG_FUNCTION (this << componentCarrierId); + NS_LOG_FUNCTION (this << +componentCarrierId); return m_componentCarrierPhyConf.at (componentCarrierId)->GetCellId (); } From 9352957adb7d6dcf1830ed8d90749681807171b7 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 3 Jul 2017 11:10:08 +0300 Subject: [PATCH 186/551] lte: Fix letter case in comments --- src/lte/model/lte-rrc-header.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 69f04c0296f..efb03535957 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -1865,7 +1865,7 @@ RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const //Serialize NonUl configuration std::bitset<4> nulOpt; nulOpt.set (3,pcdsc.haveAntennaInfoDedicated); - nulOpt.set (2,0); // crossCarrierSchedulingConfig-r10 NOT IMplemented + nulOpt.set (2,0); // crossCarrierSchedulingConfig-r10 Not Implemented nulOpt.set (1,0); // csi-RS-Config-r10 Not Implemented nulOpt.set (0, pcdsc.havePdschConfigDedicated); // pdsch-ConfigDedicated-r10 SerializeSequence (nulOpt,false); @@ -2728,7 +2728,7 @@ RrcAsn1Header::Print (std::ostream &os) const std::bitset<4> nulOpt; bIterator = DeserializeSequence (&nulOpt,false,bIterator); pcdsc->haveAntennaInfoDedicated = nulOpt[3]; - NS_ASSERT(!nulOpt[2]); // crossCarrierSchedulingConfig-r10 NOT IMplemented + NS_ASSERT(!nulOpt[2]); // crossCarrierSchedulingConfig-r10 Not Implemented NS_ASSERT(!nulOpt[1]); // csi-RS-Config-r10 Not Implemented pcdsc->havePdschConfigDedicated = nulOpt[0]; From 86259aa901eb327b40f530e4a9c07f5740803581 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Mon, 3 Jul 2017 22:01:42 +0300 Subject: [PATCH 187/551] lte: Set corresponding UlEarfcn in lte-pathloss-model test suite --- src/lte/test/lte-test-pathloss-model.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/test/lte-test-pathloss-model.cc b/src/lte/test/lte-test-pathloss-model.cc index 6f747b191f7..a8a20219c06 100644 --- a/src/lte/test/lte-test-pathloss-model.cc +++ b/src/lte/test/lte-test-pathloss-model.cc @@ -214,6 +214,7 @@ LtePathlossModelSystemTestCase::DoRun (void) // set frequency. This is important because it changes the behavior of the path loss model lteHelper->SetEnbDeviceAttribute ("DlEarfcn", UintegerValue (200)); + lteHelper->SetEnbDeviceAttribute ("UlEarfcn", UintegerValue (18200)); lteHelper->SetUeDeviceAttribute ("DlEarfcn", UintegerValue (200)); // remove shadowing component From e9ba48da923c5de4543ef1318c982ff7ec58c51e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 4 Jul 2017 04:05:36 +0300 Subject: [PATCH 188/551] lte: Add LteSpectrumValueHelper::Get{Downlink, Uplink}CarrierBand --- src/lte/model/lte-spectrum-value-helper.cc | 48 ++++++++++++++++------ src/lte/model/lte-spectrum-value-helper.h | 22 +++++++++- 2 files changed, 56 insertions(+), 14 deletions(-) diff --git a/src/lte/model/lte-spectrum-value-helper.cc b/src/lte/model/lte-spectrum-value-helper.cc index 570e2367f28..9732ae8dc16 100644 --- a/src/lte/model/lte-spectrum-value-helper.cc +++ b/src/lte/model/lte-spectrum-value-helper.cc @@ -114,38 +114,62 @@ LteSpectrumValueHelper::GetCarrierFrequency (uint32_t earfcn) } } -double -LteSpectrumValueHelper::GetDownlinkCarrierFrequency (uint32_t nDl) +uint16_t +LteSpectrumValueHelper::GetDownlinkCarrierBand (uint32_t nDl) { NS_LOG_FUNCTION (nDl); for (uint16_t i = 0; i < NUM_EUTRA_BANDS; ++i) { - if ((g_eutraChannelNumbers[i].rangeNdl1 <= nDl) - && (g_eutraChannelNumbers[i].rangeNdl2 >= nDl)) + if (g_eutraChannelNumbers[i].rangeNdl1 <= nDl && + g_eutraChannelNumbers[i].rangeNdl2 >= nDl) { NS_LOG_LOGIC ("entry " << i << " fDlLow=" << g_eutraChannelNumbers[i].fDlLow); - return 1.0e6 * (g_eutraChannelNumbers[i].fDlLow + 0.1 * (nDl - g_eutraChannelNumbers[i].nOffsDl)); + return i; } } NS_LOG_ERROR ("invalid EARFCN " << nDl); - return 0.0; + return NUM_EUTRA_BANDS; } -double -LteSpectrumValueHelper::GetUplinkCarrierFrequency (uint32_t nUl) +uint16_t +LteSpectrumValueHelper::GetUplinkCarrierBand (uint32_t nUl) { NS_LOG_FUNCTION (nUl); for (uint16_t i = 0; i < NUM_EUTRA_BANDS; ++i) { - if ((g_eutraChannelNumbers[i].rangeNul1 <= nUl) - && (g_eutraChannelNumbers[i].rangeNul2 >= nUl)) + if (g_eutraChannelNumbers[i].rangeNul1 <= nUl && + g_eutraChannelNumbers[i].rangeNul2 >= nUl) { NS_LOG_LOGIC ("entry " << i << " fUlLow=" << g_eutraChannelNumbers[i].fUlLow); - return 1.0e6 * (g_eutraChannelNumbers[i].fUlLow + 0.1 * (nUl - g_eutraChannelNumbers[i].nOffsUl)); + return i; } } NS_LOG_ERROR ("invalid EARFCN " << nUl); - return 0.0; + return NUM_EUTRA_BANDS; +} + +double +LteSpectrumValueHelper::GetDownlinkCarrierFrequency (uint32_t nDl) +{ + NS_LOG_FUNCTION (nDl); + uint16_t i = GetDownlinkCarrierBand (nDl); + if (i == NUM_EUTRA_BANDS) + { + return 0.0; + } + return 1.0e6 * (g_eutraChannelNumbers[i].fDlLow + 0.1 * (nDl - g_eutraChannelNumbers[i].nOffsDl)); +} + +double +LteSpectrumValueHelper::GetUplinkCarrierFrequency (uint32_t nUl) +{ + NS_LOG_FUNCTION (nUl); + uint16_t i = GetUplinkCarrierBand (nUl); + if (i == NUM_EUTRA_BANDS) + { + return 0.0; + } + return 1.0e6 * (g_eutraChannelNumbers[i].fUlLow + 0.1 * (nUl - g_eutraChannelNumbers[i].nOffsUl)); } double diff --git a/src/lte/model/lte-spectrum-value-helper.h b/src/lte/model/lte-spectrum-value-helper.h index 57530cc2bdf..badd263f97c 100644 --- a/src/lte/model/lte-spectrum-value-helper.h +++ b/src/lte/model/lte-spectrum-value-helper.h @@ -48,13 +48,31 @@ class LteSpectrumValueHelper static double GetCarrierFrequency (uint32_t earfcn); /** - * Calculates the dowlink carrier frequency from the E-UTRA Absolute + * Converts downlink EARFCN to corresponding LTE frequency band number. + * + * \param earfcn the EARFCN + * + * \return the downlink carrier band + */ + static uint16_t GetDownlinkCarrierBand (uint32_t nDl); + + /** + * Converts uplink EARFCN to corresponding LTE frequency band number. + * + * \param earfcn the EARFCN + * + * \return the uplink carrier band + */ + static uint16_t GetUplinkCarrierBand (uint32_t nDl); + + /** + * Calculates the downlink carrier frequency from the E-UTRA Absolute * Radio Frequency Channel Number (EARFCN) using the formula in 3GPP TS * 36.101 section 5.7.3 "Carrier frequency and EARFCN". * * \param earfcn the EARFCN * - * \return the dowlink carrier frequency in Hz + * \return the downlink carrier frequency in Hz */ static double GetDownlinkCarrierFrequency (uint32_t earfcn); From cd1cf7003c2648bac6ce0bd7e94721e79fbf4c2a Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 4 Jul 2017 07:25:02 +0300 Subject: [PATCH 189/551] lte: Make sure CC spacing is multiple of 300kHz --- src/lte/helper/cc-helper.cc | 37 +++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/src/lte/helper/cc-helper.cc b/src/lte/helper/cc-helper.cc index b31ec223691..22a6f630be8 100644 --- a/src/lte/helper/cc-helper.cc +++ b/src/lte/helper/cc-helper.cc @@ -27,6 +27,7 @@ #include #include #include +#include #define MIN_CC 1 #define MAX_CC 2 @@ -172,22 +173,46 @@ CcHelper::EquallySpacedCcs () { std::map< uint8_t, ComponentCarrier > ccmap; + uint32_t ulEarfcn = m_ulEarfcn; + uint32_t dlEarfcn = m_dlEarfcn; + uint32_t maxBandwidthRb = std::max (m_ulBandwidth, m_dlBandwidth); + + // Convert bandwidth from RBs to kHz + uint32_t maxBandwidthKhz = LteSpectrumValueHelper::GetChannelBandwidth(maxBandwidthRb) / 1e3; + for (uint8_t i = 0; i < m_numberOfComponentCarriers; i++) { + // Make sure we stay within the same band. + if (LteSpectrumValueHelper::GetUplinkCarrierBand (ulEarfcn) != + LteSpectrumValueHelper::GetUplinkCarrierBand (m_ulEarfcn) + || LteSpectrumValueHelper::GetDownlinkCarrierBand (dlEarfcn) != + LteSpectrumValueHelper::GetDownlinkCarrierBand (m_dlEarfcn)) + { + NS_FATAL_ERROR ("Band is not wide enough to allocate " << +m_numberOfComponentCarriers << " CCs"); + } + bool pc =false; - // One RB is 200 kHz wide, while increment by 1 in corresponds to 100 kHz shift - // Therefore, we need to multiply by 2 here. - uint32_t ul = m_ulEarfcn + i * 2 * m_ulBandwidth; - uint32_t dl = m_dlEarfcn + i * 2 * m_dlBandwidth; if (i == 0) { pc = true; } - ComponentCarrier cc = CreateSingleCc (m_ulBandwidth, m_dlBandwidth, ul, dl, pc); + ComponentCarrier cc = CreateSingleCc (m_ulBandwidth, m_dlBandwidth, ulEarfcn, dlEarfcn, pc); ccmap.insert (std::pair(i, cc)); - NS_LOG_INFO(" ulBandwidth:"< Date: Sat, 15 Jul 2017 10:10:15 -0700 Subject: [PATCH 190/551] internet: (fixes #2762) BindToNetDevice change for NSC TCP sockets addendum to changeset 12958:6e192ac0b562 --- src/internet/model/nsc-tcp-l4-protocol.cc | 20 +++++++++++--------- src/internet/model/nsc-tcp-l4-protocol.h | 11 ++++++++--- src/internet/model/nsc-tcp-socket-impl.cc | 17 +++++++++++++++-- src/internet/model/nsc-tcp-socket-impl.h | 1 + 4 files changed, 35 insertions(+), 14 deletions(-) diff --git a/src/internet/model/nsc-tcp-l4-protocol.cc b/src/internet/model/nsc-tcp-l4-protocol.cc index 345d66f9ddf..005b885bbef 100644 --- a/src/internet/model/nsc-tcp-l4-protocol.cc +++ b/src/internet/model/nsc-tcp-l4-protocol.cc @@ -309,25 +309,27 @@ NscTcpL4Protocol::Allocate (Ipv4Address address) } Ipv4EndPoint * -NscTcpL4Protocol::Allocate (uint16_t port) +NscTcpL4Protocol::Allocate (Ptr boundNetDevice, uint16_t port) { - NS_LOG_FUNCTION (this << port); - return m_endPoints->Allocate (port); + NS_LOG_FUNCTION (this << boundNetDevice << port); + return m_endPoints->Allocate (boundNetDevice, port); } Ipv4EndPoint * -NscTcpL4Protocol::Allocate (Ipv4Address address, uint16_t port) +NscTcpL4Protocol::Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port) { - NS_LOG_FUNCTION (this << address << port); - return m_endPoints->Allocate (address, port); + NS_LOG_FUNCTION (this << boundNetDevice << address << port); + return m_endPoints->Allocate (boundNetDevice, address, port); } Ipv4EndPoint * -NscTcpL4Protocol::Allocate (Ipv4Address localAddress, uint16_t localPort, +NscTcpL4Protocol::Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort) { - NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort); - return m_endPoints->Allocate (localAddress, localPort, + NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort); + return m_endPoints->Allocate (boundNetDevice, + localAddress, localPort, peerAddress, peerPort); } diff --git a/src/internet/model/nsc-tcp-l4-protocol.h b/src/internet/model/nsc-tcp-l4-protocol.h index a33ac45ba0e..5e073812f0a 100644 --- a/src/internet/model/nsc-tcp-l4-protocol.h +++ b/src/internet/model/nsc-tcp-l4-protocol.h @@ -37,6 +37,7 @@ class Ipv4Interface; class NscTcpSocketImpl; class Ipv4EndPoint; class NscInterfaceImpl; +class NetDevice; /** * \ingroup nsctcp @@ -99,26 +100,30 @@ class NscTcpL4Protocol : public IpL4Protocol { Ipv4EndPoint *Allocate (Ipv4Address address); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param address address to use * \param port port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port); + Ipv4EndPoint *Allocate (Ptr boundNetDevice, Ipv4Address address, uint16_t port); /** * \brief Allocate an IPv4 Endpoint + * \param boundNetDevice Bound NetDevice (if any) * \param localAddress local address to use * \param localPort local port to use * \param peerAddress remote address to use * \param peerPort remote port to use * \return the Endpoint */ - Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort, + Ipv4EndPoint *Allocate (Ptr boundNetDevice, + Ipv4Address localAddress, uint16_t localPort, Ipv4Address peerAddress, uint16_t peerPort); diff --git a/src/internet/model/nsc-tcp-socket-impl.cc b/src/internet/model/nsc-tcp-socket-impl.cc index 3438c3199e4..208fdeacc0b 100644 --- a/src/internet/model/nsc-tcp-socket-impl.cc +++ b/src/internet/model/nsc-tcp-socket-impl.cc @@ -250,7 +250,7 @@ NscTcpSocketImpl::Bind (const Address &address) } else if (ipv4 == Ipv4Address::GetAny () && port != 0) { - m_endPoint = m_tcp->Allocate (port); + m_endPoint = m_tcp->Allocate (GetBoundNetDevice (), port); NS_LOG_LOGIC ("NscTcpSocketImpl "<Allocate (ipv4, port); + m_endPoint = m_tcp->Allocate (GetBoundNetDevice (), ipv4, port); NS_LOG_LOGIC ("NscTcpSocketImpl "< netdevice) +{ + NS_LOG_FUNCTION (this << netdevice); + Socket::BindToNetDevice (netdevice); // Includes sanity check + if (m_endPoint != 0) + { + m_endPoint->BindToNetDevice (netdevice); + } + return; +} + int NscTcpSocketImpl::ShutdownSend (void) { diff --git a/src/internet/model/nsc-tcp-socket-impl.h b/src/internet/model/nsc-tcp-socket-impl.h index 8d8fcc2a24d..bfc1dbd71a7 100644 --- a/src/internet/model/nsc-tcp-socket-impl.h +++ b/src/internet/model/nsc-tcp-socket-impl.h @@ -105,6 +105,7 @@ class NscTcpSocketImpl : public TcpSocket virtual int GetSockName (Address &address) const; virtual bool SetAllowBroadcast (bool allowBroadcast); virtual bool GetAllowBroadcast () const; + virtual void BindToNetDevice (Ptr netdevice); // NetDevice with my m_endPoint private: /** From 6ef602d818275328fc43ed99c92c0872e51ecdbd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 17 Jul 2017 09:54:38 +0200 Subject: [PATCH 191/551] wifi: Clean fcs trailer in MacLow --- src/wifi/model/mac-low.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 26844784a0e..7b501b517dd 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -696,8 +696,7 @@ MacLow::StartTransmission (Ptr packet, { Ptr newPacket = (m_txPackets[GetTid (packet, *hdr)].at (i).packet)->Copy (); newPacket->AddHeader (m_txPackets[GetTid (packet, *hdr)].at (i).hdr); - WifiMacTrailer fcs; - newPacket->AddTrailer (fcs); + AddWifiMacTrailer (newPacket); edcaIt->second->GetMpduAggregator ()->Aggregate (newPacket, aggregatedPacket); } m_currentPacket = aggregatedPacket; @@ -1504,7 +1503,6 @@ MacLow::ForwardDown (Ptr packet, const WifiMacHeader* hdr, WifiTxV Ptr newPacket; Ptr dequeuedItem; WifiMacHeader newHdr; - WifiMacTrailer fcs; uint8_t queueSize = m_aggregateQueue[GetTid (packet, *hdr)]->GetNPackets (); bool singleMpdu = false; bool last = false; From ab1ee5d8d526f8e0054950fdd4576f79a5a2c9d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 17 Jul 2017 09:57:44 +0200 Subject: [PATCH 192/551] wifi: (fixes #2763) Fix pcap printing for wifi management frames --- RELEASE_NOTES | 1 + src/wifi/model/ap-wifi-mac.cc | 6 +++--- src/wifi/model/sta-wifi-mac.cc | 4 ++-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 9f12bb68546..55957649e26 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -113,6 +113,7 @@ Bugs fixed - Bug 2760 - OLSR uses unicast-bound sockets to receive broadcasts - Bug 2761 - Packet has no Traffic ID for CTS frames when A-MPDU is used - Bug 2762 - BindToNetDevice behaviour is not coherent with Linux +- Bug 2763 - wifi management packets in the PCAPs are all marked as wrong by Wireshark Known issues ------------ diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index b0c51faeb75..c3930bc3046 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -585,6 +585,7 @@ ApWifiMac::SendProbeResp (Mac48Address to) hdr.SetAddr3 (GetAddress ()); hdr.SetDsNotFrom (); hdr.SetDsNotTo (); + hdr.SetNoOrder (); Ptr packet = Create (); MgtProbeResponseHeader probe; probe.SetSsid (GetSsid ()); @@ -609,7 +610,6 @@ ApWifiMac::SendProbeResp (Mac48Address to) { probe.SetHtCapabilities (GetHtCapabilities ()); probe.SetHtOperation (GetHtOperation ()); - hdr.SetNoOrder (); } if (m_vhtSupported || m_heSupported) { @@ -640,6 +640,7 @@ ApWifiMac::SendAssocResp (Mac48Address to, bool success) hdr.SetAddr3 (GetAddress ()); hdr.SetDsNotFrom (); hdr.SetDsNotTo (); + hdr.SetNoOrder (); Ptr packet = Create (); MgtAssocResponseHeader assoc; StatusCode code; @@ -667,7 +668,6 @@ ApWifiMac::SendAssocResp (Mac48Address to, bool success) { assoc.SetHtCapabilities (GetHtCapabilities ()); assoc.SetHtOperation (GetHtOperation ()); - hdr.SetNoOrder (); } if (m_vhtSupported || m_heSupported) { @@ -698,6 +698,7 @@ ApWifiMac::SendOneBeacon (void) hdr.SetAddr3 (GetAddress ()); hdr.SetDsNotFrom (); hdr.SetDsNotTo (); + hdr.SetNoOrder (); Ptr packet = Create (); MgtBeaconHeader beacon; beacon.SetSsid (GetSsid ()); @@ -722,7 +723,6 @@ ApWifiMac::SendOneBeacon (void) { beacon.SetHtCapabilities (GetHtCapabilities ()); beacon.SetHtOperation (GetHtOperation ()); - hdr.SetNoOrder (); } if (m_vhtSupported || m_heSupported) { diff --git a/src/wifi/model/sta-wifi-mac.cc b/src/wifi/model/sta-wifi-mac.cc index 68a70ab8cb9..6085caa8f50 100644 --- a/src/wifi/model/sta-wifi-mac.cc +++ b/src/wifi/model/sta-wifi-mac.cc @@ -164,6 +164,7 @@ StaWifiMac::SendProbeRequest (void) hdr.SetAddr3 (Mac48Address::GetBroadcast ()); hdr.SetDsNotFrom (); hdr.SetDsNotTo (); + hdr.SetNoOrder (); Ptr packet = Create (); MgtProbeRequestHeader probe; probe.SetSsid (GetSsid ()); @@ -171,7 +172,6 @@ StaWifiMac::SendProbeRequest (void) if (m_htSupported || m_vhtSupported || m_heSupported) { probe.SetHtCapabilities (GetHtCapabilities ()); - hdr.SetNoOrder (); } if (m_vhtSupported || m_heSupported) { @@ -208,6 +208,7 @@ StaWifiMac::SendAssociationRequest (void) hdr.SetAddr3 (GetBssid ()); hdr.SetDsNotFrom (); hdr.SetDsNotTo (); + hdr.SetNoOrder (); Ptr packet = Create (); MgtAssocRequestHeader assoc; assoc.SetSsid (GetSsid ()); @@ -216,7 +217,6 @@ StaWifiMac::SendAssociationRequest (void) if (m_htSupported || m_vhtSupported || m_heSupported) { assoc.SetHtCapabilities (GetHtCapabilities ()); - hdr.SetNoOrder (); } if (m_vhtSupported || m_heSupported) { From 78348bbc58bb679f5d3173980df17719f2217c30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Mon, 17 Jul 2017 11:44:09 +0200 Subject: [PATCH 193/551] wifi: Extend trace for RegularWifiMac::ForwardUp --- src/wifi/model/regular-wifi-mac.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index d83f31fc823..0cba59a7ce0 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -878,7 +878,7 @@ RegularWifiMac::SupportsSendFrom (void) const void RegularWifiMac::ForwardUp (Ptr packet, Mac48Address from, Mac48Address to) { - NS_LOG_FUNCTION (this << packet << from); + NS_LOG_FUNCTION (this << packet << from << to); m_forwardUp (packet, from, to); } From 359ec078642bfe505fff9a0a7363cbc8fed7dffd Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 19 Jul 2017 11:37:44 +0300 Subject: [PATCH 194/551] Tutorial spellcheck --- doc/tutorial/source/building-topologies.rst | 22 ++++++++++----------- doc/tutorial/source/conceptual-overview.rst | 2 +- doc/tutorial/source/getting-started.rst | 2 +- doc/tutorial/source/tracing.rst | 8 ++++---- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/doc/tutorial/source/building-topologies.rst b/doc/tutorial/source/building-topologies.rst index 450061d62d9..24bc59f0e29 100644 --- a/doc/tutorial/source/building-topologies.rst +++ b/doc/tutorial/source/building-topologies.rst @@ -785,7 +785,7 @@ topology helpers in this section. The appearance and operation of these helpers should look quite familiar to you. We provide an example script in our ``examples/tutorial`` directory. This script -builds on the ``second.cc`` script and adds a Wifi network. Go ahead and +builds on the ``second.cc`` script and adds a Wi-Fi network. Go ahead and open ``examples/tutorial/third.cc`` in your favorite editor. You will have already seen enough |ns3| code to understand most of what is going on in this example, but there are a few new things, so we will go over the entire @@ -808,7 +808,7 @@ network. By default there are three "extra" CSMA nodes and three wireless The code begins by loading module include files just as was done in the ``second.cc`` example. There are a couple of new includes corresponding -to the Wifi module and the mobility module which we will discuss below. +to the wifi module and the mobility module which we will discuss below. :: @@ -925,7 +925,7 @@ selected nodes. NetDeviceContainer csmaDevices; csmaDevices = csma.Install (csmaNodes); -Next, we are going to create the nodes that will be part of the Wifi network. +Next, we are going to create the nodes that will be part of the Wi-Fi network. We are going to create a number of "station" nodes as specified by the command line argument, and we are going to use the "leftmost" node of the point-to-point link as the node for the access point. @@ -996,14 +996,14 @@ created by this helper. Once all the station-specific parameters are fully configured, both at the MAC and PHY layers, we can invoke our now-familiar ``Install`` method to -create the wifi devices of these stations: +create the Wi-Fi devices of these stations: :: NetDeviceContainer staDevices; staDevices = wifi.Install (phy, mac, wifiStaNodes); -We have configured Wifi for all of our STA nodes, and now we need to +We have configured Wi-Fi for all of our STA nodes, and now we need to configure the AP (access point) node. We begin this process by changing the default ``Attributes`` of the ``WifiMacHelper`` to reflect the requirements of the AP. @@ -1076,7 +1076,7 @@ We accomplish this by setting the mobility model for this node to be the mobility.Install (wifiApNode); We now have our nodes, devices and channels created, and mobility models -chosen for the Wifi nodes, but we have no protocol stacks present. Just as +chosen for the Wi-Fi nodes, but we have no protocol stacks present. Just as we have done previously many times, we will use the ``InternetStackHelper`` to install these stacks. @@ -1166,7 +1166,7 @@ We create just enough tracing to cover all three networks: These three lines of code will start pcap tracing on both of the point-to-point nodes that serves as our backbone, will start a promiscuous (monitor) mode -trace on the Wifi network, and will start a promiscuous trace on the CSMA +trace on the Wi-Fi network, and will start a promiscuous trace on the CSMA network. This will let us see all of the traffic with a minimum number of trace files. @@ -1222,11 +1222,11 @@ The file "third-0-0.pcap" corresponds to the point-to-point device on node zero -- the left side of the "backbone". The file "third-1-0.pcap" corresponds to the point-to-point device on node one -- the right side of the "backbone". The file "third-0-1.pcap" will be the promiscuous (monitor -mode) trace from the Wifi network and the file "third-1-1.pcap" will be the +mode) trace from the Wi-Fi network and the file "third-1-1.pcap" will be the promiscuous trace from the CSMA network. Can you verify this by inspecting the code? -Since the echo client is on the Wifi network, let's start there. Let's take +Since the echo client is on the Wi-Fi network, let's start there. Let's take a look at the promiscuous (monitor mode) trace we captured on that network. .. sourcecode:: bash @@ -1274,7 +1274,7 @@ Again, you should see some familiar looking contents: 2.008151 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, length 1024 2.026758 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, length 1024 -This is the echo packet going from left to right (from Wifi to CSMA) and back +This is the echo packet going from left to right (from Wi-Fi to CSMA) and back again across the point-to-point link. Now, look at the pcap file of the right side of the point-to-point link, @@ -1291,7 +1291,7 @@ Again, you should see some familiar looking contents: 2.011837 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, length 1024 2.023072 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, length 1024 -This is also the echo packet going from left to right (from Wifi to CSMA) and +This is also the echo packet going from left to right (from Wi-Fi to CSMA) and back again across the point-to-point link with slightly different timings as you might expect. diff --git a/doc/tutorial/source/conceptual-overview.rst b/doc/tutorial/source/conceptual-overview.rst index 3bb620c595f..0d49102bd0c 100644 --- a/doc/tutorial/source/conceptual-overview.rst +++ b/doc/tutorial/source/conceptual-overview.rst @@ -797,7 +797,7 @@ in the first example program will schedule an explicit stop at 11 seconds: return 0; } -The above wil not actually change the behavior of this program, since +The above will not actually change the behavior of this program, since this particular simulation naturally ends after 10 seconds. But if you were to change the stop time in the above statement from 11 seconds to 1 second, you would notice that the simulation stops before any output is diff --git a/doc/tutorial/source/getting-started.rst b/doc/tutorial/source/getting-started.rst index 2303b22bcae..7eb2170eb46 100644 --- a/doc/tutorial/source/getting-started.rst +++ b/doc/tutorial/source/getting-started.rst @@ -215,7 +215,7 @@ Step into the workspace directory and type the following into your shell:: $ ./bake.py configure -e ns-3.26 -Next, we'l ask bake to check whether we have enough tools to download +Next, we'll ask bake to check whether we have enough tools to download various components. Type:: $ ./bake.py check diff --git a/doc/tutorial/source/tracing.rst b/doc/tutorial/source/tracing.rst index e3e5c7366bc..86db147b785 100644 --- a/doc/tutorial/source/tracing.rst +++ b/doc/tutorial/source/tracing.rst @@ -1106,7 +1106,7 @@ there is some English: This class template implements the Functor Design Pattern. It is used to declare the type of a **Callback**: * the first non-optional template argument represents the return type of the callback. - * the reminaining (optional) template arguments represent the type of the subsequent arguments to the callback. + * the remaining (optional) template arguments represent the type of the subsequent arguments to the callback. * up to nine arguments are supported. We are trying to figure out what the @@ -1369,7 +1369,7 @@ didn't exist yet during configuration time?). As a result, during the configuration phase you can't connect a trace source to a trace sink if one of them is created dynamically during the simulation. -The two solutions to this connundrum are +The two solutions to this conundrum are #. Create a simulator event that is run after the dynamic object is created and hook the trace when that event is executed; or @@ -1456,7 +1456,7 @@ problem described above with ``Socket``. // =========================================================================== // -This should also be self-explanatory. +This should also be self-explanatory. The next part is the declaration of the ``MyApp`` ``Application`` that we put together to allow the ``Socket`` to be created at configuration @@ -2216,7 +2216,7 @@ creates a PCAP file named "sixth.pcap" with file mode "w". This means that the new file is truncated (contents deleted) if an existing file with that name is found. The final parameter is the "data link type" of the new PCAP file. These are the same as the PCAP library data -link types defined in ``bpf.h`` if you are familar with PCAP. In this +link types defined in ``bpf.h`` if you are familiar with PCAP. In this case, ``DLT_PPP`` indicates that the PCAP file is going to contain packets prefixed with point to point headers. This is true since the packets are coming from our point-to-point device driver. Other From cbe446baf1c2fec8c1ef18ee43cd04190d59c495 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 19 Jul 2017 11:43:06 +0300 Subject: [PATCH 195/551] Internet module documentation spellcheck --- src/internet/doc/ipv4.rst | 14 +++++++------- src/internet/doc/ipv6.rst | 24 ++++++++++++------------ src/internet/model/tcp-l4-protocol.cc | 2 +- 3 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/internet/doc/ipv4.rst b/src/internet/doc/ipv4.rst index 590456fb32f..4884336e5d5 100644 --- a/src/internet/doc/ipv4.rst +++ b/src/internet/doc/ipv4.rst @@ -33,8 +33,8 @@ IPv4 global addresses can be: |ns3| can use both methods, and it's quite important to understand the implications of both. -Manually assigned IPv4 adddresses -+++++++++++++++++++++++++++++++++ +Manually assigned IPv4 addresses +++++++++++++++++++++++++++++++++ This is probably the easiest and most used method. As an example: @@ -53,12 +53,12 @@ This is probably the easiest and most used method. As an example: This method will add two global IPv4 addresses to the nodes. -Note that the addesses are assigned in sequence. As a consequence, the first Node / NetDevice +Note that the addresses are assigned in sequence. As a consequence, the first Node / NetDevice will have "192.168.1.1", the second "192.168.1.2" and so on. It is possible to repeat the above to assign more than one address to a node. However, due to the :cpp:class:`Ipv4AddressHelper` singleton nature, one should first assign all the -adddresses of a network, then change the network base (``SetBase``), then do a new assignment. +addresses of a network, then change the network base (``SetBase``), then do a new assignment. Alternatively, it is possible to assign a specific address to a node: @@ -80,8 +80,8 @@ Alternatively, it is possible to assign a specific address to a node: ipv4proto->AddAddress (ifIndex, ipv4Addr); -DHCP assigned IPv4 adddresses -+++++++++++++++++++++++++++++ +DHCP assigned IPv4 addresses +++++++++++++++++++++++++++++ DHCP is available in the internet-apps module. In order to use DHCP you have to have a :cpp:class:`DhcpServer` application in a node (the DHC server node) and a :cpp:class:`DhcpClient` application in @@ -122,7 +122,7 @@ be called for a number of reasons. - If an ARP reply is received for an entry that is not waiting for a reply, the ARP reply packet is dropped and this trace is fired; -- If an ARP reply is received for a non-existant entry, the ARP reply packet +- If an ARP reply is received for a non-existent entry, the ARP reply packet is dropped and this trace is fired; - If an ARP cache entry is in the DEAD state (has timed out) and an ARP reply packet is received, the reply packet is dropped and this trace is fired. diff --git a/src/internet/doc/ipv6.rst b/src/internet/doc/ipv6.rst index 96de6039007..33d47dfd2fc 100644 --- a/src/internet/doc/ipv6.rst +++ b/src/internet/doc/ipv6.rst @@ -135,8 +135,8 @@ IPv6 global addresses might be: |ns3| can use both methods, and it's quite important to understand the implications of both. -Manually assigned IPv6 adddresses -+++++++++++++++++++++++++++++++++ +Manually assigned IPv6 addresses +++++++++++++++++++++++++++++++++ This is probably the easiest and most used method. As an example: @@ -157,12 +157,12 @@ This method will add two global IPv6 addresses to the nodes. Note that, as usual all the nodes will also have a link-local address. Typically the first address on an interface will be the link-local one, with the global address(es) being the following ones. -Note that the global addesses will be derived from the MAC address. As a consequence, expect +Note that the global addresses will be derived from the MAC address. As a consequence, expect to have addresses similar to ``2001:db8::200:ff:fe00:1``. It is possible to repeat the above to assign more than one global address to a node. However, due to the :cpp:class:`Ipv6AddressHelper` singleton nature, one should first assign all the -adddresses of a network, then change the network base (``SetBase``), then do a new assignment. +addresses of a network, then change the network base (``SetBase``), then do a new assignment. Alternatively, it is possible to assign a specific address to a node: @@ -184,8 +184,8 @@ Alternatively, it is possible to assign a specific address to a node: ipv6proto->AddAddress (ifIndex, ipv6Addr); -Auto-generated IPv6 adddresses -############################## +Auto-generated IPv6 addresses +############################# This is accomplished by relying on the RADVD protocol, implemented by the class :cpp:class:`Radvd`. A helper class is available, which can be used to ease the most @@ -193,7 +193,7 @@ common tasks, e.g., setting up a prefix on an interface, if it is announced peri and if the router is the default router for that interface. A fine grain configuration is possible though the :cpp:class:`RadvdInterface` class, which -allows to setup every parameter of the announced router advetisement on a given interface. +allows to setup every parameter of the announced router advertisement on a given interface. It is worth mentioning that the configurations must be set up before installing the application in the node. @@ -206,8 +206,8 @@ Examples of RADVD use are shown in ``examples/ipv6/radvd.cc`` and ``examples/ipv6/radvd-two-prefix.cc``. -Random-generated IPv6 adddresses -################################ +Random-generated IPv6 addresses +############################### While IPv6 real nodes will use randomly generated addresses to protect privacy, |ns3| does NOT have this capability. This feature haven't been so far considered as interesting @@ -220,7 +220,7 @@ Nodes will perform DAD (it can be disabled using an :cpp:class:`Icmpv6L4Protocol Upon receiving a DAD, however, nodes will not react to it. As is: DAD reaction is incomplete so far. The main reason relies on the missing random-generated address capability. Moreover, -since |ns3| nodes will usually be well-behaving, therea should't be any Duplicate Address. +since |ns3| nodes will usually be well-behaving, there shouldn't be any Duplicate Address. This might be changed in the future, so as to avoid issues with real-world integrated simulations. @@ -297,7 +297,7 @@ with the difference that it's not possible to override the behaviour using esote forwarding=2). Consider carefully the implications of packet forwarding. As an example, a node will NOT send -ICMPv6 PACKET_TOO_BIG messages from an interface with frowarding off. This is completely normal, +ICMPv6 PACKET_TOO_BIG messages from an interface with forwarding off. This is completely normal, as the Routing protocol will drop the packet before attempting to forward it. @@ -403,7 +403,7 @@ this MTU. This is the link-MTU. In order to support different MTUs in a source-destination path, |ns3| IPv6 model can perform fragmentation. This can be either triggered by receiving a packet bigger than the link-MTU from the L4 -protocols (UDP, TCP, etc.), or by receving an ICMPv6 PACKET_TOO_BIG message. +protocols (UDP, TCP, etc.), or by receiving an ICMPv6 PACKET_TOO_BIG message. The model mimics RFC 1981, with the following notable exceptions: * L4 protocols are not informed of the Path MTU change diff --git a/src/internet/model/tcp-l4-protocol.cc b/src/internet/model/tcp-l4-protocol.cc index 280843850c4..c31821fb68b 100644 --- a/src/internet/model/tcp-l4-protocol.cc +++ b/src/internet/model/tcp-l4-protocol.cc @@ -492,7 +492,7 @@ TcpL4Protocol::Receive (Ptr packet, TcpHeader incomingTcpHeader; IpL4Protocol::RxStatus checksumControl; - // If we are receving a v4-mapped packet, we will re-calculate the TCP checksum + // If we are receiving a v4-mapped packet, we will re-calculate the TCP checksum // Is it worth checking every received "v6" packet to see if it is v4-mapped in // order to avoid re-calculating TCP checksums for v4-mapped packets? From 3e73eaf23456df55d0c2cbc977f812c1ab6e79b5 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 19 Jul 2017 11:44:23 +0300 Subject: [PATCH 196/551] lte: Replace "bewteen" with "between" in a comment --- src/lte/helper/lte-global-pathloss-database.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/helper/lte-global-pathloss-database.h b/src/lte/helper/lte-global-pathloss-database.h index e3a2d91adda..4d1d110a688 100644 --- a/src/lte/helper/lte-global-pathloss-database.h +++ b/src/lte/helper/lte-global-pathloss-database.h @@ -61,7 +61,7 @@ class LteGlobalPathlossDatabase * \param cellId the id of the eNB * \param imsi the id of the UE * - * \return the pathloss value bewteen the UE and the eNB + * \return the pathloss value between the UE and the eNB */ double GetPathloss (uint16_t cellId, uint64_t imsi); From f296244b848665bc4e9bff59ae712a14b52fa560 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 19 Jul 2017 15:19:46 +0300 Subject: [PATCH 197/551] core: Spellcheck --- src/core/model/attribute-accessor-helper.h | 6 +++--- src/core/model/callback.cc | 2 +- src/core/model/des-metrics.h | 2 +- src/core/model/heap-scheduler.h | 2 +- src/core/model/int64x64-128.h | 2 +- src/core/model/log-macros-enabled.h | 2 +- src/core/model/names.cc | 8 ++++---- src/core/model/object.cc | 2 +- src/core/model/object.h | 2 +- src/core/model/random-variable-stream.h | 4 ++-- src/core/model/realtime-simulator-impl.cc | 6 +++--- src/core/model/rng-seed-manager.h | 2 +- src/core/model/simulator-impl.h | 2 +- src/core/model/synchronizer.h | 2 +- src/core/model/system-mutex.h | 2 +- src/core/model/system-thread.h | 2 +- src/core/model/test.h | 12 ++++++------ src/core/model/traced-value.h | 2 +- src/core/model/wall-clock-synchronizer.h | 4 ++-- src/core/model/win32-system-wall-clock-ms.cc | 2 +- 20 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/core/model/attribute-accessor-helper.h b/src/core/model/attribute-accessor-helper.h index 7487e98983e..43478153445 100644 --- a/src/core/model/attribute-accessor-helper.h +++ b/src/core/model/attribute-accessor-helper.h @@ -361,7 +361,7 @@ inline Ptr DoMakeAccessorHelperOne (void (T::*setter)(U)) { - /* AttributeAccessor implemenation with a class set method returning void. */ + /* AttributeAccessor implementation with a class set method returning void. */ class MemberMethod : public AccessorHelper { public: @@ -423,7 +423,7 @@ DoMakeAccessorHelperTwo (void (T::*setter)(U), V (T::*getter)(void) const) { /* - * AttributeAccessor implemenation with class get functor and set method, + * AttributeAccessor implementation with class get functor and set method, * returning void. */ class MemberMethod : public AccessorHelper @@ -506,7 +506,7 @@ DoMakeAccessorHelperTwo (bool (T::*setter)(U), V (T::*getter)(void) const) { /* - * AttributeAccessor implemenation with class get functor and + * AttributeAccessor implementation with class get functor and * set method, returning bool. */ class MemberMethod : public AccessorHelper diff --git a/src/core/model/callback.cc b/src/core/model/callback.cc index bc414892067..dc96bdf743d 100644 --- a/src/core/model/callback.cc +++ b/src/core/model/callback.cc @@ -99,7 +99,7 @@ CallbackImplBase::Demangle (const std::string& mangled) ret = demangled; } else if (status == -1) { - NS_LOG_UNCOND ("Callback demangling failed: Memory allocation failure occured."); + NS_LOG_UNCOND ("Callback demangling failed: Memory allocation failure occurred."); ret = mangled; } else if (status == -2) { diff --git a/src/core/model/des-metrics.h b/src/core/model/des-metrics.h index b63e0b18683..46c0ec74977 100644 --- a/src/core/model/des-metrics.h +++ b/src/core/model/des-metrics.h @@ -156,7 +156,7 @@ class DesMetrics : public Singleton static std::string m_outputDir; bool m_initialized; //!< Have we been initialized. - std::ofstream m_os; //!< The output json trace file stream. + std::ofstream m_os; //!< The output JSON trace file stream. char m_separator; //!< The separator between event records. /** Mutex to control access to the output file. */ diff --git a/src/core/model/heap-scheduler.h b/src/core/model/heap-scheduler.h index 0d506b816b6..1968e16c126 100644 --- a/src/core/model/heap-scheduler.h +++ b/src/core/model/heap-scheduler.h @@ -37,7 +37,7 @@ namespace ns3 { * \ingroup scheduler * \brief a binary heap event scheduler * - * This code started as a c++ translation of a java-based code written in 2005 + * This code started as a c++ translation of a Java-based code written in 2005 * to implement a heap sort. So, this binary heap is really a pretty * straightforward implementation of the classic data structure. Not much to say * about it. diff --git a/src/core/model/int64x64-128.h b/src/core/model/int64x64-128.h index cc7146d5f41..676ec6cde71 100644 --- a/src/core/model/int64x64-128.h +++ b/src/core/model/int64x64-128.h @@ -245,7 +245,7 @@ class int64x64_t /** * Compute the inverse of an integer value. * - * Ordinary division by an integer would be limited to 64 bits of precsion. + * Ordinary division by an integer would be limited to 64 bits of precision. * Instead, we multiply by the 128-bit inverse of the divisor. * This function computes the inverse to 128-bit precision. * MulByInvert() then completes the division. diff --git a/src/core/model/log-macros-enabled.h b/src/core/model/log-macros-enabled.h index f8f9b111f0a..b0a3337eeb1 100644 --- a/src/core/model/log-macros-enabled.h +++ b/src/core/model/log-macros-enabled.h @@ -93,7 +93,7 @@ #ifndef NS_LOG_APPEND_CONTEXT /** * \ingroup logging - * Append the node id (or other file-local programatic context, such as + * Append the node id (or other file-local programmatic context, such as * MPI rank) to a log message. * * This is implemented locally in `.cc` files because diff --git a/src/core/model/names.cc b/src/core/model/names.cc index 20cb983548b..a13a6590ad1 100644 --- a/src/core/model/names.cc +++ b/src/core/model/names.cc @@ -254,7 +254,7 @@ NamesPriv::Add (std::string name, Ptr object) // // If we are given a name that begins with "/Names/" we assume that this is a // fully qualified path name to the object we want to create. We split the name - // into a path string and and a final segment (name) and then call the "Real" Add. + // into a path string and a final segment (name) and then call the "Real" Add. // std::string namespaceName = "/Names"; std::string::size_type offset = name.find (namespaceName); @@ -363,7 +363,7 @@ NamesPriv::Rename (std::string oldpath, std::string newname) // // If we are given a name that begins with "/Names/" we assume that this is a // fully qualified path to the object we want to change. We split the path into - // path string (cf directory) and and a final segment (cf filename) and then call + // path string (cf directory) and a final segment (cf filename) and then call // the "Real" Rename. // std::string namespaceName = "/Names"; @@ -454,7 +454,7 @@ NamesPriv::Rename (Ptr context, std::string oldname, std::string newname // // The rename process consists of: - // 1. Geting the pointer to the name node from the map and remembering it; + // 1. Getting the pointer to the name node from the map and remembering it; // 2. Removing the map entry corresponding to oldname from the map; // 3. Changing the name string in the name node; // 4. Adding the name node back in the map under the newname. @@ -522,7 +522,7 @@ NamesPriv::Find (std::string path) // // If we are provided a path that doesn't begin with "/Names", we assume // that the caller has simply given us a path starting with a name that - // is in the root namespace. This allows peole to omit the "/Names" prefix. + // is in the root namespace. This allows people to omit the "/Names" prefix. // and simply do a Find ("Client/eth0") instead of having to always do a // Find ("/Names/Client/eth0"); // diff --git a/src/core/model/object.cc b/src/core/model/object.cc index c08246fac71..72822d13ec9 100644 --- a/src/core/model/object.cc +++ b/src/core/model/object.cc @@ -298,7 +298,7 @@ Object::AggregateObject (Ptr o) } // Finally, call NotifyNewAggregate on all the objects aggregates together. - // We purposedly use the old aggregate buffers to iterate over the objects + // We purposely use the old aggregate buffers to iterate over the objects // because this allows us to assume that they will not change from under // our feet, even if our users call AggregateObject from within their // NotifyNewAggregate method. diff --git a/src/core/model/object.h b/src/core/model/object.h index 0e6c49faa9a..70fbe559b34 100644 --- a/src/core/model/object.h +++ b/src/core/model/object.h @@ -133,7 +133,7 @@ class Object : public SimpleRefCount */ AggregateIterator (Ptr object); Ptr m_object; //!< Parent Object. - uint32_t m_current; //!< Current position in parent's aggegrates. + uint32_t m_current; //!< Current position in parent's aggregates. }; /** Constructor. */ diff --git a/src/core/model/random-variable-stream.h b/src/core/model/random-variable-stream.h index 739bb5a99f0..446e932b85f 100644 --- a/src/core/model/random-variable-stream.h +++ b/src/core/model/random-variable-stream.h @@ -81,7 +81,7 @@ class RngStream; * * ns-3 has a rich set of random number generators that allow stream * numbers to be set deterministically if desired. Class - * RandomVariableStream defines the base class functionalty required + * RandomVariableStream defines the base class functionality required * for all such random number generators. * * By default, the underlying generator is seeded all the time with @@ -166,7 +166,7 @@ class RandomVariableStream : public Object */ RandomVariableStream (const RandomVariableStream &o); /** - * Assignment operator. These objects can't be copied by assignement. + * Assignment operator. These objects can't be copied by assignment. * * \param [in] o The RandomVariableStream to copy. * \return lvalue RandomVariableStream. diff --git a/src/core/model/realtime-simulator-impl.cc b/src/core/model/realtime-simulator-impl.cc index b0baa8116ec..3d72f36fedb 100644 --- a/src/core/model/realtime-simulator-impl.cc +++ b/src/core/model/realtime-simulator-impl.cc @@ -177,7 +177,7 @@ RealtimeSimulatorImpl::ProcessOneEvent (void) // cause us to re-evaluate our state. The way this works is that the synchronizer // gets interrupted and returns. So, there is a possibility that things may change // out from under us dynamically. In this case, we need to re-evaluate how long to - // wait in a for-loop until we have waited sucessfully (until a timeout) for the + // wait in a for-loop until we have waited successfully (until a timeout) for the // event at the head of the event list. // // m_synchronizer->Synchronize will return true if the wait was completed without @@ -196,7 +196,7 @@ RealtimeSimulatorImpl::ProcessOneEvent (void) // It is important to understand that m_currentTs is interpreted only as the // timestamp of the last event we executed. Current time can a bit of a // slippery concept in realtime mode. What we have here is a discrete event - // simulator, so the last event is, by defintion, executed entirely at a single + // simulator, so the last event is, by definition, executed entirely at a single // discrete time. This is the definition of m_currentTs. It really has // nothing to do with the current real time, except that we are trying to arrange // that at the instant of the beginning of event execution, the current real time @@ -517,7 +517,7 @@ RealtimeSimulatorImpl::Schedule (Time const &delay, EventImpl *impl) { CriticalSection cs (m_mutex); // - // This is the reason we had to bring the absolute time calcualtion in from the + // This is the reason we had to bring the absolute time calculation in from the // simulator.h into the implementation. Since the implementations may be // multi-threaded, we need this calculation to be atomic. You can see it is // here since we are running in a CriticalSection. diff --git a/src/core/model/rng-seed-manager.h b/src/core/model/rng-seed-manager.h index c0848f96795..5b9473fb85a 100644 --- a/src/core/model/rng-seed-manager.h +++ b/src/core/model/rng-seed-manager.h @@ -78,7 +78,7 @@ class RngSeedManager * UniformVariable x(0,10); * ExponentialVariable y(2902); * \endcode - * In this example, \c N could successivly be equal to 1,2,3, _etc._ + * In this example, \c N could successively be equal to 1,2,3, _etc._ * and the user would continue to get independent runs out of the * single simulation. For this simple example, the following might work: * \code diff --git a/src/core/model/simulator-impl.h b/src/core/model/simulator-impl.h index a60af1d971c..c7ab841b06d 100644 --- a/src/core/model/simulator-impl.h +++ b/src/core/model/simulator-impl.h @@ -91,7 +91,7 @@ class SimulatorImpl : public Object * \param [in] schedulerFactory A new event scheduler factory. * * The event scheduler can be set at any time: the events scheduled - * in the previous scheduler will be transfered to the new scheduler + * in the previous scheduler will be transferred to the new scheduler * before we start to use it. */ virtual void SetScheduler (ObjectFactory schedulerFactory) = 0; diff --git a/src/core/model/synchronizer.h b/src/core/model/synchronizer.h index 4b6bfaa90bf..2bab776f5c0 100644 --- a/src/core/model/synchronizer.h +++ b/src/core/model/synchronizer.h @@ -125,7 +125,7 @@ class Synchronizer : public Object /** * @brief Wait until the real time is in sync with the specified simulation - * time or until the synchronizer is Sigalled. + * time or until the synchronizer is Signalled. * * This is where the real work of synchronization is done. The @c tsCurrent * argument is the simulation time. The job of Synchronize is to diff --git a/src/core/model/system-mutex.h b/src/core/model/system-mutex.h index f6abf4b4266..41224f344fb 100644 --- a/src/core/model/system-mutex.h +++ b/src/core/model/system-mutex.h @@ -42,7 +42,7 @@ class SystemMutexPrivate; * When more than one thread needs to access a shared resource (data structure * or device), the system needs to provide a way to serialize access to the * resource. An operating system will typically provide a Mutual Exclusion - * primitive to provide that capability. We provide plattorm-independent + * primitive to provide that capability. We provide platform-independent * access to the OS-dependent capability with the SystemMutex class. * * There are two operations: Lock and Unlock. Lock allows an executing diff --git a/src/core/model/system-thread.h b/src/core/model/system-thread.h index 2e3f315e4e8..359c8d03041 100644 --- a/src/core/model/system-thread.h +++ b/src/core/model/system-thread.h @@ -43,7 +43,7 @@ namespace ns3 { * This class allows for creation of multiple threads of execution in a * process. The exact implementation of the thread functionality is * operating system dependent, but typically in ns-3 one is using an - * environment in which Posix Threads are supported (either navively or + * environment in which Posix Threads are supported (either natively or * in the case of Windows via Cygwin's implementation of pthreads on the * Win32 API. In either case we expect that these will be kernel-level * threads and therefore a system with multiple CPUs will see truly concurrent diff --git a/src/core/model/test.h b/src/core/model/test.h index 87f444f6e81..45005664160 100644 --- a/src/core/model/test.h +++ b/src/core/model/test.h @@ -214,7 +214,7 @@ * numbers (float or double) as it is unlikely to do what you expect. * Use NS_TEST_ASSERT_MSG_EQ_RETURNS_BOOL_TOL instead. * - * This function returns a boolean value. + * This function returns a Boolean value. * */ #define NS_TEST_ASSERT_MSG_EQ_RETURNS_BOOL(actual, limit, msg) \ @@ -336,7 +336,7 @@ * because of floating point rounding errors. We provide a floating * point comparison function ns3::TestDoubleIsEqual() but you will * probably quickly find that is not what you want either. It may - * turn out to be the case that when you measured an snr that printed + * turn out to be the case that when you measured an SNR that printed * as 1128.93, what was actually measured was something more like * 1128.9287653857625442 for example. Given that the double epsilon * is on the order of 0.0000000000000009, you would need to provide @@ -426,7 +426,7 @@ * because of floating point rounding errors. We provide a floating * point comparison function ns3::TestDoubleIsEqual() but you will * probably quickly find that is not what you want either. It may - * turn out to be the case that when you measured an snr that printed + * turn out to be the case that when you measured an SNR that printed * as 1128.93, what was actually measured was something more like * 1128.9287653857625442 for example. Given that the double epsilon * is on the order of 0.0000000000000009, you would need to provide @@ -460,7 +460,7 @@ * \param [in] tol Tolerance of the test. * \param [in] msg Message that is output if the test does not pass. * - * This function returns a boolean value. + * This function returns a Boolean value. * */ #define NS_TEST_ASSERT_MSG_EQ_TOL_RETURNS_BOOL(actual, limit, tol, msg) \ @@ -521,7 +521,7 @@ * because of floating point rounding errors. We provide a floating * point comparison function ns3::TestDoubleIsEqual() but you will * probably quickly find that is not what you want either. It may - * turn out to be the case that when you measured an snr that printed + * turn out to be the case that when you measured an SNR that printed * as 1128.93, what was actually measured was something more like * 1128.9287653857625442 for example. Given that the double epsilon * is on the order of 0.0000000000000009, you would need to provide @@ -669,7 +669,7 @@ * \warning Do not use this macro if you are comparing floating point * numbers (float or double). Use NS_TEST_ASSERT_MSG_FLNE instead. * - * This function returns a boolean value. + * This function returns a Boolean value. * */ #define NS_TEST_ASSERT_MSG_NE_RETURNS_BOOL(actual, limit, msg) \ diff --git a/src/core/model/traced-value.h b/src/core/model/traced-value.h index d1bc9dede21..152b7f3c2e5 100644 --- a/src/core/model/traced-value.h +++ b/src/core/model/traced-value.h @@ -295,7 +295,7 @@ std::ostream& operator << (std::ostream& os, const TracedValue& rhs) * \tparam U \deduced The underlying type held by the right-hand argument. * \param [in] lhs The left-hand argument. * \param [in] rhs The right-hand argument. - * \returns The boolean result of comparing the underlying values. + * \returns The Boolean result of comparing the underlying values. */ template bool operator == (const TracedValue &lhs, const TracedValue &rhs) diff --git a/src/core/model/wall-clock-synchronizer.h b/src/core/model/wall-clock-synchronizer.h index b9dc9abdd86..98401081484 100644 --- a/src/core/model/wall-clock-synchronizer.h +++ b/src/core/model/wall-clock-synchronizer.h @@ -99,7 +99,7 @@ class WallClockSynchronizer : public Synchronizer * * @param [in] ns The target normalized real time we should wait for. * @returns @c true if we reached the target time, - * @c false if we retured because the condition was set. + * @c false if we returned because the condition was set. */ bool SpinWait (uint64_t ns); /** @@ -123,7 +123,7 @@ class WallClockSynchronizer : public Synchronizer * * @param [in] ns The target normalized real time we should wait for. * @returns @c true if we reached the target time, - * @c false if we retured because the condition was set. + * @c false if we returned because the condition was set. */ bool SleepWait (uint64_t ns); diff --git a/src/core/model/win32-system-wall-clock-ms.cc b/src/core/model/win32-system-wall-clock-ms.cc index 38096d50b8d..aa2355a7889 100644 --- a/src/core/model/win32-system-wall-clock-ms.cc +++ b/src/core/model/win32-system-wall-clock-ms.cc @@ -87,7 +87,7 @@ SystemWallClockMsPrivate::End (void) // internally? Works fine, lasts a long time. // // If millisecondsPerTick becomes fractional, and an elapsed time greater than - // a milliscond is measured, the function will work as expected. If an elapsed + // a millisecond is measured, the function will work as expected. If an elapsed // time is measured that turns out to be less than a millisecond, we'll just // return zero which would, I think, also will be expected. // From 37afc2b958acad3227a8149fddc1bbb733641781 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vedran=20Mileti=C4=87?= Date: Sat, 22 Jul 2017 11:27:41 +0200 Subject: [PATCH 198/551] Add missing include in LTE test --- src/lte/test/lte-test-aggregation-throughput-scale.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/test/lte-test-aggregation-throughput-scale.cc b/src/lte/test/lte-test-aggregation-throughput-scale.cc index 85e071a2a79..0e839758d78 100644 --- a/src/lte/test/lte-test-aggregation-throughput-scale.cc +++ b/src/lte/test/lte-test-aggregation-throughput-scale.cc @@ -22,6 +22,7 @@ #include "lte-test-aggregation-throughput-scale.h" #include +#include #include #include From fe23bcb15c4b3c49b4a64f679a725056622b97a2 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sat, 22 Jul 2017 13:37:35 -0700 Subject: [PATCH 199/551] lte: Rescan bindings (64-bit only) --- src/lte/bindings/callbacks_list.py | 45 +- src/lte/bindings/modulegen__gcc_LP64.py | 4200 +++++++++++++++-------- 2 files changed, 2892 insertions(+), 1353 deletions(-) diff --git a/src/lte/bindings/callbacks_list.py b/src/lte/bindings/callbacks_list.py index 8f9e97152d3..018a86e582f 100644 --- a/src/lte/bindings/callbacks_list.py +++ b/src/lte/bindings/callbacks_list.py @@ -1,16 +1,41 @@ callback_classes = [ + ['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::Address const&', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['bool', 'ns3::Ptr', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'std::list, std::allocator > >', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'unsigned short', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::UlInfoListElement_s', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ['void', 'ns3::DlInfoListElement_s', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'std::list, std::allocator > >', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], - ['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::UlInfoListElement_s', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::PhyReceptionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::PhyTransmissionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'ns3::LteUePhy::State', 'ns3::LteUePhy::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'double', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'double', 'double', 'bool', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['bool', 'ns3::Ptr', 'const ns3::Address &', 'const ns3::Address &', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::EpcUeNas::State', 'ns3::EpcUeNas::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'const ns3::SpectrumValue &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned char', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned char', 'unsigned int', 'unsigned long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::UeManager::State', 'ns3::UeManager::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::LteRrcSap::MeasurementReport', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'ns3::DlSchedulingCallbackInfo', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned int', 'unsigned int', 'unsigned short', 'unsigned char', 'unsigned short', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::LteUeRrc::State', 'ns3::LteUeRrc::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], + ['void', 'unsigned long', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], ] diff --git a/src/lte/bindings/modulegen__gcc_LP64.py b/src/lte/bindings/modulegen__gcc_LP64.py index dd70f9e761c..e54217bfd72 100644 --- a/src/lte/bindings/modulegen__gcc_LP64.py +++ b/src/lte/bindings/modulegen__gcc_LP64.py @@ -22,10 +22,10 @@ def register_types(module): ## log.h (module 'core'): ns3::LogLevel [enumeration] module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') - ## ff-mac-common.h (module 'lte'): ns3::SetupRelease_e [enumeration] - module.add_enum('SetupRelease_e', ['setup', 'release']) ## ff-mac-common.h (module 'lte'): ns3::Result_e [enumeration] module.add_enum('Result_e', ['SUCCESS', 'FAILURE']) + ## ff-mac-common.h (module 'lte'): ns3::SetupRelease_e [enumeration] + module.add_enum('SetupRelease_e', ['setup', 'release']) ## ff-mac-common.h (module 'lte'): ns3::CeBitmap_e [enumeration] module.add_enum('CeBitmap_e', ['TA', 'DRX', 'CR']) ## ff-mac-common.h (module 'lte'): ns3::NormalExtended_e [enumeration] @@ -82,6 +82,42 @@ def register_types(module): module.add_class('DataOutputCallback', allow_subclassing=True, import_from_module='ns.stats') ## data-rate.h (module 'network'): ns3::DataRate [class] module.add_class('DataRate', import_from_module='ns.network') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::EpcTft']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteChunkProcessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteControlMessage']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteHarqPhy']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumModel']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::VendorSpecificValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::X2CellInfo']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::X2IfaceInfo']) ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s [struct] module.add_class('DlDciListElement_s') ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::Format_e [enumeration] @@ -460,10 +496,10 @@ def register_types(module): module.add_class('MeasConfig', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [struct] module.add_class('MeasGapConfig', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [enumeration] - module.add_enum('', ['GP0', 'GP1'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gap [enumeration] + module.add_enum('gap', ['GP0', 'GP1'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod [struct] module.add_class('MeasIdToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra [struct] @@ -494,8 +530,8 @@ def register_types(module): module.add_class('PdschConfigCommon', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated [struct] module.add_class('PdschConfigDedicated', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated [enumeration] - module.add_enum('', ['dB_6', 'dB_4dot77', 'dB_3', 'dB_1dot77', 'dB0', 'dB1', 'dB2', 'dB3'], outer_class=root_module['ns3::LteRrcSap::PdschConfigDedicated']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::db [enumeration] + module.add_enum('db', ['dB_6', 'dB_4dot77', 'dB_3', 'dB_1dot77', 'dB0', 'dB1', 'dB2', 'dB3'], outer_class=root_module['ns3::LteRrcSap::PdschConfigDedicated']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange [struct] module.add_class('PhysCellIdRange', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated [struct] @@ -536,8 +572,8 @@ def register_types(module): module.add_enum('', ['EVENT', 'PERIODICAL'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] module.add_enum('', ['EVENT_A1', 'EVENT_A2', 'EVENT_A3', 'EVENT_A4', 'EVENT_A5'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] - module.add_enum('', ['REPORT_STRONGEST_CELLS', 'REPORT_CGI'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::report [enumeration] + module.add_enum('report', ['REPORT_STRONGEST_CELLS', 'REPORT_CGI'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] module.add_enum('', ['RSRP', 'RSRQ'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] @@ -548,8 +584,8 @@ def register_types(module): module.add_class('ReportConfigToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig [struct] module.add_class('RlcConfig', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig [enumeration] - module.add_enum('', ['AM', 'UM_BI_DIRECTIONAL', 'UM_UNI_DIRECTIONAL_UL', 'UM_UNI_DIRECTIONAL_DL'], outer_class=root_module['ns3::LteRrcSap::RlcConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::direction [enumeration] + module.add_enum('direction', ['AM', 'UM_BI_DIRECTIONAL', 'UM_UNI_DIRECTIONAL_UL', 'UM_UNI_DIRECTIONAL_DL'], outer_class=root_module['ns3::LteRrcSap::RlcConfig']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration [struct] module.add_class('RrcConnectionReconfiguration', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted [struct] @@ -576,16 +612,16 @@ def register_types(module): module.add_class('SCellToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon [struct] module.add_class('SoundingRsUlConfigCommon', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigCommon']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigCommon']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated [struct] module.add_class('SoundingRsUlConfigDedicated', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigDedicated']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigDedicated']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars [struct] module.add_class('SpeedStatePars', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SpeedStatePars']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SpeedStatePars']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors [struct] module.add_class('SpeedStateScaleFactors', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod [struct] @@ -672,8 +708,8 @@ def register_types(module): module.add_class('PacketMetadata', import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) ## packet.h (module 'network'): ns3::PacketTagIterator [class] @@ -778,9 +814,9 @@ def register_types(module): module.add_class('fdbetsFlowPerf_t') ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t [struct] module.add_class('fdtbfqsFlowPerf_t') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t [struct] module.add_class('pfsFlowPerf_t') @@ -818,8 +854,8 @@ def register_types(module): module.add_class('SetupUeParameters', outer_class=root_module['ns3::LteEnbRrcSapUser']) ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader [class] module.add_class('LtePdcpHeader', parent=root_module['ns3::Header']) - ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::DcBit_t [enumeration] - module.add_enum('DcBit_t', ['CONTROL_PDU', 'DATA_PDU'], outer_class=root_module['ns3::LtePdcpHeader']) + ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader [enumeration] + module.add_enum('', ['CONTROL_PDU', 'DATA_PDU'], outer_class=root_module['ns3::LtePdcpHeader']) ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag [class] module.add_class('LtePhyTag', parent=root_module['ns3::Tag']) ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag [class] @@ -1230,6 +1266,10 @@ def register_types(module): module.add_class('MacStatsCalculator', parent=root_module['ns3::LteStatsCalculator']) ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage [class] module.add_class('MibLteControlMessage', parent=root_module['ns3::LteControlMessage']) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator [class] + module.add_class('MinMaxAvgTotalCalculator', import_from_module='ns.stats', template_parameters=['unsigned int'], parent=[root_module['ns3::DataCalculator'], root_module['ns3::StatisticalSummary']]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator [class] + module.add_class('MinMaxAvgTotalCalculator', import_from_module='ns.stats', template_parameters=['unsigned long'], parent=[root_module['ns3::DataCalculator'], root_module['ns3::StatisticalSummary']]) ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class] module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object']) ## net-device.h (module 'network'): ns3::NetDevice [class] @@ -1344,6 +1384,78 @@ def register_types(module): module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage [class] module.add_class('BsrLteControlMessage', parent=root_module['ns3::LteControlMessage']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'const ns3::Address &', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'const ns3::SpectrumValue &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::DlSchedulingCallbackInfo', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::EpcUeNas::State', 'ns3::EpcUeNas::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::PhyReceptionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::PhyTransmissionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned int', 'unsigned int', 'unsigned short', 'unsigned char', 'unsigned short', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::LteRrcSap::MeasurementReport', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::LteUeRrc::State', 'ns3::LteUeRrc::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::UeManager::State', 'ns3::UeManager::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long', 'unsigned short', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned char', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned char', 'unsigned int', 'unsigned long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'double', 'bool', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned short', 'unsigned short', 'ns3::LteUePhy::State', 'ns3::LteUePhy::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler [class] module.add_class('CqaFfMacScheduler', parent=root_module['ns3::FfMacScheduler']) ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage [class] @@ -1412,9 +1524,9 @@ def register_types(module): module.add_container('std::list< ns3::EpcS1apSapMme::ErabToBeReleasedIndication >', 'ns3::EpcS1apSapMme::ErabToBeReleasedIndication', container_type=u'list') module.add_container('std::list< ns3::EpcS1apSapMme::ErabSetupItem >', 'ns3::EpcS1apSapMme::ErabSetupItem', container_type=u'list') module.add_container('std::list< ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem >', 'ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem', container_type=u'list') + module.add_container('std::vector< bool >', 'bool', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::UlInterferenceOverloadIndicationItem >', 'ns3::EpcX2Sap::UlInterferenceOverloadIndicationItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::UlHighInterferenceInformationItem >', 'ns3::EpcX2Sap::UlHighInterferenceInformationItem', container_type=u'vector') - module.add_container('std::vector< bool >', 'bool', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', 'ns3::EpcX2Sap::ErabToBeSetupItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabAdmittedItem >', 'ns3::EpcX2Sap::ErabAdmittedItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabNotAdmittedItem >', 'ns3::EpcX2Sap::ErabNotAdmittedItem', container_type=u'vector') @@ -1465,127 +1577,127 @@ def register_types(module): module.add_container('ns3::Bands', 'ns3::BandInfo', container_type=u'vector') module.add_container('std::map< unsigned char, ns3::ComponentCarrier >', ('unsigned char', 'ns3::ComponentCarrier'), container_type=u'map') module.add_container('std::map< unsigned int, unsigned int >', ('unsigned int', 'unsigned int'), container_type=u'map') + module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierEnb >'), container_type=u'map') module.add_container('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'ns3::Ptr< ns3::LteControlMessage >', container_type=u'list') module.add_container('std::list< ns3::UlDciLteControlMessage >', 'ns3::UlDciLteControlMessage', container_type=u'list') module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierUe >'), container_type=u'map') - module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierEnb >'), container_type=u'map') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesStatus_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesStatus_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesStatus_t&') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesTimer_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesTimer_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesTimer_t&') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >', u'ns3::DlHarqProcessesDciBuffer_t') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >*', u'ns3::DlHarqProcessesDciBuffer_t*') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >&', u'ns3::DlHarqProcessesDciBuffer_t&') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >', u'ns3::RlcPduList_t') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >*', u'ns3::RlcPduList_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >&', u'ns3::RlcPduList_t&') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >', u'ns3::DlHarqRlcPduListBuffer_t') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >*', u'ns3::DlHarqRlcPduListBuffer_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >&', u'ns3::DlHarqRlcPduListBuffer_t&') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >', u'ns3::UlHarqProcessesDciBuffer_t') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >*', u'ns3::UlHarqProcessesDciBuffer_t*') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >&', u'ns3::UlHarqProcessesDciBuffer_t&') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::UlHarqProcessesStatus_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::UlHarqProcessesStatus_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::UlHarqProcessesStatus_t&') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >', u'ns3::Uint32Map') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >*', u'ns3::Uint32Map*') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >&', u'ns3::Uint32Map&') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long > > >', u'ns3::Uint64Map') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long > > >*', u'ns3::Uint64Map*') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long > > >&', u'ns3::Uint64Map&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >', u'ns3::DlHarqRlcPduListBuffer_t') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >*', u'ns3::DlHarqRlcPduListBuffer_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >&', u'ns3::DlHarqRlcPduListBuffer_t&') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >', u'ns3::HarqProcessInfoList_t') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >*', u'ns3::HarqProcessInfoList_t*') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >&', u'ns3::HarqProcessInfoList_t&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >', u'ns3::Uint32StatsMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >*', u'ns3::Uint32StatsMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >&', u'ns3::Uint32StatsMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >', u'ns3::Uint64StatsMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >*', u'ns3::Uint64StatsMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >&', u'ns3::Uint64StatsMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >', u'ns3::DoubleMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >*', u'ns3::DoubleMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >&', u'ns3::DoubleMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >', u'ns3::FlowIdMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >*', u'ns3::FlowIdMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >&', u'ns3::FlowIdMap&') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >', u'ns3::DlHarqProcessesBuffer_t') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >*', u'ns3::DlHarqProcessesBuffer_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >&', u'ns3::DlHarqProcessesBuffer_t&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LteChunkProcessorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LteChunkProcessorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LteChunkProcessorCallback&') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >', u'ns3::expectedTbs_t') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >*', u'ns3::expectedTbs_t*') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >&', u'ns3::expectedTbs_t&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyTxEndCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyTxEndCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyTxEndCallback&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndOkCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndErrorCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndErrorCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndErrorCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndOkCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndOkCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndErrorCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndErrorCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndErrorCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >', u'ns3::Values') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >*', u'ns3::Values*') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >&', u'ns3::Values&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesStatus_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesStatus_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesStatus_t&') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', u'ns3::Bands') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', u'ns3::Bands*') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', u'ns3::Bands&') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxPssCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxPssCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxPssCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyDlHarqFeedbackCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyDlHarqFeedbackCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyDlHarqFeedbackCallback&') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >', u'ns3::expectedTbs_t') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >*', u'ns3::expectedTbs_t*') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >&', u'ns3::expectedTbs_t&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyUlHarqFeedbackCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyUlHarqFeedbackCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyUlHarqFeedbackCallback&') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >', u'ns3::HarqProcessInfoList_t') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >*', u'ns3::HarqProcessInfoList_t*') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >&', u'ns3::HarqProcessInfoList_t&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') module.add_typedef(root_module['ns3::Vector3D'], 'Vector') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >', u'ns3::UlHarqProcessesDciBuffer_t') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >*', u'ns3::UlHarqProcessesDciBuffer_t*') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >&', u'ns3::UlHarqProcessesDciBuffer_t&') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndOkCallback&') - typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') - typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') - typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >', u'ns3::DoubleMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >*', u'ns3::DoubleMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >&', u'ns3::DoubleMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyUlHarqFeedbackCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyUlHarqFeedbackCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyUlHarqFeedbackCallback&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >', u'ns3::Uint64StatsMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >*', u'ns3::Uint64StatsMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long > > > > >&', u'ns3::Uint64StatsMap&') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >', u'ns3::RlcPduList_t') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >*', u'ns3::RlcPduList_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >&', u'ns3::RlcPduList_t&') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >', u'ns3::DlHarqProcessesDciBuffer_t') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >*', u'ns3::DlHarqProcessesDciBuffer_t*') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >&', u'ns3::DlHarqProcessesDciBuffer_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >', u'ns3::FlowIdMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >*', u'ns3::FlowIdMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >&', u'ns3::FlowIdMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LteChunkProcessorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LteChunkProcessorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LteChunkProcessorCallback&') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesTimer_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesTimer_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesTimer_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >', u'ns3::Uint32StatsMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >*', u'ns3::Uint32StatsMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >&', u'ns3::Uint32StatsMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxPssCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxPssCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxPssCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >', u'ns3::DlHarqProcessesBuffer_t') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >*', u'ns3::DlHarqProcessesBuffer_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >&', u'ns3::DlHarqProcessesBuffer_t&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::UlHarqProcessesStatus_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::UlHarqProcessesStatus_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::UlHarqProcessesStatus_t&') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >', u'ns3::Values') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >*', u'ns3::Values*') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >&', u'ns3::Values&') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', u'ns3::Bands') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', u'ns3::Bands*') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', u'ns3::Bands&') + typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') + typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') + typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') ## Register a nested module for the namespace Config @@ -1634,12 +1746,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -1662,36 +1774,36 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -1721,6 +1833,24 @@ def register_methods(root_module): register_Ns3CqiListElement_s_methods(root_module, root_module['ns3::CqiListElement_s']) register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback']) register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EpcTft_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EpcTft >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3LteChunkProcessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteChunkProcessor >']) + register_Ns3DefaultDeleter__Ns3LteControlMessage_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteControlMessage >']) + register_Ns3DefaultDeleter__Ns3LteHarqPhy_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteHarqPhy >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumModel >']) + register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumValue >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) + register_Ns3DefaultDeleter__Ns3VendorSpecificValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::VendorSpecificValue >']) + register_Ns3DefaultDeleter__Ns3X2CellInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2CellInfo >']) + register_Ns3DefaultDeleter__Ns3X2IfaceInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2IfaceInfo >']) register_Ns3DlDciListElement_s_methods(root_module, root_module['ns3::DlDciListElement_s']) register_Ns3DlInfoListElement_s_methods(root_module, root_module['ns3::DlInfoListElement_s']) register_Ns3DlSchedulingCallbackInfo_methods(root_module, root_module['ns3::DlSchedulingCallbackInfo']) @@ -2213,6 +2343,8 @@ def register_methods(root_module): register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) register_Ns3MacStatsCalculator_methods(root_module, root_module['ns3::MacStatsCalculator']) register_Ns3MibLteControlMessage_methods(root_module, root_module['ns3::MibLteControlMessage']) + register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >']) + register_Ns3MinMaxAvgTotalCalculator__Unsigned_long_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned long >']) register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel']) register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector']) @@ -2269,6 +2401,42 @@ def register_methods(root_module): register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) register_Ns3BsrLteControlMessage_methods(root_module, root_module['ns3::BsrLteControlMessage']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Packet__gt___Const_ns3Address___amp___Const_ns3Address___amp___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Const_ns3SpectrumValue___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, const ns3::SpectrumValue &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3DlSchedulingCallbackInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::DlSchedulingCallbackInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3EpcUeNasState_Ns3EpcUeNasState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::EpcUeNas::State, ns3::EpcUeNas::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3PhyReceptionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyReceptionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3PhyTransmissionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyTransmissionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3PacketBurst__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, unsigned short, unsigned char, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteRrcSapMeasurementReport_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteRrcSap::MeasurementReport, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteUeRrcState_Ns3LteUeRrcState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteUeRrc::State, ns3::LteUeRrc::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3UeManagerState_Ns3UeManagerState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::UeManager::State, ns3::UeManager::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Ns3Ptr__lt__ns3SpectrumValue__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Bool_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, bool, unsigned char, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3LteUePhyState_Ns3LteUePhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::LteUePhy::State, ns3::LteUePhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3CqaFfMacScheduler_methods(root_module, root_module['ns3::CqaFfMacScheduler']) register_Ns3DlCqiLteControlMessage_methods(root_module, root_module['ns3::DlCqiLteControlMessage']) register_Ns3DlDciLteControlMessage_methods(root_module, root_module['ns3::DlDciLteControlMessage']) @@ -2304,15 +2472,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -2374,7 +2542,7 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3AllocationRetentionPriority_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority(ns3::AllocationRetentionPriority const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority(ns3::AllocationRetentionPriority const & arg0) [constructor] cls.add_constructor([param('ns3::AllocationRetentionPriority const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority() [constructor] cls.add_constructor([]) @@ -2387,25 +2555,25 @@ def register_Ns3AllocationRetentionPriority_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2415,7 +2583,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -2428,7 +2596,7 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): def register_Ns3BandInfo_methods(root_module, cls): ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo() [constructor] cls.add_constructor([]) - ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [constructor] cls.add_constructor([param('ns3::BandInfo const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::fc [variable] cls.add_instance_attribute('fc', 'double', is_const=False) @@ -2439,14 +2607,14 @@ def register_Ns3BandInfo_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', @@ -2519,7 +2687,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -2681,7 +2849,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): def register_Ns3BufferSizeLevelBsr_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr(ns3::BufferSizeLevelBsr const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr(ns3::BufferSizeLevelBsr const & arg0) [constructor] cls.add_constructor([param('ns3::BufferSizeLevelBsr const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint32_t ns3::BufferSizeLevelBsr::BsrId2BufferSize(uint8_t val) [member function] cls.add_method('BsrId2BufferSize', @@ -2700,7 +2868,7 @@ def register_Ns3BufferSizeLevelBsr_methods(root_module, cls): def register_Ns3BuildBroadcastListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s(ns3::BuildBroadcastListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s(ns3::BuildBroadcastListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildBroadcastListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::m_dci [variable] cls.add_instance_attribute('m_dci', 'ns3::DlDciListElement_s', is_const=False) @@ -2713,7 +2881,7 @@ def register_Ns3BuildBroadcastListElement_s_methods(root_module, cls): def register_Ns3BuildDataListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s(ns3::BuildDataListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s(ns3::BuildDataListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildDataListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::m_ceBitmap [variable] cls.add_instance_attribute('m_ceBitmap', 'std::vector< ns3::CeBitmap_e >', is_const=False) @@ -2728,7 +2896,7 @@ def register_Ns3BuildDataListElement_s_methods(root_module, cls): def register_Ns3BuildRarListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s(ns3::BuildRarListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s(ns3::BuildRarListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildRarListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::m_dci [variable] cls.add_instance_attribute('m_dci', 'ns3::DlDciListElement_s', is_const=False) @@ -2741,7 +2909,7 @@ def register_Ns3BuildRarListElement_s_methods(root_module, cls): def register_Ns3BwPart_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s(ns3::BwPart_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s(ns3::BwPart_s const & arg0) [constructor] cls.add_constructor([param('ns3::BwPart_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::m_bwPartIndex [variable] cls.add_instance_attribute('m_bwPartIndex', 'uint8_t', is_const=False) @@ -2752,7 +2920,7 @@ def register_Ns3BwPart_s_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2766,7 +2934,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -2793,7 +2961,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -2827,7 +2995,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -2846,7 +3014,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -2863,7 +3031,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -2880,7 +3048,7 @@ def register_Ns3CallbackBase_methods(root_module, cls): def register_Ns3CqasFlowPerf_t_methods(root_module, cls): ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t() [constructor] cls.add_constructor([]) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t(ns3::CqasFlowPerf_t const & arg0) [copy constructor] + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t(ns3::CqasFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::CqasFlowPerf_t const &', 'arg0')]) ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -2899,7 +3067,7 @@ def register_Ns3CqasFlowPerf_t_methods(root_module, cls): def register_Ns3CqiConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s(ns3::CqiConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s(ns3::CqiConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::CqiConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::m_action [variable] cls.add_instance_attribute('m_action', 'ns3::SetupRelease_e', is_const=False) @@ -2912,7 +3080,7 @@ def register_Ns3CqiConfig_s_methods(root_module, cls): def register_Ns3CqiListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s(ns3::CqiListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s(ns3::CqiListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::CqiListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::m_cqiType [variable] cls.add_instance_attribute('m_cqiType', 'ns3::CqiListElement_s::CqiType_e', is_const=False) @@ -2931,7 +3099,7 @@ def register_Ns3CqiListElement_s_methods(root_module, cls): def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback() [constructor] cls.add_constructor([]) - ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')]) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function] cls.add_method('OutputSingleton', @@ -2973,7 +3141,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('>=') - ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRate::DataRate() [constructor] cls.add_constructor([]) @@ -2995,7 +3163,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], - deprecated=True, is_const=True) + is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', 'uint64_t', @@ -3003,90 +3171,306 @@ def register_Ns3DataRate_methods(root_module, cls): is_const=True) return -def register_Ns3DlDciListElement_s_methods(root_module, cls): - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s(ns3::DlDciListElement_s const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlDciListElement_s const &', 'arg0')]) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_aggrLevel [variable] - cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_cceIndex [variable] - cls.add_instance_attribute('m_cceIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dai [variable] - cls.add_instance_attribute('m_dai', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dlPowerOffset [variable] - cls.add_instance_attribute('m_dlPowerOffset', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_format [variable] - cls.add_instance_attribute('m_format', 'ns3::DlDciListElement_s::Format_e', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_harqProcess [variable] - cls.add_instance_attribute('m_harqProcess', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_mcs [variable] - cls.add_instance_attribute('m_mcs', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_nGap [variable] - cls.add_instance_attribute('m_nGap', 'ns3::DlDciListElement_s::Ngap_e', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_ndi [variable] - cls.add_instance_attribute('m_ndi', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchOrder [variable] - cls.add_instance_attribute('m_pdcchOrder', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchPowerOffset [variable] - cls.add_instance_attribute('m_pdcchPowerOffset', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_prachMaskIndex [variable] - cls.add_instance_attribute('m_prachMaskIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_preambleIndex [variable] - cls.add_instance_attribute('m_preambleIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_precodingInfo [variable] - cls.add_instance_attribute('m_precodingInfo', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbBitmap [variable] - cls.add_instance_attribute('m_rbBitmap', 'uint32_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbShift [variable] - cls.add_instance_attribute('m_rbShift', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_resAlloc [variable] - cls.add_instance_attribute('m_resAlloc', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rnti [variable] - cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rv [variable] - cls.add_instance_attribute('m_rv', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_spsRelease [variable] - cls.add_instance_attribute('m_spsRelease', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbSwap [variable] - cls.add_instance_attribute('m_tbSwap', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsIdx [variable] - cls.add_instance_attribute('m_tbsIdx', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsSize [variable] - cls.add_instance_attribute('m_tbsSize', 'std::vector< unsigned short >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tpc [variable] - cls.add_instance_attribute('m_tpc', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_vrbFormat [variable] - cls.add_instance_attribute('m_vrbFormat', 'ns3::DlDciListElement_s::VrbFormat_e', is_const=False) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) return -def register_Ns3DlInfoListElement_s_methods(root_module, cls): - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s(ns3::DlInfoListElement_s const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlInfoListElement_s const &', 'arg0')]) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqProcessId [variable] - cls.add_instance_attribute('m_harqProcessId', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqStatus [variable] - cls.add_instance_attribute('m_harqStatus', 'std::vector< ns3::DlInfoListElement_s::HarqStatus_e >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_rnti [variable] - cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) return -def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo(ns3::DlSchedulingCallbackInfo const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlSchedulingCallbackInfo const &', 'arg0')]) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::componentCarrierId [variable] - cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::frameNo [variable] - cls.add_instance_attribute('frameNo', 'uint32_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb1 [variable] - cls.add_instance_attribute('mcsTb1', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb2 [variable] - cls.add_instance_attribute('mcsTb2', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::rnti [variable] + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EpcTft_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EpcTft > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EpcTft * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EpcTft *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteChunkProcessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteChunkProcessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteChunkProcessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteChunkProcessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteControlMessage_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteControlMessage > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteControlMessage * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteControlMessage *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteHarqPhy_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteHarqPhy > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteHarqPhy * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteHarqPhy *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumModel > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumModel * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SpectrumModel *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SpectrumValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3VendorSpecificValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::VendorSpecificValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::VendorSpecificValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::VendorSpecificValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3X2CellInfo_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::X2CellInfo > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::X2CellInfo * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::X2CellInfo *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3X2IfaceInfo_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::X2IfaceInfo > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::X2IfaceInfo * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::X2IfaceInfo *', 'object')], + is_static=True) + return + +def register_Ns3DlDciListElement_s_methods(root_module, cls): + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s() [constructor] + cls.add_constructor([]) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s(ns3::DlDciListElement_s const & arg0) [constructor] + cls.add_constructor([param('ns3::DlDciListElement_s const &', 'arg0')]) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_aggrLevel [variable] + cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_cceIndex [variable] + cls.add_instance_attribute('m_cceIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dai [variable] + cls.add_instance_attribute('m_dai', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dlPowerOffset [variable] + cls.add_instance_attribute('m_dlPowerOffset', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_format [variable] + cls.add_instance_attribute('m_format', 'ns3::DlDciListElement_s::Format_e', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_harqProcess [variable] + cls.add_instance_attribute('m_harqProcess', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_mcs [variable] + cls.add_instance_attribute('m_mcs', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_nGap [variable] + cls.add_instance_attribute('m_nGap', 'ns3::DlDciListElement_s::Ngap_e', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_ndi [variable] + cls.add_instance_attribute('m_ndi', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchOrder [variable] + cls.add_instance_attribute('m_pdcchOrder', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchPowerOffset [variable] + cls.add_instance_attribute('m_pdcchPowerOffset', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_prachMaskIndex [variable] + cls.add_instance_attribute('m_prachMaskIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_preambleIndex [variable] + cls.add_instance_attribute('m_preambleIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_precodingInfo [variable] + cls.add_instance_attribute('m_precodingInfo', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbBitmap [variable] + cls.add_instance_attribute('m_rbBitmap', 'uint32_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbShift [variable] + cls.add_instance_attribute('m_rbShift', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_resAlloc [variable] + cls.add_instance_attribute('m_resAlloc', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rnti [variable] + cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rv [variable] + cls.add_instance_attribute('m_rv', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_spsRelease [variable] + cls.add_instance_attribute('m_spsRelease', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbSwap [variable] + cls.add_instance_attribute('m_tbSwap', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsIdx [variable] + cls.add_instance_attribute('m_tbsIdx', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsSize [variable] + cls.add_instance_attribute('m_tbsSize', 'std::vector< unsigned short >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tpc [variable] + cls.add_instance_attribute('m_tpc', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_vrbFormat [variable] + cls.add_instance_attribute('m_vrbFormat', 'ns3::DlDciListElement_s::VrbFormat_e', is_const=False) + return + +def register_Ns3DlInfoListElement_s_methods(root_module, cls): + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s() [constructor] + cls.add_constructor([]) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s(ns3::DlInfoListElement_s const & arg0) [constructor] + cls.add_constructor([param('ns3::DlInfoListElement_s const &', 'arg0')]) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqProcessId [variable] + cls.add_instance_attribute('m_harqProcessId', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqStatus [variable] + cls.add_instance_attribute('m_harqStatus', 'std::vector< ns3::DlInfoListElement_s::HarqStatus_e >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_rnti [variable] + cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + return + +def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo() [constructor] + cls.add_constructor([]) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo(ns3::DlSchedulingCallbackInfo const & arg0) [constructor] + cls.add_constructor([param('ns3::DlSchedulingCallbackInfo const &', 'arg0')]) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::componentCarrierId [variable] + cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::frameNo [variable] + cls.add_instance_attribute('frameNo', 'uint32_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb1 [variable] + cls.add_instance_attribute('mcsTb1', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb2 [variable] + cls.add_instance_attribute('mcsTb2', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::rnti [variable] cls.add_instance_attribute('rnti', 'uint16_t', is_const=False) ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::sizeTb1 [variable] cls.add_instance_attribute('sizeTb1', 'uint16_t', is_const=False) @@ -3099,7 +3483,7 @@ def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): def register_Ns3DrxConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s(ns3::DrxConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s(ns3::DrxConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::DrxConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::m_drxInactivityTimer [variable] cls.add_instance_attribute('m_drxInactivityTimer', 'uint16_t', is_const=False) @@ -3120,7 +3504,7 @@ def register_Ns3DrxConfig_s_methods(root_module, cls): def register_Ns3EpcEnbS1SapProvider_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider(ns3::EpcEnbS1SapProvider const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider(ns3::EpcEnbS1SapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): void ns3::EpcEnbS1SapProvider::DoSendReleaseIndication(uint64_t imsi, uint16_t rnti, uint8_t bearerId) [member function] cls.add_method('DoSendReleaseIndication', @@ -3147,7 +3531,7 @@ def register_Ns3EpcEnbS1SapProvider_methods(root_module, cls): def register_Ns3EpcEnbS1SapProviderBearerToBeSwitched_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched(ns3::EpcEnbS1SapProvider::BearerToBeSwitched const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched(ns3::EpcEnbS1SapProvider::BearerToBeSwitched const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider::BearerToBeSwitched const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3158,7 +3542,7 @@ def register_Ns3EpcEnbS1SapProviderBearerToBeSwitched_methods(root_module, cls): def register_Ns3EpcEnbS1SapProviderPathSwitchRequestParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters(ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters(ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::bearersToBeSwitched [variable] cls.add_instance_attribute('bearersToBeSwitched', 'std::list< ns3::EpcEnbS1SapProvider::BearerToBeSwitched >', is_const=False) @@ -3173,7 +3557,7 @@ def register_Ns3EpcEnbS1SapProviderPathSwitchRequestParameters_methods(root_modu def register_Ns3EpcEnbS1SapUser_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser(ns3::EpcEnbS1SapUser const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser(ns3::EpcEnbS1SapUser const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): void ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequest(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters params) [member function] cls.add_method('DataRadioBearerSetupRequest', @@ -3190,7 +3574,7 @@ def register_Ns3EpcEnbS1SapUser_methods(root_module, cls): def register_Ns3EpcEnbS1SapUserDataRadioBearerSetupRequestParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::bearer [variable] cls.add_instance_attribute('bearer', 'ns3::EpsBearer', is_const=False) @@ -3207,7 +3591,7 @@ def register_Ns3EpcEnbS1SapUserDataRadioBearerSetupRequestParameters_methods(roo def register_Ns3EpcEnbS1SapUserPathSwitchRequestAcknowledgeParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters(ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters(ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::rnti [variable] cls.add_instance_attribute('rnti', 'uint16_t', is_const=False) @@ -3216,14 +3600,14 @@ def register_Ns3EpcEnbS1SapUserPathSwitchRequestAcknowledgeParameters_methods(ro def register_Ns3EpcS11Sap_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap(ns3::EpcS11Sap const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap(ns3::EpcS11Sap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap const &', 'arg0')]) return def register_Ns3EpcS11SapFteid_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid(ns3::EpcS11Sap::Fteid const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid(ns3::EpcS11Sap::Fteid const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::Fteid const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::address [variable] cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False) @@ -3234,7 +3618,7 @@ def register_Ns3EpcS11SapFteid_methods(root_module, cls): def register_Ns3EpcS11SapGtpcMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage(ns3::EpcS11Sap::GtpcMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage(ns3::EpcS11Sap::GtpcMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::GtpcMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::teid [variable] cls.add_instance_attribute('teid', 'uint32_t', is_const=False) @@ -3243,7 +3627,7 @@ def register_Ns3EpcS11SapGtpcMessage_methods(root_module, cls): def register_Ns3EpcS11SapUli_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli(ns3::EpcS11Sap::Uli const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli(ns3::EpcS11Sap::Uli const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::Uli const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::gci [variable] cls.add_instance_attribute('gci', 'uint16_t', is_const=False) @@ -3252,7 +3636,7 @@ def register_Ns3EpcS11SapUli_methods(root_module, cls): def register_Ns3EpcS11SapMme_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme(ns3::EpcS11SapMme const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme(ns3::EpcS11SapMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): void ns3::EpcS11SapMme::CreateSessionResponse(ns3::EpcS11SapMme::CreateSessionResponseMessage msg) [member function] cls.add_method('CreateSessionResponse', @@ -3274,7 +3658,7 @@ def register_Ns3EpcS11SapMme_methods(root_module, cls): def register_Ns3EpcS11SapMmeBearerContextCreated_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated(ns3::EpcS11SapMme::BearerContextCreated const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated(ns3::EpcS11SapMme::BearerContextCreated const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::BearerContextCreated const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::bearerLevelQos [variable] cls.add_instance_attribute('bearerLevelQos', 'ns3::EpsBearer', is_const=False) @@ -3289,7 +3673,7 @@ def register_Ns3EpcS11SapMmeBearerContextCreated_methods(root_module, cls): def register_Ns3EpcS11SapMmeBearerContextRemoved_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved(ns3::EpcS11SapMme::BearerContextRemoved const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved(ns3::EpcS11SapMme::BearerContextRemoved const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::BearerContextRemoved const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3298,7 +3682,7 @@ def register_Ns3EpcS11SapMmeBearerContextRemoved_methods(root_module, cls): def register_Ns3EpcS11SapMmeCreateSessionResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage(ns3::EpcS11SapMme::CreateSessionResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage(ns3::EpcS11SapMme::CreateSessionResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::CreateSessionResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::bearerContextsCreated [variable] cls.add_instance_attribute('bearerContextsCreated', 'std::list< ns3::EpcS11SapMme::BearerContextCreated >', is_const=False) @@ -3307,7 +3691,7 @@ def register_Ns3EpcS11SapMmeCreateSessionResponseMessage_methods(root_module, cl def register_Ns3EpcS11SapMmeDeleteBearerRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage(ns3::EpcS11SapMme::DeleteBearerRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage(ns3::EpcS11SapMme::DeleteBearerRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::DeleteBearerRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::bearerContextsRemoved [variable] cls.add_instance_attribute('bearerContextsRemoved', 'std::list< ns3::EpcS11SapMme::BearerContextRemoved >', is_const=False) @@ -3316,7 +3700,7 @@ def register_Ns3EpcS11SapMmeDeleteBearerRequestMessage_methods(root_module, cls) def register_Ns3EpcS11SapMmeModifyBearerResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage(ns3::EpcS11SapMme::ModifyBearerResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage(ns3::EpcS11SapMme::ModifyBearerResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::ModifyBearerResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::cause [variable] cls.add_instance_attribute('cause', 'ns3::EpcS11SapMme::ModifyBearerResponseMessage::Cause', is_const=False) @@ -3325,7 +3709,7 @@ def register_Ns3EpcS11SapMmeModifyBearerResponseMessage_methods(root_module, cls def register_Ns3EpcS11SapSgw_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw(ns3::EpcS11SapSgw const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw(ns3::EpcS11SapSgw const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): void ns3::EpcS11SapSgw::CreateSessionRequest(ns3::EpcS11SapSgw::CreateSessionRequestMessage msg) [member function] cls.add_method('CreateSessionRequest', @@ -3352,7 +3736,7 @@ def register_Ns3EpcS11SapSgw_methods(root_module, cls): def register_Ns3EpcS11SapSgwBearerContextRemovedSgwPgw_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw(ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw(ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3361,7 +3745,7 @@ def register_Ns3EpcS11SapSgwBearerContextRemovedSgwPgw_methods(root_module, cls) def register_Ns3EpcS11SapSgwBearerContextToBeCreated_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated(ns3::EpcS11SapSgw::BearerContextToBeCreated const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated(ns3::EpcS11SapSgw::BearerContextToBeCreated const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextToBeCreated const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::bearerLevelQos [variable] cls.add_instance_attribute('bearerLevelQos', 'ns3::EpsBearer', is_const=False) @@ -3376,7 +3760,7 @@ def register_Ns3EpcS11SapSgwBearerContextToBeCreated_methods(root_module, cls): def register_Ns3EpcS11SapSgwBearerContextToBeRemoved_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved(ns3::EpcS11SapSgw::BearerContextToBeRemoved const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved(ns3::EpcS11SapSgw::BearerContextToBeRemoved const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextToBeRemoved const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3385,7 +3769,7 @@ def register_Ns3EpcS11SapSgwBearerContextToBeRemoved_methods(root_module, cls): def register_Ns3EpcS11SapSgwCreateSessionRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage(ns3::EpcS11SapSgw::CreateSessionRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage(ns3::EpcS11SapSgw::CreateSessionRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::CreateSessionRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::bearerContextsToBeCreated [variable] cls.add_instance_attribute('bearerContextsToBeCreated', 'std::list< ns3::EpcS11SapSgw::BearerContextToBeCreated >', is_const=False) @@ -3398,7 +3782,7 @@ def register_Ns3EpcS11SapSgwCreateSessionRequestMessage_methods(root_module, cls def register_Ns3EpcS11SapSgwDeleteBearerCommandMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage(ns3::EpcS11SapSgw::DeleteBearerCommandMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage(ns3::EpcS11SapSgw::DeleteBearerCommandMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::DeleteBearerCommandMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::bearerContextsToBeRemoved [variable] cls.add_instance_attribute('bearerContextsToBeRemoved', 'std::list< ns3::EpcS11SapSgw::BearerContextToBeRemoved >', is_const=False) @@ -3407,7 +3791,7 @@ def register_Ns3EpcS11SapSgwDeleteBearerCommandMessage_methods(root_module, cls) def register_Ns3EpcS11SapSgwDeleteBearerResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage(ns3::EpcS11SapSgw::DeleteBearerResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage(ns3::EpcS11SapSgw::DeleteBearerResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::DeleteBearerResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::bearerContextsRemoved [variable] cls.add_instance_attribute('bearerContextsRemoved', 'std::list< ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw >', is_const=False) @@ -3416,7 +3800,7 @@ def register_Ns3EpcS11SapSgwDeleteBearerResponseMessage_methods(root_module, cls def register_Ns3EpcS11SapSgwModifyBearerRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage(ns3::EpcS11SapSgw::ModifyBearerRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage(ns3::EpcS11SapSgw::ModifyBearerRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::ModifyBearerRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::uli [variable] cls.add_instance_attribute('uli', 'ns3::EpcS11Sap::Uli', is_const=False) @@ -3425,14 +3809,14 @@ def register_Ns3EpcS11SapSgwModifyBearerRequestMessage_methods(root_module, cls) def register_Ns3EpcS1apSap_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap(ns3::EpcS1apSap const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap(ns3::EpcS1apSap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSap const &', 'arg0')]) return def register_Ns3EpcS1apSapEnb_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb(ns3::EpcS1apSapEnb const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb(ns3::EpcS1apSapEnb const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): void ns3::EpcS1apSapEnb::InitialContextSetupRequest(uint64_t mmeUeS1Id, uint16_t enbUeS1Id, std::list > erabToBeSetupList) [member function] cls.add_method('InitialContextSetupRequest', @@ -3449,7 +3833,7 @@ def register_Ns3EpcS1apSapEnb_methods(root_module, cls): def register_Ns3EpcS1apSapEnbErabSwitchedInUplinkItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem(ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem(ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3462,7 +3846,7 @@ def register_Ns3EpcS1apSapEnbErabSwitchedInUplinkItem_methods(root_module, cls): def register_Ns3EpcS1apSapEnbErabToBeSetupItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcS1apSapEnb::ErabToBeSetupItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcS1apSapEnb::ErabToBeSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb::ErabToBeSetupItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::erabId [variable] cls.add_instance_attribute('erabId', 'uint8_t', is_const=False) @@ -3477,7 +3861,7 @@ def register_Ns3EpcS1apSapEnbErabToBeSetupItem_methods(root_module, cls): def register_Ns3EpcS1apSapMme_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme(ns3::EpcS1apSapMme const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme(ns3::EpcS1apSapMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): void ns3::EpcS1apSapMme::ErabReleaseIndication(uint64_t mmeUeS1Id, uint16_t enbUeS1Id, std::list > erabToBeReleaseIndication) [member function] cls.add_method('ErabReleaseIndication', @@ -3504,7 +3888,7 @@ def register_Ns3EpcS1apSapMme_methods(root_module, cls): def register_Ns3EpcS1apSapMmeErabSetupItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem(ns3::EpcS1apSapMme::ErabSetupItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem(ns3::EpcS1apSapMme::ErabSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabSetupItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3517,7 +3901,7 @@ def register_Ns3EpcS1apSapMmeErabSetupItem_methods(root_module, cls): def register_Ns3EpcS1apSapMmeErabSwitchedInDownlinkItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem(ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem(ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3530,7 +3914,7 @@ def register_Ns3EpcS1apSapMmeErabSwitchedInDownlinkItem_methods(root_module, cls def register_Ns3EpcS1apSapMmeErabToBeReleasedIndication_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication(ns3::EpcS1apSapMme::ErabToBeReleasedIndication const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication(ns3::EpcS1apSapMme::ErabToBeReleasedIndication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabToBeReleasedIndication const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::erabId [variable] cls.add_instance_attribute('erabId', 'uint8_t', is_const=False) @@ -3539,7 +3923,7 @@ def register_Ns3EpcS1apSapMmeErabToBeReleasedIndication_methods(root_module, cls def register_Ns3EpcX2Sap_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap(ns3::EpcX2Sap const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap(ns3::EpcX2Sap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::m_maxPdcpSn [variable] cls.add_static_attribute('m_maxPdcpSn', 'uint16_t const', is_const=True) @@ -3548,7 +3932,7 @@ def register_Ns3EpcX2Sap_methods(root_module, cls): def register_Ns3EpcX2SapCellInformationItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem(ns3::EpcX2Sap::CellInformationItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem(ns3::EpcX2Sap::CellInformationItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CellInformationItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::relativeNarrowbandTxBand [variable] cls.add_instance_attribute('relativeNarrowbandTxBand', 'ns3::EpcX2Sap::RelativeNarrowbandTxBand', is_const=False) @@ -3563,7 +3947,7 @@ def register_Ns3EpcX2SapCellInformationItem_methods(root_module, cls): def register_Ns3EpcX2SapCellMeasurementResultItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem(ns3::EpcX2Sap::CellMeasurementResultItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem(ns3::EpcX2Sap::CellMeasurementResultItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CellMeasurementResultItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::dlCompositeAvailableCapacity [variable] cls.add_instance_attribute('dlCompositeAvailableCapacity', 'ns3::EpcX2Sap::CompositeAvailCapacity', is_const=False) @@ -3596,7 +3980,7 @@ def register_Ns3EpcX2SapCellMeasurementResultItem_methods(root_module, cls): def register_Ns3EpcX2SapCompositeAvailCapacity_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity(ns3::EpcX2Sap::CompositeAvailCapacity const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity(ns3::EpcX2Sap::CompositeAvailCapacity const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CompositeAvailCapacity const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::capacityValue [variable] cls.add_instance_attribute('capacityValue', 'uint16_t', is_const=False) @@ -3607,7 +3991,7 @@ def register_Ns3EpcX2SapCompositeAvailCapacity_methods(root_module, cls): def register_Ns3EpcX2SapErabAdmittedItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem(ns3::EpcX2Sap::ErabAdmittedItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem(ns3::EpcX2Sap::ErabAdmittedItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabAdmittedItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::dlGtpTeid [variable] cls.add_instance_attribute('dlGtpTeid', 'uint32_t', is_const=False) @@ -3620,7 +4004,7 @@ def register_Ns3EpcX2SapErabAdmittedItem_methods(root_module, cls): def register_Ns3EpcX2SapErabNotAdmittedItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem(ns3::EpcX2Sap::ErabNotAdmittedItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem(ns3::EpcX2Sap::ErabNotAdmittedItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabNotAdmittedItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::cause [variable] cls.add_instance_attribute('cause', 'uint16_t', is_const=False) @@ -3629,7 +4013,7 @@ def register_Ns3EpcX2SapErabNotAdmittedItem_methods(root_module, cls): return def register_Ns3EpcX2SapErabToBeSetupItem_methods(root_module, cls): - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcX2Sap::ErabToBeSetupItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcX2Sap::ErabToBeSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabToBeSetupItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem() [constructor] cls.add_constructor([]) @@ -3648,7 +4032,7 @@ def register_Ns3EpcX2SapErabToBeSetupItem_methods(root_module, cls): def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem(ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem(ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::dlHfn [variable] cls.add_instance_attribute('dlHfn', 'uint32_t', is_const=False) @@ -3657,7 +4041,7 @@ def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cl ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::erabId [variable] cls.add_instance_attribute('erabId', 'uint16_t', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::receiveStatusOfUlPdcpSdus [variable] - cls.add_instance_attribute('receiveStatusOfUlPdcpSdus', 'std::bitset< 4096ul >', is_const=False) + cls.add_instance_attribute('receiveStatusOfUlPdcpSdus', 'std::bitset< 4096 >', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ulHfn [variable] cls.add_instance_attribute('ulHfn', 'uint32_t', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ulPdcpSn [variable] @@ -3667,7 +4051,7 @@ def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cl def register_Ns3EpcX2SapHandoverPreparationFailureParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams(ns3::EpcX2Sap::HandoverPreparationFailureParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams(ns3::EpcX2Sap::HandoverPreparationFailureParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverPreparationFailureParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::cause [variable] cls.add_instance_attribute('cause', 'uint16_t', is_const=False) @@ -3684,7 +4068,7 @@ def register_Ns3EpcX2SapHandoverPreparationFailureParams_methods(root_module, cl def register_Ns3EpcX2SapHandoverRequestAckParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams(ns3::EpcX2Sap::HandoverRequestAckParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams(ns3::EpcX2Sap::HandoverRequestAckParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverRequestAckParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::admittedBearers [variable] cls.add_instance_attribute('admittedBearers', 'std::vector< ns3::EpcX2Sap::ErabAdmittedItem >', is_const=False) @@ -3705,7 +4089,7 @@ def register_Ns3EpcX2SapHandoverRequestAckParams_methods(root_module, cls): def register_Ns3EpcX2SapHandoverRequestParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams(ns3::EpcX2Sap::HandoverRequestParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams(ns3::EpcX2Sap::HandoverRequestParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverRequestParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::bearers [variable] cls.add_instance_attribute('bearers', 'std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', is_const=False) @@ -3730,7 +4114,7 @@ def register_Ns3EpcX2SapHandoverRequestParams_methods(root_module, cls): def register_Ns3EpcX2SapLoadInformationParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams(ns3::EpcX2Sap::LoadInformationParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams(ns3::EpcX2Sap::LoadInformationParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::LoadInformationParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::cellInformationList [variable] cls.add_instance_attribute('cellInformationList', 'std::vector< ns3::EpcX2Sap::CellInformationItem >', is_const=False) @@ -3741,7 +4125,7 @@ def register_Ns3EpcX2SapLoadInformationParams_methods(root_module, cls): def register_Ns3EpcX2SapRelativeNarrowbandTxBand_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand(ns3::EpcX2Sap::RelativeNarrowbandTxBand const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand(ns3::EpcX2Sap::RelativeNarrowbandTxBand const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::RelativeNarrowbandTxBand const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::antennaPorts [variable] cls.add_instance_attribute('antennaPorts', 'uint16_t', is_const=False) @@ -3758,7 +4142,7 @@ def register_Ns3EpcX2SapRelativeNarrowbandTxBand_methods(root_module, cls): def register_Ns3EpcX2SapResourceStatusUpdateParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams(ns3::EpcX2Sap::ResourceStatusUpdateParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams(ns3::EpcX2Sap::ResourceStatusUpdateParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ResourceStatusUpdateParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::cellMeasurementResultList [variable] cls.add_instance_attribute('cellMeasurementResultList', 'std::vector< ns3::EpcX2Sap::CellMeasurementResultItem >', is_const=False) @@ -3773,7 +4157,7 @@ def register_Ns3EpcX2SapResourceStatusUpdateParams_methods(root_module, cls): def register_Ns3EpcX2SapSnStatusTransferParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams(ns3::EpcX2Sap::SnStatusTransferParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams(ns3::EpcX2Sap::SnStatusTransferParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::SnStatusTransferParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::erabsSubjectToStatusTransferList [variable] cls.add_instance_attribute('erabsSubjectToStatusTransferList', 'std::vector< ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem >', is_const=False) @@ -3790,7 +4174,7 @@ def register_Ns3EpcX2SapSnStatusTransferParams_methods(root_module, cls): def register_Ns3EpcX2SapUeContextReleaseParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams(ns3::EpcX2Sap::UeContextReleaseParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams(ns3::EpcX2Sap::UeContextReleaseParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UeContextReleaseParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::newEnbUeX2apId [variable] cls.add_instance_attribute('newEnbUeX2apId', 'uint16_t', is_const=False) @@ -3805,7 +4189,7 @@ def register_Ns3EpcX2SapUeContextReleaseParams_methods(root_module, cls): def register_Ns3EpcX2SapUeDataParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams(ns3::EpcX2Sap::UeDataParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams(ns3::EpcX2Sap::UeDataParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UeDataParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::gtpTeid [variable] cls.add_instance_attribute('gtpTeid', 'uint32_t', is_const=False) @@ -3820,7 +4204,7 @@ def register_Ns3EpcX2SapUeDataParams_methods(root_module, cls): def register_Ns3EpcX2SapUlHighInterferenceInformationItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem(ns3::EpcX2Sap::UlHighInterferenceInformationItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem(ns3::EpcX2Sap::UlHighInterferenceInformationItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UlHighInterferenceInformationItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::targetCellId [variable] cls.add_instance_attribute('targetCellId', 'uint16_t', is_const=False) @@ -3831,7 +4215,7 @@ def register_Ns3EpcX2SapUlHighInterferenceInformationItem_methods(root_module, c def register_Ns3EpcX2SapProvider_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider(ns3::EpcX2SapProvider const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider(ns3::EpcX2SapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SapProvider const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): void ns3::EpcX2SapProvider::SendHandoverPreparationFailure(ns3::EpcX2Sap::HandoverPreparationFailureParams params) [member function] cls.add_method('SendHandoverPreparationFailure', @@ -3878,7 +4262,7 @@ def register_Ns3EpcX2SapProvider_methods(root_module, cls): def register_Ns3EpcX2SapUser_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser(ns3::EpcX2SapUser const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser(ns3::EpcX2SapUser const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SapUser const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): void ns3::EpcX2SapUser::RecvHandoverPreparationFailure(ns3::EpcX2Sap::HandoverPreparationFailureParams params) [member function] cls.add_method('RecvHandoverPreparationFailure', @@ -3923,7 +4307,7 @@ def register_Ns3EpcX2SapUser_methods(root_module, cls): return def register_Ns3EpsBearer_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer(ns3::EpsBearer const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer(ns3::EpsBearer const & arg0) [constructor] cls.add_constructor([param('ns3::EpsBearer const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer() [constructor] cls.add_constructor([]) @@ -3962,7 +4346,7 @@ def register_Ns3EpsBearer_methods(root_module, cls): def register_Ns3EutranMeasurementMapping_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping(ns3::EutranMeasurementMapping const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping(ns3::EutranMeasurementMapping const & arg0) [constructor] cls.add_constructor([param('ns3::EutranMeasurementMapping const &', 'arg0')]) ## lte-common.h (module 'lte'): static int8_t ns3::EutranMeasurementMapping::ActualA3Offset2IeValue(double a3OffsetDb) [member function] cls.add_method('ActualA3Offset2IeValue', @@ -4027,9 +4411,9 @@ def register_Ns3EutranMeasurementMapping_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -4074,7 +4458,7 @@ def register_Ns3EventId_methods(root_module, cls): def register_Ns3FfMacCschedSapProvider_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider(ns3::FfMacCschedSapProvider const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider(ns3::FfMacCschedSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): void ns3::FfMacCschedSapProvider::CschedCellConfigReq(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & params) [member function] cls.add_method('CschedCellConfigReq', @@ -4106,7 +4490,7 @@ def register_Ns3FfMacCschedSapProvider_methods(root_module, cls): def register_Ns3FfMacCschedSapProviderCschedCellConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::m_antennaPortsCount [variable] cls.add_instance_attribute('m_antennaPortsCount', 'uint8_t', is_const=False) @@ -4179,7 +4563,7 @@ def register_Ns3FfMacCschedSapProviderCschedCellConfigReqParameters_methods(root def register_Ns3FfMacCschedSapProviderCschedLcConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters(ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters(ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::m_logicalChannelConfigList [variable] cls.add_instance_attribute('m_logicalChannelConfigList', 'std::vector< ns3::LogicalChannelConfigListElement_s >', is_const=False) @@ -4194,7 +4578,7 @@ def register_Ns3FfMacCschedSapProviderCschedLcConfigReqParameters_methods(root_m def register_Ns3FfMacCschedSapProviderCschedLcReleaseReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4207,7 +4591,7 @@ def register_Ns3FfMacCschedSapProviderCschedLcReleaseReqParameters_methods(root_ def register_Ns3FfMacCschedSapProviderCschedUeConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters(ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters(ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::m_ackNackRepetitionFactor [variable] cls.add_instance_attribute('m_ackNackRepetitionFactor', 'uint8_t', is_const=False) @@ -4272,7 +4656,7 @@ def register_Ns3FfMacCschedSapProviderCschedUeConfigReqParameters_methods(root_m def register_Ns3FfMacCschedSapProviderCschedUeReleaseReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -4283,7 +4667,7 @@ def register_Ns3FfMacCschedSapProviderCschedUeReleaseReqParameters_methods(root_ def register_Ns3FfMacCschedSapUser_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser(ns3::FfMacCschedSapUser const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser(ns3::FfMacCschedSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): void ns3::FfMacCschedSapUser::CschedCellConfigCnf(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & params) [member function] cls.add_method('CschedCellConfigCnf', @@ -4325,7 +4709,7 @@ def register_Ns3FfMacCschedSapUser_methods(root_module, cls): def register_Ns3FfMacCschedSapUserCschedCellConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4336,7 +4720,7 @@ def register_Ns3FfMacCschedSapUserCschedCellConfigCnfParameters_methods(root_mod def register_Ns3FfMacCschedSapUserCschedCellConfigUpdateIndParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::m_prbUtilizationDl [variable] cls.add_instance_attribute('m_prbUtilizationDl', 'uint8_t', is_const=False) @@ -4349,7 +4733,7 @@ def register_Ns3FfMacCschedSapUserCschedCellConfigUpdateIndParameters_methods(ro def register_Ns3FfMacCschedSapUserCschedLcConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters(ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters(ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4364,7 +4748,7 @@ def register_Ns3FfMacCschedSapUserCschedLcConfigCnfParameters_methods(root_modul def register_Ns3FfMacCschedSapUserCschedLcReleaseCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4379,7 +4763,7 @@ def register_Ns3FfMacCschedSapUserCschedLcReleaseCnfParameters_methods(root_modu def register_Ns3FfMacCschedSapUserCschedUeConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters(ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters(ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4392,7 +4776,7 @@ def register_Ns3FfMacCschedSapUserCschedUeConfigCnfParameters_methods(root_modul def register_Ns3FfMacCschedSapUserCschedUeConfigUpdateIndParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::m_cqiConfig [variable] cls.add_instance_attribute('m_cqiConfig', 'ns3::CqiConfig_s', is_const=False) @@ -4417,7 +4801,7 @@ def register_Ns3FfMacCschedSapUserCschedUeConfigUpdateIndParameters_methods(root def register_Ns3FfMacCschedSapUserCschedUeReleaseCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4430,7 +4814,7 @@ def register_Ns3FfMacCschedSapUserCschedUeReleaseCnfParameters_methods(root_modu def register_Ns3FfMacSchedSapProvider_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider(ns3::FfMacSchedSapProvider const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider(ns3::FfMacSchedSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): void ns3::FfMacSchedSapProvider::SchedDlCqiInfoReq(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & params) [member function] cls.add_method('SchedDlCqiInfoReq', @@ -4492,7 +4876,7 @@ def register_Ns3FfMacSchedSapProvider_methods(root_module, cls): def register_Ns3FfMacSchedSapProviderSchedDlCqiInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::m_cqiList [variable] cls.add_instance_attribute('m_cqiList', 'std::vector< ns3::CqiListElement_s >', is_const=False) @@ -4505,7 +4889,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlCqiInfoReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedDlMacBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::m_ceBitmap [variable] cls.add_instance_attribute('m_ceBitmap', 'ns3::CeBitmap_e', is_const=False) @@ -4518,7 +4902,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlMacBufferReqParameters_methods(root_ def register_Ns3FfMacSchedSapProviderSchedDlPagingBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::m_pagingInfoList [variable] cls.add_instance_attribute('m_pagingInfoList', 'std::vector< ns3::PagingInfoListElement_s >', is_const=False) @@ -4531,7 +4915,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlPagingBufferReqParameters_methods(ro def register_Ns3FfMacSchedSapProviderSchedDlRachInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::m_rachList [variable] cls.add_instance_attribute('m_rachList', 'std::vector< ns3::RachListElement_s >', is_const=False) @@ -4544,7 +4928,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlRachInfoReqParameters_methods(root_m def register_Ns3FfMacSchedSapProviderSchedDlRlcBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'uint8_t', is_const=False) @@ -4567,7 +4951,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlRlcBufferReqParameters_methods(root_ def register_Ns3FfMacSchedSapProviderSchedDlTriggerReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::m_dlInfoList [variable] cls.add_instance_attribute('m_dlInfoList', 'std::vector< ns3::DlInfoListElement_s >', is_const=False) @@ -4580,7 +4964,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlTriggerReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedUlCqiInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4593,7 +4977,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlCqiInfoReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedUlMacCtrlInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::m_macCeList [variable] cls.add_instance_attribute('m_macCeList', 'std::vector< ns3::MacCeListElement_s >', is_const=False) @@ -4606,7 +4990,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlMacCtrlInfoReqParameters_methods(roo def register_Ns3FfMacSchedSapProviderSchedUlNoiseInterferenceReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters(ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters(ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::m_rip [variable] cls.add_instance_attribute('m_rip', 'uint16_t', is_const=False) @@ -4621,7 +5005,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlNoiseInterferenceReqParameters_metho def register_Ns3FfMacSchedSapProviderSchedUlSrInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4634,7 +5018,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlSrInfoReqParameters_methods(root_mod def register_Ns3FfMacSchedSapProviderSchedUlTriggerReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4647,7 +5031,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlTriggerReqParameters_methods(root_mo def register_Ns3FfMacSchedSapUser_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser(ns3::FfMacSchedSapUser const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser(ns3::FfMacSchedSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): void ns3::FfMacSchedSapUser::SchedDlConfigInd(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & params) [member function] cls.add_method('SchedDlConfigInd', @@ -4664,7 +5048,7 @@ def register_Ns3FfMacSchedSapUser_methods(root_module, cls): def register_Ns3FfMacSchedSapUserSchedDlConfigIndParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::m_buildBroadcastList [variable] cls.add_instance_attribute('m_buildBroadcastList', 'std::vector< ns3::BuildBroadcastListElement_s >', is_const=False) @@ -4681,7 +5065,7 @@ def register_Ns3FfMacSchedSapUserSchedDlConfigIndParameters_methods(root_module, def register_Ns3FfMacSchedSapUserSchedUlConfigIndParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters(ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters(ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::m_dciList [variable] cls.add_instance_attribute('m_dciList', 'std::vector< ns3::UlDciListElement_s >', is_const=False) @@ -4692,7 +5076,7 @@ def register_Ns3FfMacSchedSapUserSchedUlConfigIndParameters_methods(root_module, return def register_Ns3GbrQosInformation_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation(ns3::GbrQosInformation const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation(ns3::GbrQosInformation const & arg0) [constructor] cls.add_constructor([param('ns3::GbrQosInformation const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation() [constructor] cls.add_constructor([]) @@ -4709,7 +5093,7 @@ def register_Ns3GbrQosInformation_methods(root_module, cls): def register_Ns3HarqProcessInfoElement_t_methods(root_module, cls): ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t() [constructor] cls.add_constructor([]) - ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t(ns3::HarqProcessInfoElement_t const & arg0) [copy constructor] + ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t(ns3::HarqProcessInfoElement_t const & arg0) [constructor] cls.add_constructor([param('ns3::HarqProcessInfoElement_t const &', 'arg0')]) ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::m_codeBits [variable] cls.add_instance_attribute('m_codeBits', 'uint16_t', is_const=False) @@ -4722,7 +5106,7 @@ def register_Ns3HarqProcessInfoElement_t_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -4753,7 +5137,7 @@ def register_Ns3Hasher_methods(root_module, cls): def register_Ns3HigherLayerSelected_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s(ns3::HigherLayerSelected_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s(ns3::HigherLayerSelected_s const & arg0) [constructor] cls.add_constructor([param('ns3::HigherLayerSelected_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::m_sbCqi [variable] cls.add_instance_attribute('m_sbCqi', 'std::vector< unsigned char >', is_const=False) @@ -4764,7 +5148,7 @@ def register_Ns3HigherLayerSelected_s_methods(root_module, cls): def register_Ns3ImsiLcidPair_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t(ns3::ImsiLcidPair_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t(ns3::ImsiLcidPair_t const & arg0) [constructor] cls.add_constructor([param('ns3::ImsiLcidPair_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t() [constructor] cls.add_constructor([]) @@ -4777,7 +5161,7 @@ def register_Ns3ImsiLcidPair_t_methods(root_module, cls): return def register_Ns3Inet6SocketAddress_methods(root_module, cls): - ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor] + ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')]) ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')]) @@ -4820,7 +5204,7 @@ def register_Ns3Inet6SocketAddress_methods(root_module, cls): return def register_Ns3InetSocketAddress_methods(root_module, cls): - ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor] + ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')]) ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')]) @@ -4872,11 +5256,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -4990,7 +5374,7 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4AddressHelper_methods(root_module, cls): - ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper(ns3::Ipv4AddressHelper const & arg0) [copy constructor] + ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper(ns3::Ipv4AddressHelper const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressHelper const &', 'arg0')]) ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor] cls.add_constructor([]) @@ -5015,14 +5399,14 @@ def register_Ns3Ipv4AddressHelper_methods(root_module, cls): return def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress() [constructor] cls.add_constructor([]) ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4Address local, ns3::Ipv4Mask mask) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'local'), param('ns3::Ipv4Mask', 'mask')]) - ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [copy constructor] + ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [constructor] cls.add_constructor([param('ns3::Ipv4InterfaceAddress const &', 'o')]) ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetBroadcast() const [member function] cls.add_method('GetBroadcast', @@ -5076,7 +5460,7 @@ def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls): return def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): - ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer(ns3::Ipv4InterfaceContainer const & arg0) [copy constructor] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer(ns3::Ipv4InterfaceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4InterfaceContainer const &', 'arg0')]) ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor] cls.add_constructor([]) @@ -5088,7 +5472,7 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')]) - ## ipv4-interface-container.h (module 'internet'): void ns3::Ipv4InterfaceContainer::Add(std::pair,unsigned int> ipInterfacePair) [member function] + ## ipv4-interface-container.h (module 'internet'): void ns3::Ipv4InterfaceContainer::Add(std::pair, unsigned int> ipInterfacePair) [member function] cls.add_method('Add', 'void', [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'ipInterfacePair')]) @@ -5096,17 +5480,17 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'ipv4Name'), param('uint32_t', 'interface')]) - ## ipv4-interface-container.h (module 'internet'): __gnu_cxx::__normal_iterator, unsigned int>*,std::vector, unsigned int>, std::allocator, unsigned int> > > > ns3::Ipv4InterfaceContainer::Begin() const [member function] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Iterator ns3::Ipv4InterfaceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > > >', + 'ns3::Ipv4InterfaceContainer::Iterator', [], is_const=True) - ## ipv4-interface-container.h (module 'internet'): __gnu_cxx::__normal_iterator, unsigned int>*,std::vector, unsigned int>, std::allocator, unsigned int> > > > ns3::Ipv4InterfaceContainer::End() const [member function] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Iterator ns3::Ipv4InterfaceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > > >', + 'ns3::Ipv4InterfaceContainer::Iterator', [], is_const=True) - ## ipv4-interface-container.h (module 'internet'): std::pair,unsigned int> ns3::Ipv4InterfaceContainer::Get(uint32_t i) const [member function] + ## ipv4-interface-container.h (module 'internet'): std::pair, unsigned int> ns3::Ipv4InterfaceContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', [param('uint32_t', 'i')], @@ -5128,10 +5512,10 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -5191,17 +5575,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -5268,7 +5652,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -5390,9 +5774,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -5401,7 +5785,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -5448,10 +5832,10 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -5465,9 +5849,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -5499,7 +5883,7 @@ def register_Ns3LogComponent_methods(root_module, cls): def register_Ns3LogicalChannelConfigListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s(ns3::LogicalChannelConfigListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s(ns3::LogicalChannelConfigListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::LogicalChannelConfigListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::m_direction [variable] cls.add_instance_attribute('m_direction', 'ns3::LogicalChannelConfigListElement_s::Direction_e', is_const=False) @@ -5524,7 +5908,7 @@ def register_Ns3LogicalChannelConfigListElement_s_methods(root_module, cls): def register_Ns3LteAnrSapProvider_methods(root_module, cls): ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider() [constructor] cls.add_constructor([]) - ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider(ns3::LteAnrSapProvider const & arg0) [copy constructor] + ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider(ns3::LteAnrSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnrSapProvider const &', 'arg0')]) ## lte-anr-sap.h (module 'lte'): void ns3::LteAnrSapProvider::AddNeighbourRelation(uint16_t cellId) [member function] cls.add_method('AddNeighbourRelation', @@ -5556,7 +5940,7 @@ def register_Ns3LteAnrSapProvider_methods(root_module, cls): def register_Ns3LteAnrSapUser_methods(root_module, cls): ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser() [constructor] cls.add_constructor([]) - ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser(ns3::LteAnrSapUser const & arg0) [copy constructor] + ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser(ns3::LteAnrSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnrSapUser const &', 'arg0')]) ## lte-anr-sap.h (module 'lte'): uint8_t ns3::LteAnrSapUser::AddUeMeasReportConfigForAnr(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForAnr', @@ -5568,7 +5952,7 @@ def register_Ns3LteAnrSapUser_methods(root_module, cls): def register_Ns3LteAsSapProvider_methods(root_module, cls): ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider() [constructor] cls.add_constructor([]) - ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider(ns3::LteAsSapProvider const & arg0) [copy constructor] + ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider(ns3::LteAsSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteAsSapProvider const &', 'arg0')]) ## lte-as-sap.h (module 'lte'): void ns3::LteAsSapProvider::Connect() [member function] cls.add_method('Connect', @@ -5605,7 +5989,7 @@ def register_Ns3LteAsSapProvider_methods(root_module, cls): def register_Ns3LteAsSapUser_methods(root_module, cls): ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser() [constructor] cls.add_constructor([]) - ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser(ns3::LteAsSapUser const & arg0) [copy constructor] + ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser(ns3::LteAsSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteAsSapUser const &', 'arg0')]) ## lte-as-sap.h (module 'lte'): void ns3::LteAsSapUser::NotifyConnectionFailed() [member function] cls.add_method('NotifyConnectionFailed', @@ -5632,7 +6016,7 @@ def register_Ns3LteAsSapUser_methods(root_module, cls): def register_Ns3LteCcmMacSapProvider_methods(root_module, cls): ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider() [constructor] cls.add_constructor([]) - ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider(ns3::LteCcmMacSapProvider const & arg0) [copy constructor] + ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider(ns3::LteCcmMacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmMacSapProvider const &', 'arg0')]) ## lte-ccm-mac-sap.h (module 'lte'): void ns3::LteCcmMacSapProvider::ReportMacCeToScheduler(ns3::MacCeListElement_s bsr) [member function] cls.add_method('ReportMacCeToScheduler', @@ -5644,7 +6028,7 @@ def register_Ns3LteCcmMacSapProvider_methods(root_module, cls): def register_Ns3LteCcmRrcSapProvider_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider(ns3::LteCcmRrcSapProvider const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider(ns3::LteCcmRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapProvider const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapProvider::AddLc(ns3::LteEnbCmacSapProvider::LcInfo lcInfo, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -5686,7 +6070,7 @@ def register_Ns3LteCcmRrcSapProvider_methods(root_module, cls): def register_Ns3LteCcmRrcSapProviderLcsConfig_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteCcmRrcSapProvider::LcsConfig const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteCcmRrcSapProvider::LcsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapProvider::LcsConfig const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint16_t', is_const=False) @@ -5699,7 +6083,7 @@ def register_Ns3LteCcmRrcSapProviderLcsConfig_methods(root_module, cls): def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser(ns3::LteCcmRrcSapUser const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser(ns3::LteCcmRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapUser const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapUser::AddLcs(std::vector > lcConfig) [member function] cls.add_method('AddLcs', @@ -5711,6 +6095,11 @@ def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): 'uint8_t', [param('ns3::LteRrcSap::ReportConfigEutra', 'reportConfig')], is_pure_virtual=True, is_virtual=True) + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::Ptr ns3::LteCcmRrcSapUser::GetUeManager(uint16_t rnti) [member function] + cls.add_method('GetUeManager', + 'ns3::Ptr< ns3::UeManager >', + [param('uint16_t', 'rnti')], + is_pure_virtual=True, is_virtual=True) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapUser::ReleaseLcs(uint16_t rnti, uint8_t lcid) [member function] cls.add_method('ReleaseLcs', 'void', @@ -5726,7 +6115,7 @@ def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): def register_Ns3LteEnbCmacSapProvider_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider(ns3::LteEnbCmacSapProvider const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider(ns3::LteEnbCmacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): void ns3::LteEnbCmacSapProvider::AddLc(ns3::LteEnbCmacSapProvider::LcInfo lcinfo, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -5778,7 +6167,7 @@ def register_Ns3LteEnbCmacSapProvider_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderAllocateNcRaPreambleReturnValue_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue(ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue(ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::raPrachMaskIndex [variable] cls.add_instance_attribute('raPrachMaskIndex', 'uint8_t', is_const=False) @@ -5791,7 +6180,7 @@ def register_Ns3LteEnbCmacSapProviderAllocateNcRaPreambleReturnValue_methods(roo def register_Ns3LteEnbCmacSapProviderLcInfo_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo(ns3::LteEnbCmacSapProvider::LcInfo const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo(ns3::LteEnbCmacSapProvider::LcInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::LcInfo const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::gbrDl [variable] cls.add_instance_attribute('gbrDl', 'uint64_t', is_const=False) @@ -5816,7 +6205,7 @@ def register_Ns3LteEnbCmacSapProviderLcInfo_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderRachConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig(ns3::LteEnbCmacSapProvider::RachConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig(ns3::LteEnbCmacSapProvider::RachConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::RachConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -5829,7 +6218,7 @@ def register_Ns3LteEnbCmacSapProviderRachConfig_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderUeConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig(ns3::LteEnbCmacSapProvider::UeConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig(ns3::LteEnbCmacSapProvider::UeConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::UeConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -5840,7 +6229,7 @@ def register_Ns3LteEnbCmacSapProviderUeConfig_methods(root_module, cls): def register_Ns3LteEnbCmacSapUser_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser(ns3::LteEnbCmacSapUser const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser(ns3::LteEnbCmacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapUser const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): uint16_t ns3::LteEnbCmacSapUser::AllocateTemporaryCellRnti() [member function] cls.add_method('AllocateTemporaryCellRnti', @@ -5862,7 +6251,7 @@ def register_Ns3LteEnbCmacSapUser_methods(root_module, cls): def register_Ns3LteEnbCmacSapUserUeConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig(ns3::LteEnbCmacSapUser::UeConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig(ns3::LteEnbCmacSapUser::UeConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapUser::UeConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -5873,7 +6262,7 @@ def register_Ns3LteEnbCmacSapUserUeConfig_methods(root_module, cls): def register_Ns3LteEnbCphySapProvider_methods(root_module, cls): ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider(ns3::LteEnbCphySapProvider const & arg0) [copy constructor] + ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider(ns3::LteEnbCphySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCphySapProvider const &', 'arg0')]) ## lte-enb-cphy-sap.h (module 'lte'): void ns3::LteEnbCphySapProvider::AddUe(uint16_t rnti) [member function] cls.add_method('AddUe', @@ -5935,14 +6324,14 @@ def register_Ns3LteEnbCphySapProvider_methods(root_module, cls): def register_Ns3LteEnbCphySapUser_methods(root_module, cls): ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser() [constructor] cls.add_constructor([]) - ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser(ns3::LteEnbCphySapUser const & arg0) [copy constructor] + ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser(ns3::LteEnbCphySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCphySapUser const &', 'arg0')]) return def register_Ns3LteEnbPhySapProvider_methods(root_module, cls): ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider(ns3::LteEnbPhySapProvider const & arg0) [copy constructor] + ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider(ns3::LteEnbPhySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhySapProvider const &', 'arg0')]) ## lte-enb-phy-sap.h (module 'lte'): uint8_t ns3::LteEnbPhySapProvider::GetMacChTtiDelay() [member function] cls.add_method('GetMacChTtiDelay', @@ -5964,7 +6353,7 @@ def register_Ns3LteEnbPhySapProvider_methods(root_module, cls): def register_Ns3LteEnbPhySapUser_methods(root_module, cls): ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser() [constructor] cls.add_constructor([]) - ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser(ns3::LteEnbPhySapUser const & arg0) [copy constructor] + ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser(ns3::LteEnbPhySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhySapUser const &', 'arg0')]) ## lte-enb-phy-sap.h (module 'lte'): void ns3::LteEnbPhySapUser::DlInfoListElementHarqFeeback(ns3::DlInfoListElement_s params) [member function] cls.add_method('DlInfoListElementHarqFeeback', @@ -6006,7 +6395,7 @@ def register_Ns3LteEnbPhySapUser_methods(root_module, cls): def register_Ns3LteFfConverter_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter(ns3::LteFfConverter const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter(ns3::LteFfConverter const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfConverter const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint16_t ns3::LteFfConverter::double2fpS11dot3(double val) [member function] cls.add_method('double2fpS11dot3', @@ -6028,7 +6417,7 @@ def register_Ns3LteFfConverter_methods(root_module, cls): def register_Ns3LteFfrRrcSapProvider_methods(root_module, cls): ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider(ns3::LteFfrRrcSapProvider const & arg0) [copy constructor] + ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider(ns3::LteFfrRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrRrcSapProvider const &', 'arg0')]) ## lte-ffr-rrc-sap.h (module 'lte'): void ns3::LteFfrRrcSapProvider::RecvLoadInformation(ns3::EpcX2Sap::LoadInformationParams params) [member function] cls.add_method('RecvLoadInformation', @@ -6055,7 +6444,7 @@ def register_Ns3LteFfrRrcSapProvider_methods(root_module, cls): def register_Ns3LteFfrRrcSapUser_methods(root_module, cls): ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser(ns3::LteFfrRrcSapUser const & arg0) [copy constructor] + ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser(ns3::LteFfrRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrRrcSapUser const &', 'arg0')]) ## lte-ffr-rrc-sap.h (module 'lte'): uint8_t ns3::LteFfrRrcSapUser::AddUeMeasReportConfigForFfr(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForFfr', @@ -6077,7 +6466,7 @@ def register_Ns3LteFfrRrcSapUser_methods(root_module, cls): def register_Ns3LteFfrSapProvider_methods(root_module, cls): ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider() [constructor] cls.add_constructor([]) - ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider(ns3::LteFfrSapProvider const & arg0) [copy constructor] + ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider(ns3::LteFfrSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSapProvider const &', 'arg0')]) ## lte-ffr-sap.h (module 'lte'): std::vector > ns3::LteFfrSapProvider::GetAvailableDlRbg() [member function] cls.add_method('GetAvailableDlRbg', @@ -6119,7 +6508,7 @@ def register_Ns3LteFfrSapProvider_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], is_pure_virtual=True, is_virtual=True) - ## lte-ffr-sap.h (module 'lte'): void ns3::LteFfrSapProvider::ReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-sap.h (module 'lte'): void ns3::LteFfrSapProvider::ReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('ReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -6129,14 +6518,14 @@ def register_Ns3LteFfrSapProvider_methods(root_module, cls): def register_Ns3LteFfrSapUser_methods(root_module, cls): ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser() [constructor] cls.add_constructor([]) - ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser(ns3::LteFfrSapUser const & arg0) [copy constructor] + ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser(ns3::LteFfrSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSapUser const &', 'arg0')]) return def register_Ns3LteFlowId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t(ns3::LteFlowId_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t(ns3::LteFlowId_t const & arg0) [constructor] cls.add_constructor([param('ns3::LteFlowId_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t() [constructor] cls.add_constructor([]) @@ -6151,7 +6540,7 @@ def register_Ns3LteFlowId_t_methods(root_module, cls): def register_Ns3LteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase(ns3::LteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase(ns3::LteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::LteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): double ns3::LteGlobalPathlossDatabase::GetPathloss(uint16_t cellId, uint64_t imsi) [member function] cls.add_method('GetPathloss', @@ -6171,7 +6560,7 @@ def register_Ns3LteGlobalPathlossDatabase_methods(root_module, cls): def register_Ns3LteHandoverManagementSapProvider_methods(root_module, cls): ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider() [constructor] cls.add_constructor([]) - ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider(ns3::LteHandoverManagementSapProvider const & arg0) [copy constructor] + ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider(ns3::LteHandoverManagementSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverManagementSapProvider const &', 'arg0')]) ## lte-handover-management-sap.h (module 'lte'): void ns3::LteHandoverManagementSapProvider::ReportUeMeas(uint16_t rnti, ns3::LteRrcSap::MeasResults measResults) [member function] cls.add_method('ReportUeMeas', @@ -6183,7 +6572,7 @@ def register_Ns3LteHandoverManagementSapProvider_methods(root_module, cls): def register_Ns3LteHandoverManagementSapUser_methods(root_module, cls): ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser() [constructor] cls.add_constructor([]) - ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser(ns3::LteHandoverManagementSapUser const & arg0) [copy constructor] + ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser(ns3::LteHandoverManagementSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverManagementSapUser const &', 'arg0')]) ## lte-handover-management-sap.h (module 'lte'): uint8_t ns3::LteHandoverManagementSapUser::AddUeMeasReportConfigForHandover(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForHandover', @@ -6200,7 +6589,7 @@ def register_Ns3LteHandoverManagementSapUser_methods(root_module, cls): def register_Ns3LteMacSapProvider_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider(ns3::LteMacSapProvider const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider(ns3::LteMacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): void ns3::LteMacSapProvider::ReportBufferStatus(ns3::LteMacSapProvider::ReportBufferStatusParameters params) [member function] cls.add_method('ReportBufferStatus', @@ -6217,7 +6606,7 @@ def register_Ns3LteMacSapProvider_methods(root_module, cls): def register_Ns3LteMacSapProviderReportBufferStatusParameters_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters(ns3::LteMacSapProvider::ReportBufferStatusParameters const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters(ns3::LteMacSapProvider::ReportBufferStatusParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider::ReportBufferStatusParameters const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6238,7 +6627,7 @@ def register_Ns3LteMacSapProviderReportBufferStatusParameters_methods(root_modul def register_Ns3LteMacSapProviderTransmitPduParameters_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters(ns3::LteMacSapProvider::TransmitPduParameters const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters(ns3::LteMacSapProvider::TransmitPduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider::TransmitPduParameters const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) @@ -6257,7 +6646,7 @@ def register_Ns3LteMacSapProviderTransmitPduParameters_methods(root_module, cls) def register_Ns3LteMacSapUser_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser(ns3::LteMacSapUser const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser(ns3::LteMacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapUser const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): void ns3::LteMacSapUser::NotifyHarqDeliveryFailure() [member function] cls.add_method('NotifyHarqDeliveryFailure', @@ -6279,7 +6668,7 @@ def register_Ns3LteMacSapUser_methods(root_module, cls): def register_Ns3LteMiErrorModel_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel() [constructor] cls.add_constructor([]) - ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel(ns3::LteMiErrorModel const & arg0) [copy constructor] + ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel(ns3::LteMiErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::LteMiErrorModel const &', 'arg0')]) ## lte-mi-error-model.h (module 'lte'): static double ns3::LteMiErrorModel::GetPcfichPdcchError(ns3::SpectrumValue const & sinr) [member function] cls.add_method('GetPcfichPdcchError', @@ -6289,7 +6678,7 @@ def register_Ns3LteMiErrorModel_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): static ns3::TbStats_t ns3::LteMiErrorModel::GetTbDecodificationStats(ns3::SpectrumValue const & sinr, std::vector > const & map, uint16_t size, uint8_t mcs, ns3::HarqProcessInfoList_t miHistory) [member function] cls.add_method('GetTbDecodificationStats', 'ns3::TbStats_t', - [param('ns3::SpectrumValue const &', 'sinr'), param('std::vector< int > const &', 'map'), param('uint16_t', 'size'), param('uint8_t', 'mcs'), param('ns3::HarqProcessInfoList_t', 'miHistory')], + [param('ns3::SpectrumValue const &', 'sinr'), param('std::vector< int > const &', 'map'), param('uint16_t', 'size'), param('uint8_t', 'mcs'), param('std::vector< ns3::HarqProcessInfoElement_t >', 'miHistory')], is_static=True) ## lte-mi-error-model.h (module 'lte'): static double ns3::LteMiErrorModel::MappingMiBler(double mib, uint8_t ecrId, uint16_t cbSize) [member function] cls.add_method('MappingMiBler', @@ -6306,7 +6695,7 @@ def register_Ns3LteMiErrorModel_methods(root_module, cls): def register_Ns3LtePdcpSapProvider_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider(ns3::LtePdcpSapProvider const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider(ns3::LtePdcpSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapProvider const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): void ns3::LtePdcpSapProvider::TransmitPdcpSdu(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters params) [member function] cls.add_method('TransmitPdcpSdu', @@ -6318,7 +6707,7 @@ def register_Ns3LtePdcpSapProvider_methods(root_module, cls): def register_Ns3LtePdcpSapProviderTransmitPdcpSduParameters_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6331,7 +6720,7 @@ def register_Ns3LtePdcpSapProviderTransmitPdcpSduParameters_methods(root_module, def register_Ns3LtePdcpSapUser_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser(ns3::LtePdcpSapUser const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser(ns3::LtePdcpSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapUser const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): void ns3::LtePdcpSapUser::ReceivePdcpSdu(ns3::LtePdcpSapUser::ReceivePdcpSduParameters params) [member function] cls.add_method('ReceivePdcpSdu', @@ -6343,7 +6732,7 @@ def register_Ns3LtePdcpSapUser_methods(root_module, cls): def register_Ns3LtePdcpSapUserReceivePdcpSduParameters_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters(ns3::LtePdcpSapUser::ReceivePdcpSduParameters const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters(ns3::LtePdcpSapUser::ReceivePdcpSduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapUser::ReceivePdcpSduParameters const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6356,7 +6745,7 @@ def register_Ns3LtePdcpSapUserReceivePdcpSduParameters_methods(root_module, cls) def register_Ns3LteRlcSapProvider_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider(ns3::LteRlcSapProvider const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider(ns3::LteRlcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapProvider const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): void ns3::LteRlcSapProvider::TransmitPdcpPdu(ns3::LteRlcSapProvider::TransmitPdcpPduParameters params) [member function] cls.add_method('TransmitPdcpPdu', @@ -6368,7 +6757,7 @@ def register_Ns3LteRlcSapProvider_methods(root_module, cls): def register_Ns3LteRlcSapProviderTransmitPdcpPduParameters_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters(ns3::LteRlcSapProvider::TransmitPdcpPduParameters const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters(ns3::LteRlcSapProvider::TransmitPdcpPduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapProvider::TransmitPdcpPduParameters const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6381,7 +6770,7 @@ def register_Ns3LteRlcSapProviderTransmitPdcpPduParameters_methods(root_module, def register_Ns3LteRlcSapUser_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser(ns3::LteRlcSapUser const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser(ns3::LteRlcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapUser const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): void ns3::LteRlcSapUser::ReceivePdcpPdu(ns3::Ptr p) [member function] cls.add_method('ReceivePdcpPdu', @@ -6393,7 +6782,7 @@ def register_Ns3LteRlcSapUser_methods(root_module, cls): def register_Ns3LteRrcSap_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap(ns3::LteRrcSap const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap(ns3::LteRrcSap const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): static double ns3::LteRrcSap::ConvertPdschConfigDedicated2Double(ns3::LteRrcSap::PdschConfigDedicated pdschConfigDedicated) [member function] cls.add_method('ConvertPdschConfigDedicated2Double', @@ -6407,7 +6796,7 @@ def register_Ns3LteRrcSap_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon(ns3::LteRrcSap::AntennaInfoCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon(ns3::LteRrcSap::AntennaInfoCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::antennaPortsCount [variable] cls.add_instance_attribute('antennaPortsCount', 'uint16_t', is_const=False) @@ -6416,7 +6805,7 @@ def register_Ns3LteRrcSapAntennaInfoCommon_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated(ns3::LteRrcSap::AntennaInfoDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated(ns3::LteRrcSap::AntennaInfoDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::transmissionMode [variable] cls.add_instance_attribute('transmissionMode', 'uint8_t', is_const=False) @@ -6425,7 +6814,7 @@ def register_Ns3LteRrcSapAntennaInfoDedicated_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl(ns3::LteRrcSap::AntennaInfoUl const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl(ns3::LteRrcSap::AntennaInfoUl const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoUl const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::transmissionMode [variable] cls.add_instance_attribute('transmissionMode', 'uint8_t', is_const=False) @@ -6434,7 +6823,7 @@ def register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, cls): def register_Ns3LteRrcSapAsConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig(ns3::LteRrcSap::AsConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig(ns3::LteRrcSap::AsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AsConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::sourceDlCarrierFreq [variable] cls.add_instance_attribute('sourceDlCarrierFreq', 'uint32_t', is_const=False) @@ -6455,7 +6844,7 @@ def register_Ns3LteRrcSapAsConfig_methods(root_module, cls): def register_Ns3LteRrcSapBlackCellsToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod(ns3::LteRrcSap::BlackCellsToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod(ns3::LteRrcSap::BlackCellsToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::BlackCellsToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::cellIndex [variable] cls.add_instance_attribute('cellIndex', 'uint8_t', is_const=False) @@ -6466,7 +6855,7 @@ def register_Ns3LteRrcSapBlackCellsToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapCarrierBandwidthEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra(ns3::LteRrcSap::CarrierBandwidthEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra(ns3::LteRrcSap::CarrierBandwidthEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CarrierBandwidthEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::dlBandwidth [variable] cls.add_instance_attribute('dlBandwidth', 'uint8_t', is_const=False) @@ -6477,7 +6866,7 @@ def register_Ns3LteRrcSapCarrierBandwidthEutra_methods(root_module, cls): def register_Ns3LteRrcSapCarrierFreqEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra(ns3::LteRrcSap::CarrierFreqEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra(ns3::LteRrcSap::CarrierFreqEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CarrierFreqEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::dlCarrierFreq [variable] cls.add_instance_attribute('dlCarrierFreq', 'uint32_t', is_const=False) @@ -6488,7 +6877,7 @@ def register_Ns3LteRrcSapCarrierFreqEutra_methods(root_module, cls): def register_Ns3LteRrcSapCellAccessRelatedInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo(ns3::LteRrcSap::CellAccessRelatedInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo(ns3::LteRrcSap::CellAccessRelatedInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellAccessRelatedInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::cellIdentity [variable] cls.add_instance_attribute('cellIdentity', 'uint32_t', is_const=False) @@ -6503,7 +6892,7 @@ def register_Ns3LteRrcSapCellAccessRelatedInfo_methods(root_module, cls): def register_Ns3LteRrcSapCellIdentification_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification(ns3::LteRrcSap::CellIdentification const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification(ns3::LteRrcSap::CellIdentification const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellIdentification const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::dlCarrierFreq [variable] cls.add_instance_attribute('dlCarrierFreq', 'uint32_t', is_const=False) @@ -6514,7 +6903,7 @@ def register_Ns3LteRrcSapCellIdentification_methods(root_module, cls): def register_Ns3LteRrcSapCellSelectionInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo(ns3::LteRrcSap::CellSelectionInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo(ns3::LteRrcSap::CellSelectionInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellSelectionInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::qQualMin [variable] cls.add_instance_attribute('qQualMin', 'int8_t', is_const=False) @@ -6525,7 +6914,7 @@ def register_Ns3LteRrcSapCellSelectionInfo_methods(root_module, cls): def register_Ns3LteRrcSapCellsToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod(ns3::LteRrcSap::CellsToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod(ns3::LteRrcSap::CellsToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellsToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::cellIndex [variable] cls.add_instance_attribute('cellIndex', 'uint8_t', is_const=False) @@ -6538,7 +6927,7 @@ def register_Ns3LteRrcSapCellsToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapCgiInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo(ns3::LteRrcSap::CgiInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo(ns3::LteRrcSap::CgiInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CgiInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::cellIdentity [variable] cls.add_instance_attribute('cellIdentity', 'uint32_t', is_const=False) @@ -6553,7 +6942,7 @@ def register_Ns3LteRrcSapCgiInfo_methods(root_module, cls): def register_Ns3LteRrcSapDrbToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod(ns3::LteRrcSap::DrbToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod(ns3::LteRrcSap::DrbToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::DrbToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::drbIdentity [variable] cls.add_instance_attribute('drbIdentity', 'uint8_t', is_const=False) @@ -6570,7 +6959,7 @@ def register_Ns3LteRrcSapDrbToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapFreqInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo(ns3::LteRrcSap::FreqInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo(ns3::LteRrcSap::FreqInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::FreqInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::ulBandwidth [variable] cls.add_instance_attribute('ulBandwidth', 'uint8_t', is_const=False) @@ -6581,7 +6970,7 @@ def register_Ns3LteRrcSapFreqInfo_methods(root_module, cls): def register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo(ns3::LteRrcSap::HandoverPreparationInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo(ns3::LteRrcSap::HandoverPreparationInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::HandoverPreparationInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::asConfig [variable] cls.add_instance_attribute('asConfig', 'ns3::LteRrcSap::AsConfig', is_const=False) @@ -6590,7 +6979,7 @@ def register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, cls): def register_Ns3LteRrcSapLogicalChannelConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig(ns3::LteRrcSap::LogicalChannelConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig(ns3::LteRrcSap::LogicalChannelConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::LogicalChannelConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::bucketSizeDurationMs [variable] cls.add_instance_attribute('bucketSizeDurationMs', 'uint16_t', is_const=False) @@ -6605,7 +6994,7 @@ def register_Ns3LteRrcSapLogicalChannelConfig_methods(root_module, cls): def register_Ns3LteRrcSapMasterInformationBlock_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock(ns3::LteRrcSap::MasterInformationBlock const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock(ns3::LteRrcSap::MasterInformationBlock const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MasterInformationBlock const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::dlBandwidth [variable] cls.add_instance_attribute('dlBandwidth', 'uint8_t', is_const=False) @@ -6616,7 +7005,7 @@ def register_Ns3LteRrcSapMasterInformationBlock_methods(root_module, cls): def register_Ns3LteRrcSapMeasConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig(ns3::LteRrcSap::MeasConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig(ns3::LteRrcSap::MeasConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::haveMeasGapConfig [variable] cls.add_instance_attribute('haveMeasGapConfig', 'bool', is_const=False) @@ -6651,16 +7040,20 @@ def register_Ns3LteRrcSapMeasConfig_methods(root_module, cls): def register_Ns3LteRrcSapMeasGapConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig(ns3::LteRrcSap::MeasGapConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig(ns3::LteRrcSap::MeasGapConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasGapConfig const &', 'arg0')]) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gapOffsetChoice [variable] + cls.add_instance_attribute('gapOffsetChoice', 'ns3::LteRrcSap::MeasGapConfig::gap', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gapOffsetValue [variable] cls.add_instance_attribute('gapOffsetValue', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::MeasGapConfig::action', is_const=False) return def register_Ns3LteRrcSapMeasIdToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod(ns3::LteRrcSap::MeasIdToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod(ns3::LteRrcSap::MeasIdToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasIdToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::measId [variable] cls.add_instance_attribute('measId', 'uint8_t', is_const=False) @@ -6673,7 +7066,7 @@ def register_Ns3LteRrcSapMeasIdToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapMeasObjectEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra(ns3::LteRrcSap::MeasObjectEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra(ns3::LteRrcSap::MeasObjectEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasObjectEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::allowedMeasBandwidth [variable] cls.add_instance_attribute('allowedMeasBandwidth', 'uint8_t', is_const=False) @@ -6702,7 +7095,7 @@ def register_Ns3LteRrcSapMeasObjectEutra_methods(root_module, cls): def register_Ns3LteRrcSapMeasObjectToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod(ns3::LteRrcSap::MeasObjectToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod(ns3::LteRrcSap::MeasObjectToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasObjectToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::measObjectEutra [variable] cls.add_instance_attribute('measObjectEutra', 'ns3::LteRrcSap::MeasObjectEutra', is_const=False) @@ -6713,7 +7106,7 @@ def register_Ns3LteRrcSapMeasObjectToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultBestNeighCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell(ns3::LteRrcSap::MeasResultBestNeighCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell(ns3::LteRrcSap::MeasResultBestNeighCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultBestNeighCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::haveRsrpResult [variable] cls.add_instance_attribute('haveRsrpResult', 'bool', is_const=False) @@ -6732,7 +7125,7 @@ def register_Ns3LteRrcSapMeasResultBestNeighCell_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra(ns3::LteRrcSap::MeasResultEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra(ns3::LteRrcSap::MeasResultEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::cgiInfo [variable] cls.add_instance_attribute('cgiInfo', 'ns3::LteRrcSap::CgiInfo', is_const=False) @@ -6753,7 +7146,7 @@ def register_Ns3LteRrcSapMeasResultEutra_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultScell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell(ns3::LteRrcSap::MeasResultScell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell(ns3::LteRrcSap::MeasResultScell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultScell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::haveRsrpResult [variable] cls.add_instance_attribute('haveRsrpResult', 'bool', is_const=False) @@ -6770,7 +7163,7 @@ def register_Ns3LteRrcSapMeasResultScell_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultServFreqList_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList(ns3::LteRrcSap::MeasResultServFreqList const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList(ns3::LteRrcSap::MeasResultServFreqList const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultServFreqList const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::haveMeasurementResultsNeighCell [variable] cls.add_instance_attribute('haveMeasurementResultsNeighCell', 'bool', is_const=False) @@ -6785,7 +7178,7 @@ def register_Ns3LteRrcSapMeasResultServFreqList_methods(root_module, cls): def register_Ns3LteRrcSapMeasResults_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults(ns3::LteRrcSap::MeasResults const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults(ns3::LteRrcSap::MeasResults const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResults const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::haveMeasResultNeighCells [variable] cls.add_instance_attribute('haveMeasResultNeighCells', 'bool', is_const=False) @@ -6806,7 +7199,7 @@ def register_Ns3LteRrcSapMeasResults_methods(root_module, cls): def register_Ns3LteRrcSapMeasurementReport_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport(ns3::LteRrcSap::MeasurementReport const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport(ns3::LteRrcSap::MeasurementReport const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasurementReport const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::measResults [variable] cls.add_instance_attribute('measResults', 'ns3::LteRrcSap::MeasResults', is_const=False) @@ -6815,7 +7208,7 @@ def register_Ns3LteRrcSapMeasurementReport_methods(root_module, cls): def register_Ns3LteRrcSapMobilityControlInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo(ns3::LteRrcSap::MobilityControlInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo(ns3::LteRrcSap::MobilityControlInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MobilityControlInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::carrierBandwidth [variable] cls.add_instance_attribute('carrierBandwidth', 'ns3::LteRrcSap::CarrierBandwidthEutra', is_const=False) @@ -6840,7 +7233,7 @@ def register_Ns3LteRrcSapMobilityControlInfo_methods(root_module, cls): def register_Ns3LteRrcSapMobilityStateParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters(ns3::LteRrcSap::MobilityStateParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters(ns3::LteRrcSap::MobilityStateParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MobilityStateParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::nCellChangeHigh [variable] cls.add_instance_attribute('nCellChangeHigh', 'uint8_t', is_const=False) @@ -6855,7 +7248,7 @@ def register_Ns3LteRrcSapMobilityStateParameters_methods(root_module, cls): def register_Ns3LteRrcSapNonCriticalExtensionConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration(ns3::LteRrcSap::NonCriticalExtensionConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration(ns3::LteRrcSap::NonCriticalExtensionConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::NonCriticalExtensionConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::sCellToReleaseList [variable] cls.add_instance_attribute('sCellToReleaseList', 'std::list< unsigned int >', is_const=False) @@ -6866,7 +7259,7 @@ def register_Ns3LteRrcSapNonCriticalExtensionConfiguration_methods(root_module, def register_Ns3LteRrcSapNonUlConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration(ns3::LteRrcSap::NonUlConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration(ns3::LteRrcSap::NonUlConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::NonUlConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::antennaInfoCommon [variable] cls.add_instance_attribute('antennaInfoCommon', 'ns3::LteRrcSap::AntennaInfoCommon', is_const=False) @@ -6879,7 +7272,7 @@ def register_Ns3LteRrcSapNonUlConfiguration_methods(root_module, cls): def register_Ns3LteRrcSapPdschConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon(ns3::LteRrcSap::PdschConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon(ns3::LteRrcSap::PdschConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PdschConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::pb [variable] cls.add_instance_attribute('pb', 'int8_t', is_const=False) @@ -6890,7 +7283,7 @@ def register_Ns3LteRrcSapPdschConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapPdschConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated(ns3::LteRrcSap::PdschConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated(ns3::LteRrcSap::PdschConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PdschConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::pa [variable] cls.add_instance_attribute('pa', 'uint8_t', is_const=False) @@ -6899,7 +7292,7 @@ def register_Ns3LteRrcSapPdschConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapPhysCellIdRange_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange(ns3::LteRrcSap::PhysCellIdRange const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange(ns3::LteRrcSap::PhysCellIdRange const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysCellIdRange const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::haveRange [variable] cls.add_instance_attribute('haveRange', 'bool', is_const=False) @@ -6912,7 +7305,7 @@ def register_Ns3LteRrcSapPhysCellIdRange_methods(root_module, cls): def register_Ns3LteRrcSapPhysicalConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated(ns3::LteRrcSap::PhysicalConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated(ns3::LteRrcSap::PhysicalConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysicalConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::antennaInfo [variable] cls.add_instance_attribute('antennaInfo', 'ns3::LteRrcSap::AntennaInfoDedicated', is_const=False) @@ -6931,7 +7324,7 @@ def register_Ns3LteRrcSapPhysicalConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapPhysicalConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell(ns3::LteRrcSap::PhysicalConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell(ns3::LteRrcSap::PhysicalConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysicalConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::antennaInfo [variable] cls.add_instance_attribute('antennaInfo', 'ns3::LteRrcSap::AntennaInfoDedicated', is_const=False) @@ -6964,7 +7357,7 @@ def register_Ns3LteRrcSapPhysicalConfigDedicatedSCell_methods(root_module, cls): def register_Ns3LteRrcSapPlmnIdentityInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo(ns3::LteRrcSap::PlmnIdentityInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo(ns3::LteRrcSap::PlmnIdentityInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PlmnIdentityInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::plmnIdentity [variable] cls.add_instance_attribute('plmnIdentity', 'uint32_t', is_const=False) @@ -6973,7 +7366,7 @@ def register_Ns3LteRrcSapPlmnIdentityInfo_methods(root_module, cls): def register_Ns3LteRrcSapPrachConfigSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell(ns3::LteRrcSap::PrachConfigSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell(ns3::LteRrcSap::PrachConfigSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PrachConfigSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::index [variable] cls.add_instance_attribute('index', 'uint16_t', is_const=False) @@ -6982,7 +7375,7 @@ def register_Ns3LteRrcSapPrachConfigSCell_methods(root_module, cls): def register_Ns3LteRrcSapPreambleInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo(ns3::LteRrcSap::PreambleInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo(ns3::LteRrcSap::PreambleInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PreambleInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -6991,7 +7384,7 @@ def register_Ns3LteRrcSapPreambleInfo_methods(root_module, cls): def register_Ns3LteRrcSapPuschConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell(ns3::LteRrcSap::PuschConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell(ns3::LteRrcSap::PuschConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PuschConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::nPuschIdentity [variable] cls.add_instance_attribute('nPuschIdentity', 'uint16_t', is_const=False) @@ -7000,7 +7393,7 @@ def register_Ns3LteRrcSapPuschConfigDedicatedSCell_methods(root_module, cls): def register_Ns3LteRrcSapQuantityConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig(ns3::LteRrcSap::QuantityConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig(ns3::LteRrcSap::QuantityConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::QuantityConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::filterCoefficientRSRP [variable] cls.add_instance_attribute('filterCoefficientRSRP', 'uint8_t', is_const=False) @@ -7011,7 +7404,7 @@ def register_Ns3LteRrcSapQuantityConfig_methods(root_module, cls): def register_Ns3LteRrcSapRaSupervisionInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo(ns3::LteRrcSap::RaSupervisionInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo(ns3::LteRrcSap::RaSupervisionInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RaSupervisionInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::preambleTransMax [variable] cls.add_instance_attribute('preambleTransMax', 'uint8_t', is_const=False) @@ -7022,7 +7415,7 @@ def register_Ns3LteRrcSapRaSupervisionInfo_methods(root_module, cls): def register_Ns3LteRrcSapRachConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon(ns3::LteRrcSap::RachConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon(ns3::LteRrcSap::RachConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RachConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::preambleInfo [variable] cls.add_instance_attribute('preambleInfo', 'ns3::LteRrcSap::PreambleInfo', is_const=False) @@ -7033,7 +7426,7 @@ def register_Ns3LteRrcSapRachConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapRachConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated(ns3::LteRrcSap::RachConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated(ns3::LteRrcSap::RachConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RachConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::raPrachMaskIndex [variable] cls.add_instance_attribute('raPrachMaskIndex', 'uint8_t', is_const=False) @@ -7044,7 +7437,7 @@ def register_Ns3LteRrcSapRachConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon(ns3::LteRrcSap::RadioResourceConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon(ns3::LteRrcSap::RadioResourceConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::rachConfigCommon [variable] cls.add_instance_attribute('rachConfigCommon', 'ns3::LteRrcSap::RachConfigCommon', is_const=False) @@ -7053,7 +7446,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigCommonSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell(ns3::LteRrcSap::RadioResourceConfigCommonSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell(ns3::LteRrcSap::RadioResourceConfigCommonSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommonSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::haveNonUlConfiguration [variable] cls.add_instance_attribute('haveNonUlConfiguration', 'bool', is_const=False) @@ -7068,7 +7461,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommonSCell_methods(root_module, cls def register_Ns3LteRrcSapRadioResourceConfigCommonSib_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib(ns3::LteRrcSap::RadioResourceConfigCommonSib const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib(ns3::LteRrcSap::RadioResourceConfigCommonSib const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommonSib const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::pdschConfigCommon [variable] cls.add_instance_attribute('pdschConfigCommon', 'ns3::LteRrcSap::PdschConfigCommon', is_const=False) @@ -7079,7 +7472,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommonSib_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated(ns3::LteRrcSap::RadioResourceConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated(ns3::LteRrcSap::RadioResourceConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::drbToAddModList [variable] cls.add_instance_attribute('drbToAddModList', 'std::list< ns3::LteRrcSap::DrbToAddMod >', is_const=False) @@ -7096,7 +7489,7 @@ def register_Ns3LteRrcSapRadioResourceConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell(ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell(ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::physicalConfigDedicatedSCell [variable] cls.add_instance_attribute('physicalConfigDedicatedSCell', 'ns3::LteRrcSap::PhysicalConfigDedicatedSCell', is_const=False) @@ -7105,7 +7498,7 @@ def register_Ns3LteRrcSapRadioResourceConfigDedicatedSCell_methods(root_module, def register_Ns3LteRrcSapReestabUeIdentity_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity(ns3::LteRrcSap::ReestabUeIdentity const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity(ns3::LteRrcSap::ReestabUeIdentity const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReestabUeIdentity const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::cRnti [variable] cls.add_instance_attribute('cRnti', 'uint16_t', is_const=False) @@ -7114,7 +7507,7 @@ def register_Ns3LteRrcSapReestabUeIdentity_methods(root_module, cls): return def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra(ns3::LteRrcSap::ReportConfigEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra(ns3::LteRrcSap::ReportConfigEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReportConfigEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra() [constructor] cls.add_constructor([]) @@ -7124,6 +7517,8 @@ def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): cls.add_instance_attribute('hysteresis', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::maxReportCells [variable] cls.add_instance_attribute('maxReportCells', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::purpose [variable] + cls.add_instance_attribute('purpose', 'ns3::LteRrcSap::ReportConfigEutra::report', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::reportAmount [variable] cls.add_instance_attribute('reportAmount', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::reportOnLeave [variable] @@ -7139,7 +7534,7 @@ def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): def register_Ns3LteRrcSapReportConfigToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod(ns3::LteRrcSap::ReportConfigToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod(ns3::LteRrcSap::ReportConfigToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReportConfigToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::reportConfigEutra [variable] cls.add_instance_attribute('reportConfigEutra', 'ns3::LteRrcSap::ReportConfigEutra', is_const=False) @@ -7150,14 +7545,16 @@ def register_Ns3LteRrcSapReportConfigToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapRlcConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig(ns3::LteRrcSap::RlcConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig(ns3::LteRrcSap::RlcConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RlcConfig const &', 'arg0')]) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::choice [variable] + cls.add_instance_attribute('choice', 'ns3::LteRrcSap::RlcConfig::direction', is_const=False) return def register_Ns3LteRrcSapRrcConnectionReconfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration(ns3::LteRrcSap::RrcConnectionReconfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration(ns3::LteRrcSap::RrcConnectionReconfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReconfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::haveMeasConfig [variable] cls.add_instance_attribute('haveMeasConfig', 'bool', is_const=False) @@ -7182,7 +7579,7 @@ def register_Ns3LteRrcSapRrcConnectionReconfiguration_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionReconfigurationCompleted_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted(ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted(ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7191,7 +7588,7 @@ def register_Ns3LteRrcSapRrcConnectionReconfigurationCompleted_methods(root_modu def register_Ns3LteRrcSapRrcConnectionReestablishment_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment(ns3::LteRrcSap::RrcConnectionReestablishment const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment(ns3::LteRrcSap::RrcConnectionReestablishment const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishment const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::radioResourceConfigDedicated [variable] cls.add_instance_attribute('radioResourceConfigDedicated', 'ns3::LteRrcSap::RadioResourceConfigDedicated', is_const=False) @@ -7202,7 +7599,7 @@ def register_Ns3LteRrcSapRrcConnectionReestablishment_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionReestablishmentComplete_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete(ns3::LteRrcSap::RrcConnectionReestablishmentComplete const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete(ns3::LteRrcSap::RrcConnectionReestablishmentComplete const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentComplete const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7211,14 +7608,14 @@ def register_Ns3LteRrcSapRrcConnectionReestablishmentComplete_methods(root_modul def register_Ns3LteRrcSapRrcConnectionReestablishmentReject_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject(ns3::LteRrcSap::RrcConnectionReestablishmentReject const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject(ns3::LteRrcSap::RrcConnectionReestablishmentReject const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentReject const &', 'arg0')]) return def register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest(ns3::LteRrcSap::RrcConnectionReestablishmentRequest const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest(ns3::LteRrcSap::RrcConnectionReestablishmentRequest const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentRequest const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::reestablishmentCause [variable] cls.add_instance_attribute('reestablishmentCause', 'ns3::LteRrcSap::ReestablishmentCause', is_const=False) @@ -7229,7 +7626,7 @@ def register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module def register_Ns3LteRrcSapRrcConnectionReject_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject(ns3::LteRrcSap::RrcConnectionReject const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject(ns3::LteRrcSap::RrcConnectionReject const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReject const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::waitTime [variable] cls.add_instance_attribute('waitTime', 'uint8_t', is_const=False) @@ -7238,7 +7635,7 @@ def register_Ns3LteRrcSapRrcConnectionReject_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionRelease_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease(ns3::LteRrcSap::RrcConnectionRelease const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease(ns3::LteRrcSap::RrcConnectionRelease const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionRelease const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7247,7 +7644,7 @@ def register_Ns3LteRrcSapRrcConnectionRelease_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionRequest_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest(ns3::LteRrcSap::RrcConnectionRequest const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest(ns3::LteRrcSap::RrcConnectionRequest const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionRequest const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::ueIdentity [variable] cls.add_instance_attribute('ueIdentity', 'uint64_t', is_const=False) @@ -7256,7 +7653,7 @@ def register_Ns3LteRrcSapRrcConnectionRequest_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionSetup_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup(ns3::LteRrcSap::RrcConnectionSetup const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup(ns3::LteRrcSap::RrcConnectionSetup const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionSetup const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::radioResourceConfigDedicated [variable] cls.add_instance_attribute('radioResourceConfigDedicated', 'ns3::LteRrcSap::RadioResourceConfigDedicated', is_const=False) @@ -7267,7 +7664,7 @@ def register_Ns3LteRrcSapRrcConnectionSetup_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionSetupCompleted_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted(ns3::LteRrcSap::RrcConnectionSetupCompleted const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted(ns3::LteRrcSap::RrcConnectionSetupCompleted const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionSetupCompleted const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7276,7 +7673,7 @@ def register_Ns3LteRrcSapRrcConnectionSetupCompleted_methods(root_module, cls): def register_Ns3LteRrcSapSCellToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod(ns3::LteRrcSap::SCellToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod(ns3::LteRrcSap::SCellToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SCellToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::cellIdentification [variable] cls.add_instance_attribute('cellIdentification', 'ns3::LteRrcSap::CellIdentification', is_const=False) @@ -7293,40 +7690,46 @@ def register_Ns3LteRrcSapSCellToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapSoundingRsUlConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon(ns3::LteRrcSap::SoundingRsUlConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon(ns3::LteRrcSap::SoundingRsUlConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SoundingRsUlConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::srsBandwidthConfig [variable] cls.add_instance_attribute('srsBandwidthConfig', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::srsSubframeConfig [variable] cls.add_instance_attribute('srsSubframeConfig', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SoundingRsUlConfigCommon::action', is_const=False) return def register_Ns3LteRrcSapSoundingRsUlConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated(ns3::LteRrcSap::SoundingRsUlConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated(ns3::LteRrcSap::SoundingRsUlConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SoundingRsUlConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::srsBandwidth [variable] cls.add_instance_attribute('srsBandwidth', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::srsConfigIndex [variable] cls.add_instance_attribute('srsConfigIndex', 'uint16_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SoundingRsUlConfigDedicated::action', is_const=False) return def register_Ns3LteRrcSapSpeedStatePars_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars(ns3::LteRrcSap::SpeedStatePars const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars(ns3::LteRrcSap::SpeedStatePars const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SpeedStatePars const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::mobilityStateParameters [variable] cls.add_instance_attribute('mobilityStateParameters', 'ns3::LteRrcSap::MobilityStateParameters', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::timeToTriggerSf [variable] cls.add_instance_attribute('timeToTriggerSf', 'ns3::LteRrcSap::SpeedStateScaleFactors', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SpeedStatePars::action', is_const=False) return def register_Ns3LteRrcSapSpeedStateScaleFactors_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors(ns3::LteRrcSap::SpeedStateScaleFactors const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors(ns3::LteRrcSap::SpeedStateScaleFactors const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SpeedStateScaleFactors const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::sfHigh [variable] cls.add_instance_attribute('sfHigh', 'uint8_t', is_const=False) @@ -7337,7 +7740,7 @@ def register_Ns3LteRrcSapSpeedStateScaleFactors_methods(root_module, cls): def register_Ns3LteRrcSapSrbToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod(ns3::LteRrcSap::SrbToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod(ns3::LteRrcSap::SrbToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SrbToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::logicalChannelConfig [variable] cls.add_instance_attribute('logicalChannelConfig', 'ns3::LteRrcSap::LogicalChannelConfig', is_const=False) @@ -7348,7 +7751,7 @@ def register_Ns3LteRrcSapSrbToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformation_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation(ns3::LteRrcSap::SystemInformation const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation(ns3::LteRrcSap::SystemInformation const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformation const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::haveSib2 [variable] cls.add_instance_attribute('haveSib2', 'bool', is_const=False) @@ -7359,7 +7762,7 @@ def register_Ns3LteRrcSapSystemInformation_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformationBlockType1_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1(ns3::LteRrcSap::SystemInformationBlockType1 const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1(ns3::LteRrcSap::SystemInformationBlockType1 const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformationBlockType1 const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::cellAccessRelatedInfo [variable] cls.add_instance_attribute('cellAccessRelatedInfo', 'ns3::LteRrcSap::CellAccessRelatedInfo', is_const=False) @@ -7370,7 +7773,7 @@ def register_Ns3LteRrcSapSystemInformationBlockType1_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformationBlockType2_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2(ns3::LteRrcSap::SystemInformationBlockType2 const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2(ns3::LteRrcSap::SystemInformationBlockType2 const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformationBlockType2 const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::freqInfo [variable] cls.add_instance_attribute('freqInfo', 'ns3::LteRrcSap::FreqInfo', is_const=False) @@ -7381,7 +7784,7 @@ def register_Ns3LteRrcSapSystemInformationBlockType2_methods(root_module, cls): def register_Ns3LteRrcSapThresholdEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra(ns3::LteRrcSap::ThresholdEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra(ns3::LteRrcSap::ThresholdEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ThresholdEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::range [variable] cls.add_instance_attribute('range', 'uint8_t', is_const=False) @@ -7390,7 +7793,7 @@ def register_Ns3LteRrcSapThresholdEutra_methods(root_module, cls): def register_Ns3LteRrcSapUlConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration(ns3::LteRrcSap::UlConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration(ns3::LteRrcSap::UlConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::prachConfigSCell [variable] cls.add_instance_attribute('prachConfigSCell', 'ns3::LteRrcSap::PrachConfigSCell', is_const=False) @@ -7405,7 +7808,7 @@ def register_Ns3LteRrcSapUlConfiguration_methods(root_module, cls): def register_Ns3LteRrcSapUlPowerControlCommonSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell(ns3::LteRrcSap::UlPowerControlCommonSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell(ns3::LteRrcSap::UlPowerControlCommonSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlPowerControlCommonSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::alpha [variable] cls.add_instance_attribute('alpha', 'uint16_t', is_const=False) @@ -7414,7 +7817,7 @@ def register_Ns3LteRrcSapUlPowerControlCommonSCell_methods(root_module, cls): def register_Ns3LteRrcSapUlPowerControlDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell(ns3::LteRrcSap::UlPowerControlDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell(ns3::LteRrcSap::UlPowerControlDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlPowerControlDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::pSrsOffset [variable] cls.add_instance_attribute('pSrsOffset', 'uint16_t', is_const=False) @@ -7423,7 +7826,7 @@ def register_Ns3LteRrcSapUlPowerControlDedicatedSCell_methods(root_module, cls): def register_Ns3LteSpectrumValueCatcher_methods(root_module, cls): ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher() [constructor] cls.add_constructor([]) - ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher(ns3::LteSpectrumValueCatcher const & arg0) [copy constructor] + ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher(ns3::LteSpectrumValueCatcher const & arg0) [constructor] cls.add_constructor([param('ns3::LteSpectrumValueCatcher const &', 'arg0')]) ## lte-chunk-processor.h (module 'lte'): ns3::Ptr ns3::LteSpectrumValueCatcher::GetValue() [member function] cls.add_method('GetValue', @@ -7438,7 +7841,7 @@ def register_Ns3LteSpectrumValueCatcher_methods(root_module, cls): def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper() [constructor] cls.add_constructor([]) - ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper(ns3::LteSpectrumValueHelper const & arg0) [copy constructor] + ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper(ns3::LteSpectrumValueHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteSpectrumValueHelper const &', 'arg0')]) ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double noiseFigure) [member function] cls.add_method('CreateNoisePowerSpectralDensity', @@ -7455,7 +7858,7 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth'), param('double', 'powerTx'), param('std::vector< int >', 'activeRbs')], is_static=True) - ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateTxPowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double powerTx, std::map, std::allocator > > powerTxMap, std::vector > activeRbs) [member function] + ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateTxPowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double powerTx, std::map, std::allocator > > powerTxMap, std::vector > activeRbs) [member function] cls.add_method('CreateTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth'), param('double', 'powerTx'), param('std::map< int, double >', 'powerTxMap'), param('std::vector< int >', 'activeRbs')], @@ -7470,6 +7873,11 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'double', [param('uint8_t', 'txBandwidthConf')], is_static=True) + ## lte-spectrum-value-helper.h (module 'lte'): static uint16_t ns3::LteSpectrumValueHelper::GetDownlinkCarrierBand(uint32_t nDl) [member function] + cls.add_method('GetDownlinkCarrierBand', + 'uint16_t', + [param('uint32_t', 'nDl')], + is_static=True) ## lte-spectrum-value-helper.h (module 'lte'): static double ns3::LteSpectrumValueHelper::GetDownlinkCarrierFrequency(uint32_t earfcn) [member function] cls.add_method('GetDownlinkCarrierFrequency', 'double', @@ -7480,6 +7888,11 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumModel >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth')], is_static=True) + ## lte-spectrum-value-helper.h (module 'lte'): static uint16_t ns3::LteSpectrumValueHelper::GetUplinkCarrierBand(uint32_t nDl) [member function] + cls.add_method('GetUplinkCarrierBand', + 'uint16_t', + [param('uint32_t', 'nDl')], + is_static=True) ## lte-spectrum-value-helper.h (module 'lte'): static double ns3::LteSpectrumValueHelper::GetUplinkCarrierFrequency(uint32_t earfcn) [member function] cls.add_method('GetUplinkCarrierFrequency', 'double', @@ -7490,7 +7903,7 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapProvider_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider(ns3::LteUeCcmRrcSapProvider const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider(ns3::LteUeCcmRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapProvider const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): std::vector > ns3::LteUeCcmRrcSapProvider::AddLc(uint8_t lcId, ns3::LteUeCmacSapProvider::LogicalChannelConfig lcConfig, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -7517,7 +7930,7 @@ def register_Ns3LteUeCcmRrcSapProvider_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapProviderLcsConfig_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteUeCcmRrcSapProvider::LcsConfig const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteUeCcmRrcSapProvider::LcsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapProvider::LcsConfig const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) @@ -7530,7 +7943,7 @@ def register_Ns3LteUeCcmRrcSapProviderLcsConfig_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapUser_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser(ns3::LteUeCcmRrcSapUser const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser(ns3::LteUeCcmRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapUser const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): void ns3::LteUeCcmRrcSapUser::ComponentCarrierEnabling(std::vector > componentCarrierList) [member function] cls.add_method('ComponentCarrierEnabling', @@ -7542,7 +7955,7 @@ def register_Ns3LteUeCcmRrcSapUser_methods(root_module, cls): def register_Ns3LteUeCmacSapProvider_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider(ns3::LteUeCmacSapProvider const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider(ns3::LteUeCmacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): void ns3::LteUeCmacSapProvider::AddLc(uint8_t lcId, ns3::LteUeCmacSapProvider::LogicalChannelConfig lcConfig, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -7584,7 +7997,7 @@ def register_Ns3LteUeCmacSapProvider_methods(root_module, cls): def register_Ns3LteUeCmacSapProviderLogicalChannelConfig_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig(ns3::LteUeCmacSapProvider::LogicalChannelConfig const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig(ns3::LteUeCmacSapProvider::LogicalChannelConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider::LogicalChannelConfig const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::bucketSizeDurationMs [variable] cls.add_instance_attribute('bucketSizeDurationMs', 'uint16_t', is_const=False) @@ -7599,7 +8012,7 @@ def register_Ns3LteUeCmacSapProviderLogicalChannelConfig_methods(root_module, cl def register_Ns3LteUeCmacSapProviderRachConfig_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig(ns3::LteUeCmacSapProvider::RachConfig const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig(ns3::LteUeCmacSapProvider::RachConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider::RachConfig const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -7612,7 +8025,7 @@ def register_Ns3LteUeCmacSapProviderRachConfig_methods(root_module, cls): def register_Ns3LteUeCmacSapUser_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser(ns3::LteUeCmacSapUser const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser(ns3::LteUeCmacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapUser const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): void ns3::LteUeCmacSapUser::NotifyRandomAccessFailed() [member function] cls.add_method('NotifyRandomAccessFailed', @@ -7634,7 +8047,7 @@ def register_Ns3LteUeCmacSapUser_methods(root_module, cls): def register_Ns3LteUeConfig_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t(ns3::LteUeConfig_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t(ns3::LteUeConfig_t const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeConfig_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t() [constructor] cls.add_constructor([]) @@ -7651,7 +8064,7 @@ def register_Ns3LteUeConfig_t_methods(root_module, cls): def register_Ns3LteUeCphySapProvider_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider(ns3::LteUeCphySapProvider const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider(ns3::LteUeCphySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapProvider const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): void ns3::LteUeCphySapProvider::ConfigureReferenceSignalPower(int8_t referenceSignalPower) [member function] cls.add_method('ConfigureReferenceSignalPower', @@ -7713,7 +8126,7 @@ def register_Ns3LteUeCphySapProvider_methods(root_module, cls): def register_Ns3LteUeCphySapUser_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser(ns3::LteUeCphySapUser const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser(ns3::LteUeCphySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): void ns3::LteUeCphySapUser::RecvMasterInformationBlock(uint16_t cellId, ns3::LteRrcSap::MasterInformationBlock mib) [member function] cls.add_method('RecvMasterInformationBlock', @@ -7735,7 +8148,7 @@ def register_Ns3LteUeCphySapUser_methods(root_module, cls): def register_Ns3LteUeCphySapUserUeMeasurementsElement_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement(ns3::LteUeCphySapUser::UeMeasurementsElement const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement(ns3::LteUeCphySapUser::UeMeasurementsElement const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser::UeMeasurementsElement const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::m_cellId [variable] cls.add_instance_attribute('m_cellId', 'uint16_t', is_const=False) @@ -7748,7 +8161,7 @@ def register_Ns3LteUeCphySapUserUeMeasurementsElement_methods(root_module, cls): def register_Ns3LteUeCphySapUserUeMeasurementsParameters_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters(ns3::LteUeCphySapUser::UeMeasurementsParameters const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters(ns3::LteUeCphySapUser::UeMeasurementsParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser::UeMeasurementsParameters const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::m_componentCarrierId [variable] cls.add_instance_attribute('m_componentCarrierId', 'uint8_t', is_const=False) @@ -7759,7 +8172,7 @@ def register_Ns3LteUeCphySapUserUeMeasurementsParameters_methods(root_module, cl def register_Ns3LteUePhySapProvider_methods(root_module, cls): ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider(ns3::LteUePhySapProvider const & arg0) [copy constructor] + ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider(ns3::LteUePhySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhySapProvider const &', 'arg0')]) ## lte-ue-phy-sap.h (module 'lte'): void ns3::LteUePhySapProvider::SendLteControlMessage(ns3::Ptr msg) [member function] cls.add_method('SendLteControlMessage', @@ -7781,7 +8194,7 @@ def register_Ns3LteUePhySapProvider_methods(root_module, cls): def register_Ns3LteUePhySapUser_methods(root_module, cls): ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser() [constructor] cls.add_constructor([]) - ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser(ns3::LteUePhySapUser const & arg0) [copy constructor] + ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser(ns3::LteUePhySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhySapUser const &', 'arg0')]) ## lte-ue-phy-sap.h (module 'lte'): void ns3::LteUePhySapUser::ReceiveLteControlMessage(ns3::Ptr msg) [member function] cls.add_method('ReceiveLteControlMessage', @@ -7803,7 +8216,7 @@ def register_Ns3LteUePhySapUser_methods(root_module, cls): def register_Ns3LteUeRrcSapProvider_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider(ns3::LteUeRrcSapProvider const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider(ns3::LteUeRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapProvider const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteUeRrcSapProvider::CompleteSetup(ns3::LteUeRrcSapProvider::CompleteSetupParameters params) [member function] cls.add_method('CompleteSetup', @@ -7850,7 +8263,7 @@ def register_Ns3LteUeRrcSapProvider_methods(root_module, cls): def register_Ns3LteUeRrcSapProviderCompleteSetupParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters(ns3::LteUeRrcSapProvider::CompleteSetupParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters(ns3::LteUeRrcSapProvider::CompleteSetupParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapProvider::CompleteSetupParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::srb0SapUser [variable] cls.add_instance_attribute('srb0SapUser', 'ns3::LteRlcSapUser *', is_const=False) @@ -7861,7 +8274,7 @@ def register_Ns3LteUeRrcSapProviderCompleteSetupParameters_methods(root_module, def register_Ns3LteUeRrcSapUser_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser(ns3::LteUeRrcSapUser const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser(ns3::LteUeRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapUser const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteUeRrcSapUser::SendMeasurementReport(ns3::LteRrcSap::MeasurementReport msg) [member function] cls.add_method('SendMeasurementReport', @@ -7903,7 +8316,7 @@ def register_Ns3LteUeRrcSapUser_methods(root_module, cls): def register_Ns3LteUeRrcSapUserSetupParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters(ns3::LteUeRrcSapUser::SetupParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters(ns3::LteUeRrcSapUser::SetupParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapUser::SetupParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::srb0SapProvider [variable] cls.add_instance_attribute('srb0SapProvider', 'ns3::LteRlcSapProvider *', is_const=False) @@ -7912,11 +8325,11 @@ def register_Ns3LteUeRrcSapUserSetupParameters_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -7986,7 +8399,7 @@ def register_Ns3Mac48Address_methods(root_module, cls): def register_Ns3MacCeListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s(ns3::MacCeListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s(ns3::MacCeListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::MacCeListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::m_macCeType [variable] cls.add_instance_attribute('m_macCeType', 'ns3::MacCeListElement_s::MacCeType_e', is_const=False) @@ -7999,7 +8412,7 @@ def register_Ns3MacCeListElement_s_methods(root_module, cls): def register_Ns3MacCeValue_u_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u(ns3::MacCeValue_u const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u(ns3::MacCeValue_u const & arg0) [constructor] cls.add_constructor([param('ns3::MacCeValue_u const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::m_bufferStatus [variable] cls.add_instance_attribute('m_bufferStatus', 'std::vector< unsigned char >', is_const=False) @@ -8012,7 +8425,7 @@ def register_Ns3MacCeValue_u_methods(root_module, cls): def register_Ns3Names_methods(root_module, cls): ## names.h (module 'core'): ns3::Names::Names() [constructor] cls.add_constructor([]) - ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [copy constructor] + ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [constructor] cls.add_constructor([param('ns3::Names const &', 'arg0')]) ## names.h (module 'core'): static void ns3::Names::Add(std::string name, ns3::Ptr object) [member function] cls.add_method('Add', @@ -8062,7 +8475,7 @@ def register_Ns3Names_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -8084,14 +8497,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -8107,7 +8520,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -8135,9 +8548,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -8148,9 +8561,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -8173,7 +8586,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -8234,7 +8647,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -8245,7 +8658,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -8282,7 +8695,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -8360,7 +8773,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -8374,10 +8787,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -8393,7 +8808,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -8407,7 +8822,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -8424,7 +8839,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -8458,7 +8873,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -8475,7 +8890,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): def register_Ns3PagingInfoListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s(ns3::PagingInfoListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s(ns3::PagingInfoListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::PagingInfoListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::m_pagingIndex [variable] cls.add_instance_attribute('m_pagingIndex', 'uint8_t', is_const=False) @@ -8486,7 +8901,7 @@ def register_Ns3PagingInfoListElement_s_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -8495,7 +8910,7 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3PhichListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s(ns3::PhichListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s(ns3::PhichListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::PhichListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::m_phich [variable] cls.add_instance_attribute('m_phich', 'ns3::PhichListElement_s::Phich_e', is_const=False) @@ -8506,7 +8921,7 @@ def register_Ns3PhichListElement_s_methods(root_module, cls): def register_Ns3PhyReceptionStatParameters_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters(ns3::PhyReceptionStatParameters const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters(ns3::PhyReceptionStatParameters const & arg0) [constructor] cls.add_constructor([param('ns3::PhyReceptionStatParameters const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::m_ccId [variable] cls.add_instance_attribute('m_ccId', 'uint8_t', is_const=False) @@ -8537,7 +8952,7 @@ def register_Ns3PhyReceptionStatParameters_methods(root_module, cls): def register_Ns3PhyTransmissionStatParameters_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters(ns3::PhyTransmissionStatParameters const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters(ns3::PhyTransmissionStatParameters const & arg0) [constructor] cls.add_constructor([param('ns3::PhyTransmissionStatParameters const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::m_ccId [variable] cls.add_instance_attribute('m_ccId', 'uint8_t', is_const=False) @@ -8566,7 +8981,7 @@ def register_Ns3PhyTransmissionStatParameters_methods(root_module, cls): def register_Ns3RachListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s(ns3::RachListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s(ns3::RachListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::RachListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::m_estimatedSize [variable] cls.add_instance_attribute('m_estimatedSize', 'uint16_t', is_const=False) @@ -8575,7 +8990,7 @@ def register_Ns3RachListElement_s_methods(root_module, cls): return def register_Ns3RadioBearerStatsConnector_methods(root_module, cls): - ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector(ns3::RadioBearerStatsConnector const & arg0) [copy constructor] + ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector(ns3::RadioBearerStatsConnector const & arg0) [constructor] cls.add_constructor([param('ns3::RadioBearerStatsConnector const &', 'arg0')]) ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector() [constructor] cls.add_constructor([]) @@ -8639,7 +9054,7 @@ def register_Ns3RadioBearerStatsConnector_methods(root_module, cls): return def register_Ns3RealProtocolRlcSapUser_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::RealProtocolRlcSapUser const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::RealProtocolRlcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::RealProtocolRlcSapUser const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::LteEnbRrcProtocolReal * pdcp, uint16_t rnti) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolReal *', 'pdcp'), param('uint16_t', 'rnti')]) @@ -8653,7 +9068,7 @@ def register_Ns3RealProtocolRlcSapUser_methods(root_module, cls): def register_Ns3RlcPduListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s(ns3::RlcPduListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s(ns3::RlcPduListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::RlcPduListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'uint8_t', is_const=False) @@ -8664,7 +9079,7 @@ def register_Ns3RlcPduListElement_s_methods(root_module, cls): def register_Ns3SbMeasResult_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s(ns3::SbMeasResult_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s(ns3::SbMeasResult_s const & arg0) [constructor] cls.add_constructor([param('ns3::SbMeasResult_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::m_bwPart [variable] cls.add_instance_attribute('m_bwPart', 'ns3::BwPart_s', is_const=False) @@ -8688,7 +9103,7 @@ def register_Ns3SequenceNumber10_methods(root_module, cls): cls.add_constructor([]) ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(uint16_t value) [constructor] cls.add_constructor([param('uint16_t', 'value')]) - ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(ns3::SequenceNumber10 const & value) [copy constructor] + ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(ns3::SequenceNumber10 const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber10 const &', 'value')]) ## lte-rlc-sequence-number.h (module 'lte'): uint16_t ns3::SequenceNumber10::GetValue() const [member function] cls.add_method('GetValue', @@ -8708,7 +9123,7 @@ def register_Ns3SequenceNumber10_methods(root_module, cls): def register_Ns3SiConfiguration_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s(ns3::SiConfiguration_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s(ns3::SiConfiguration_s const & arg0) [constructor] cls.add_constructor([param('ns3::SiConfiguration_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::m_sfn [variable] cls.add_instance_attribute('m_sfn', 'uint16_t', is_const=False) @@ -8723,7 +9138,7 @@ def register_Ns3SiConfiguration_s_methods(root_module, cls): def register_Ns3SiMessageListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s(ns3::SiMessageListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s(ns3::SiMessageListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::SiMessageListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::m_length [variable] cls.add_instance_attribute('m_length', 'uint16_t', is_const=False) @@ -8734,7 +9149,7 @@ def register_Ns3SiMessageListElement_s_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -8744,7 +9159,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -8826,7 +9241,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3SpsConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s(ns3::SpsConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s(ns3::SpsConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::SpsConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::m_implicitReleaseAfter [variable] cls.add_instance_attribute('m_implicitReleaseAfter', 'uint8_t', is_const=False) @@ -8845,7 +9260,7 @@ def register_Ns3SpsConfig_s_methods(root_module, cls): def register_Ns3SrConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s(ns3::SrConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s(ns3::SrConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::SrConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::m_action [variable] cls.add_instance_attribute('m_action', 'ns3::SetupRelease_e', is_const=False) @@ -8858,7 +9273,7 @@ def register_Ns3SrConfig_s_methods(root_module, cls): def register_Ns3SrListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s(ns3::SrListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s(ns3::SrListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::SrListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -8867,7 +9282,7 @@ def register_Ns3SrListElement_s_methods(root_module, cls): def register_Ns3StatisticalSummary_methods(root_module, cls): ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary() [constructor] cls.add_constructor([]) - ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [constructor] cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')]) ## data-calculator.h (module 'stats'): long int ns3::StatisticalSummary::getCount() const [member function] cls.add_method('getCount', @@ -8914,7 +9329,7 @@ def register_Ns3StatisticalSummary_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -8944,7 +9359,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -8988,14 +9403,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -9009,7 +9424,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): def register_Ns3TbId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t(ns3::TbId_t const & arg0) [copy constructor] + ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t(ns3::TbId_t const & arg0) [constructor] cls.add_constructor([param('ns3::TbId_t const &', 'arg0')]) ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t() [constructor] cls.add_constructor([]) @@ -9024,7 +9439,7 @@ def register_Ns3TbId_t_methods(root_module, cls): def register_Ns3TbStats_t_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t() [constructor] cls.add_constructor([]) - ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t(ns3::TbStats_t const & arg0) [copy constructor] + ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t(ns3::TbStats_t const & arg0) [constructor] cls.add_constructor([param('ns3::TbStats_t const &', 'arg0')]) ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::mi [variable] cls.add_instance_attribute('mi', 'double', is_const=False) @@ -9034,7 +9449,7 @@ def register_Ns3TbStats_t_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -9043,7 +9458,7 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TransmissionModesLayers_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers(ns3::TransmissionModesLayers const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers(ns3::TransmissionModesLayers const & arg0) [constructor] cls.add_constructor([param('ns3::TransmissionModesLayers const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint8_t ns3::TransmissionModesLayers::TxMode2LayerNum(uint8_t txMode) [member function] cls.add_method('TxMode2LayerNum', @@ -9053,33 +9468,32 @@ def register_Ns3TransmissionModesLayers_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -9095,7 +9509,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -9105,9 +9519,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -9174,12 +9588,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -9189,12 +9603,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -9204,7 +9618,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -9220,7 +9634,7 @@ def register_Ns3TypeId_methods(root_module, cls): cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::Object']) + template_parameters=[u'ns3::Object']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', @@ -9234,13 +9648,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -9259,7 +9672,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -9278,7 +9691,7 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3UeCapabilities_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s(ns3::UeCapabilities_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s(ns3::UeCapabilities_s const & arg0) [constructor] cls.add_constructor([param('ns3::UeCapabilities_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::m_halfDuplex [variable] cls.add_instance_attribute('m_halfDuplex', 'bool', is_const=False) @@ -9295,7 +9708,7 @@ def register_Ns3UeCapabilities_s_methods(root_module, cls): def register_Ns3UeSelected_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s(ns3::UeSelected_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s(ns3::UeSelected_s const & arg0) [constructor] cls.add_constructor([param('ns3::UeSelected_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::m_sbCqi [variable] cls.add_instance_attribute('m_sbCqi', 'std::vector< unsigned char >', is_const=False) @@ -9308,7 +9721,7 @@ def register_Ns3UeSelected_s_methods(root_module, cls): def register_Ns3UlCqi_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s(ns3::UlCqi_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s(ns3::UlCqi_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlCqi_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::m_sinr [variable] cls.add_instance_attribute('m_sinr', 'std::vector< unsigned short >', is_const=False) @@ -9319,7 +9732,7 @@ def register_Ns3UlCqi_s_methods(root_module, cls): def register_Ns3UlDciListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s(ns3::UlDciListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s(ns3::UlDciListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlDciListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::m_aggrLevel [variable] cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) @@ -9360,7 +9773,7 @@ def register_Ns3UlDciListElement_s_methods(root_module, cls): def register_Ns3UlGrant_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s(ns3::UlGrant_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s(ns3::UlGrant_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlGrant_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::m_cqiRequest [variable] cls.add_instance_attribute('m_cqiRequest', 'bool', is_const=False) @@ -9385,7 +9798,7 @@ def register_Ns3UlGrant_s_methods(root_module, cls): def register_Ns3UlInfoListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s(ns3::UlInfoListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s(ns3::UlInfoListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlInfoListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::m_receptionStatus [variable] cls.add_instance_attribute('m_receptionStatus', 'ns3::UlInfoListElement_s::ReceptionStatus_e', is_const=False) @@ -9400,7 +9813,7 @@ def register_Ns3UlInfoListElement_s_methods(root_module, cls): def register_Ns3UplinkLteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase(ns3::UplinkLteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase(ns3::UplinkLteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::UplinkLteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): void ns3::UplinkLteGlobalPathlossDatabase::UpdatePathloss(std::string context, ns3::Ptr txPhy, ns3::Ptr rxPhy, double lossDb) [member function] cls.add_method('UpdatePathloss', @@ -9410,14 +9823,21 @@ def register_Ns3UplinkLteGlobalPathlossDatabase_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -9425,14 +9845,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -9444,7 +9871,7 @@ def register_Ns3Vector3D_methods(root_module, cls): def register_Ns3VendorSpecificListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s(ns3::VendorSpecificListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s(ns3::VendorSpecificListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::VendorSpecificListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::m_length [variable] cls.add_instance_attribute('m_length', 'uint32_t', is_const=False) @@ -9457,14 +9884,14 @@ def register_Ns3VendorSpecificListElement_s_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3FdbetsFlowPerf_t_methods(root_module, cls): ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t() [constructor] cls.add_constructor([]) - ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t(ns3::fdbetsFlowPerf_t const & arg0) [copy constructor] + ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t(ns3::fdbetsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::fdbetsFlowPerf_t const &', 'arg0')]) ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9479,7 +9906,7 @@ def register_Ns3FdbetsFlowPerf_t_methods(root_module, cls): def register_Ns3FdtbfqsFlowPerf_t_methods(root_module, cls): ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t() [constructor] cls.add_constructor([]) - ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t(ns3::fdtbfqsFlowPerf_t const & arg0) [copy constructor] + ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t(ns3::fdtbfqsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::fdtbfqsFlowPerf_t const &', 'arg0')]) ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::burstCredit [variable] cls.add_instance_attribute('burstCredit', 'uint32_t', is_const=False) @@ -9502,76 +9929,76 @@ def register_Ns3FdtbfqsFlowPerf_t_methods(root_module, cls): return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3PfsFlowPerf_t_methods(root_module, cls): ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t() [constructor] cls.add_constructor([]) - ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t(ns3::pfsFlowPerf_t const & arg0) [copy constructor] + ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t(ns3::pfsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::pfsFlowPerf_t const &', 'arg0')]) ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9586,7 +10013,7 @@ def register_Ns3PfsFlowPerf_t_methods(root_module, cls): def register_Ns3PssFlowPerf_t_methods(root_module, cls): ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t() [constructor] cls.add_constructor([]) - ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t(ns3::pssFlowPerf_t const & arg0) [copy constructor] + ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t(ns3::pssFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::pssFlowPerf_t const &', 'arg0')]) ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9605,7 +10032,7 @@ def register_Ns3PssFlowPerf_t_methods(root_module, cls): def register_Ns3TbInfo_t_methods(root_module, cls): ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t() [constructor] cls.add_constructor([]) - ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t(ns3::tbInfo_t const & arg0) [copy constructor] + ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t(ns3::tbInfo_t const & arg0) [constructor] cls.add_constructor([param('ns3::tbInfo_t const &', 'arg0')]) ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::corrupt [variable] cls.add_instance_attribute('corrupt', 'bool', is_const=False) @@ -9632,7 +10059,7 @@ def register_Ns3TbInfo_t_methods(root_module, cls): def register_Ns3TdbetsFlowPerf_t_methods(root_module, cls): ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t() [constructor] cls.add_constructor([]) - ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t(ns3::tdbetsFlowPerf_t const & arg0) [copy constructor] + ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t(ns3::tdbetsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::tdbetsFlowPerf_t const &', 'arg0')]) ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9647,7 +10074,7 @@ def register_Ns3TdbetsFlowPerf_t_methods(root_module, cls): def register_Ns3TdtbfqsFlowPerf_t_methods(root_module, cls): ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t() [constructor] cls.add_constructor([]) - ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t(ns3::tdtbfqsFlowPerf_t const & arg0) [copy constructor] + ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t(ns3::tdtbfqsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::tdtbfqsFlowPerf_t const &', 'arg0')]) ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::burstCredit [variable] cls.add_instance_attribute('burstCredit', 'uint32_t', is_const=False) @@ -9672,7 +10099,7 @@ def register_Ns3TdtbfqsFlowPerf_t_methods(root_module, cls): def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -9694,7 +10121,7 @@ def register_Ns3Chunk_methods(root_module, cls): def register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase(ns3::DownlinkLteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase(ns3::DownlinkLteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::DownlinkLteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): void ns3::DownlinkLteGlobalPathlossDatabase::UpdatePathloss(std::string context, ns3::Ptr txPhy, ns3::Ptr rxPhy, double lossDb) [member function] cls.add_method('UpdatePathloss', @@ -9704,7 +10131,7 @@ def register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, cls): return def register_Ns3EpsBearerTag_methods(root_module, cls): - ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag(ns3::EpsBearerTag const & arg0) [copy constructor] + ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag(ns3::EpsBearerTag const & arg0) [constructor] cls.add_constructor([param('ns3::EpsBearerTag const &', 'arg0')]) ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag() [constructor] cls.add_constructor([]) @@ -9764,7 +10191,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -9794,7 +10221,7 @@ def register_Ns3Header_methods(root_module, cls): return def register_Ns3Ipv4Header_methods(root_module, cls): - ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor] + ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')]) ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header() [constructor] cls.add_constructor([]) @@ -9968,7 +10395,7 @@ def register_Ns3Ipv4Header_methods(root_module, cls): def register_Ns3LteCcmMacSapUser_methods(root_module, cls): ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser() [constructor] cls.add_constructor([]) - ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser(ns3::LteCcmMacSapUser const & arg0) [copy constructor] + ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser(ns3::LteCcmMacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmMacSapUser const &', 'arg0')]) ## lte-ccm-mac-sap.h (module 'lte'): void ns3::LteCcmMacSapUser::NotifyPrbOccupancy(double prbOccupancy, uint8_t componentCarrierId) [member function] cls.add_method('NotifyPrbOccupancy', @@ -9985,7 +10412,7 @@ def register_Ns3LteCcmMacSapUser_methods(root_module, cls): def register_Ns3LteEnbRrcSapProvider_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider(ns3::LteEnbRrcSapProvider const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider(ns3::LteEnbRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapProvider const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapProvider::CompleteSetupUe(uint16_t rnti, ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters params) [member function] cls.add_method('CompleteSetupUe', @@ -10027,7 +10454,7 @@ def register_Ns3LteEnbRrcSapProvider_methods(root_module, cls): def register_Ns3LteEnbRrcSapProviderCompleteSetupUeParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters(ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters(ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::srb0SapUser [variable] cls.add_instance_attribute('srb0SapUser', 'ns3::LteRlcSapUser *', is_const=False) @@ -10038,7 +10465,7 @@ def register_Ns3LteEnbRrcSapProviderCompleteSetupUeParameters_methods(root_modul def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser(ns3::LteEnbRrcSapUser const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser(ns3::LteEnbRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapUser const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration ns3::LteEnbRrcSapUser::DecodeHandoverCommand(ns3::Ptr p) [member function] cls.add_method('DecodeHandoverCommand', @@ -10095,10 +10522,10 @@ def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): 'void', [param('uint16_t', 'rnti'), param('ns3::LteRrcSap::RrcConnectionSetup', 'msg')], is_pure_virtual=True, is_virtual=True) - ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SendSystemInformation(ns3::LteRrcSap::SystemInformation msg) [member function] + ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SendSystemInformation(uint16_t cellId, ns3::LteRrcSap::SystemInformation msg) [member function] cls.add_method('SendSystemInformation', 'void', - [param('ns3::LteRrcSap::SystemInformation', 'msg')], + [param('uint16_t', 'cellId'), param('ns3::LteRrcSap::SystemInformation', 'msg')], is_pure_virtual=True, is_virtual=True) ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SetupUe(uint16_t rnti, ns3::LteEnbRrcSapUser::SetupUeParameters params) [member function] cls.add_method('SetupUe', @@ -10110,7 +10537,7 @@ def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): def register_Ns3LteEnbRrcSapUserSetupUeParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters(ns3::LteEnbRrcSapUser::SetupUeParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters(ns3::LteEnbRrcSapUser::SetupUeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapUser::SetupUeParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::srb0SapProvider [variable] cls.add_instance_attribute('srb0SapProvider', 'ns3::LteRlcSapProvider *', is_const=False) @@ -10119,7 +10546,7 @@ def register_Ns3LteEnbRrcSapUserSetupUeParameters_methods(root_module, cls): return def register_Ns3LtePdcpHeader_methods(root_module, cls): - ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader(ns3::LtePdcpHeader const & arg0) [copy constructor] + ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader(ns3::LtePdcpHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpHeader const &', 'arg0')]) ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader() [constructor] cls.add_constructor([]) @@ -10174,7 +10601,7 @@ def register_Ns3LtePdcpHeader_methods(root_module, cls): return def register_Ns3LtePhyTag_methods(root_module, cls): - ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag(ns3::LtePhyTag const & arg0) [copy constructor] + ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag(ns3::LtePhyTag const & arg0) [constructor] cls.add_constructor([param('ns3::LtePhyTag const &', 'arg0')]) ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag() [constructor] cls.add_constructor([]) @@ -10218,7 +10645,7 @@ def register_Ns3LtePhyTag_methods(root_module, cls): return def register_Ns3LteRadioBearerTag_methods(root_module, cls): - ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag(ns3::LteRadioBearerTag const & arg0) [copy constructor] + ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag(ns3::LteRadioBearerTag const & arg0) [constructor] cls.add_constructor([param('ns3::LteRadioBearerTag const &', 'arg0')]) ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag() [constructor] cls.add_constructor([]) @@ -10286,7 +10713,7 @@ def register_Ns3LteRadioBearerTag_methods(root_module, cls): return def register_Ns3LteRlcAmHeader_methods(root_module, cls): - ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader(ns3::LteRlcAmHeader const & arg0) [copy constructor] + ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader(ns3::LteRlcAmHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcAmHeader const &', 'arg0')]) ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader() [constructor] cls.add_constructor([]) @@ -10441,7 +10868,7 @@ def register_Ns3LteRlcAmHeader_methods(root_module, cls): return def register_Ns3LteRlcHeader_methods(root_module, cls): - ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader(ns3::LteRlcHeader const & arg0) [copy constructor] + ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader(ns3::LteRlcHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcHeader const &', 'arg0')]) ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader() [constructor] cls.add_constructor([]) @@ -10512,7 +10939,7 @@ def register_Ns3LteRlcHeader_methods(root_module, cls): return def register_Ns3LteRlcSduStatusTag_methods(root_module, cls): - ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag(ns3::LteRlcSduStatusTag const & arg0) [copy constructor] + ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag(ns3::LteRlcSduStatusTag const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSduStatusTag const &', 'arg0')]) ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag() [constructor] cls.add_constructor([]) @@ -10592,7 +11019,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -10613,7 +11040,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -10622,14 +11049,14 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) return def register_Ns3PacketBurst_methods(root_module, cls): - ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor] + ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [constructor] cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')]) ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor] cls.add_constructor([]) @@ -10637,9 +11064,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): cls.add_method('AddPacket', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')]) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::Begin() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): ns3::Ptr ns3::PacketBurst::Copy() const [member function] @@ -10647,9 +11074,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): 'ns3::Ptr< ns3::PacketBurst >', [], is_const=True) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::End() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function] @@ -10680,7 +11107,7 @@ def register_Ns3PacketBurst_methods(root_module, cls): return def register_Ns3PdcpTag_methods(root_module, cls): - ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag(ns3::PdcpTag const & arg0) [copy constructor] + ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag(ns3::PdcpTag const & arg0) [constructor] cls.add_constructor([param('ns3::PdcpTag const &', 'arg0')]) ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag() [constructor] cls.add_constructor([]) @@ -10799,7 +11226,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): return def register_Ns3RlcTag_methods(root_module, cls): - ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag(ns3::RlcTag const & arg0) [copy constructor] + ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag(ns3::RlcTag const & arg0) [constructor] cls.add_constructor([param('ns3::RlcTag const &', 'arg0')]) ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag() [constructor] cls.add_constructor([]) @@ -10889,7 +11316,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10901,7 +11328,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10913,7 +11340,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10925,7 +11352,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10937,7 +11364,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EpcTft_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTft__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EpcTft, ns3::empty, ns3::DefaultDeleter< ns3::EpcTft > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10949,7 +11376,7 @@ def register_Ns3SimpleRefCount__Ns3EpcTft_Ns3Empty_Ns3DefaultDeleter__lt__ns3Epc def register_Ns3SimpleRefCount__Ns3EpcTftClassifier_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTftClassifier__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EpcTftClassifier, ns3::empty, ns3::DefaultDeleter< ns3::EpcTftClassifier > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10961,7 +11388,7 @@ def register_Ns3SimpleRefCount__Ns3EpcTftClassifier_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10973,7 +11400,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10985,7 +11412,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3Ipv4MulticastRoute_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4MulticastRoute__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Ipv4MulticastRoute, ns3::empty, ns3::DefaultDeleter< ns3::Ipv4MulticastRoute > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10997,7 +11424,7 @@ def register_Ns3SimpleRefCount__Ns3Ipv4MulticastRoute_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3Ipv4Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4Route__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter< ns3::Ipv4Route > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11009,7 +11436,7 @@ def register_Ns3SimpleRefCount__Ns3Ipv4Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3LteChunkProcessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteChunkProcessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteChunkProcessor, ns3::empty, ns3::DefaultDeleter< ns3::LteChunkProcessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11021,7 +11448,7 @@ def register_Ns3SimpleRefCount__Ns3LteChunkProcessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3LteControlMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteControlMessage__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteControlMessage, ns3::empty, ns3::DefaultDeleter< ns3::LteControlMessage > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11033,7 +11460,7 @@ def register_Ns3SimpleRefCount__Ns3LteControlMessage_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteHarqPhy__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteHarqPhy, ns3::empty, ns3::DefaultDeleter< ns3::LteHarqPhy > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11045,7 +11472,7 @@ def register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11057,7 +11484,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11069,7 +11496,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumModel__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumModel, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumModel > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11081,7 +11508,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumSignalParameters__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumSignalParameters, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumSignalParameters > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11093,7 +11520,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultD def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumValue, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11105,7 +11532,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11117,7 +11544,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3VendorSpecificValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3VendorSpecificValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::VendorSpecificValue, ns3::empty, ns3::DefaultDeleter< ns3::VendorSpecificValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11129,7 +11556,7 @@ def register_Ns3SimpleRefCount__Ns3VendorSpecificValue_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3X2CellInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2CellInfo__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::X2CellInfo, ns3::empty, ns3::DefaultDeleter< ns3::X2CellInfo > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11141,7 +11568,7 @@ def register_Ns3SimpleRefCount__Ns3X2CellInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3X2IfaceInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2IfaceInfo__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::X2IfaceInfo, ns3::empty, ns3::DefaultDeleter< ns3::X2IfaceInfo > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11151,7 +11578,7 @@ def register_Ns3SimpleRefCount__Ns3X2IfaceInfo_Ns3Empty_Ns3DefaultDeleter__lt__n return def register_Ns3Socket_methods(root_module, cls): - ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [constructor] cls.add_constructor([param('ns3::Socket const &', 'arg0')]) ## socket.h (module 'network'): ns3::Socket::Socket() [constructor] cls.add_constructor([]) @@ -11269,7 +11696,7 @@ def register_Ns3Socket_methods(root_module, cls): 'uint8_t', [param('uint8_t', 'ipTos')], is_static=True) - ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] + ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] cls.add_method('Ipv6JoinGroup', 'void', [param('ns3::Ipv6Address', 'address'), param('ns3::Socket::Ipv6MulticastFilterMode', 'filterMode'), param('std::vector< ns3::Ipv6Address >', 'sourceAddresses')], @@ -11362,7 +11789,7 @@ def register_Ns3Socket_methods(root_module, cls): cls.add_method('SendTo', 'int', [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')]) - ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] + ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] cls.add_method('SetAcceptCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')]) @@ -11511,7 +11938,7 @@ def register_Ns3Socket_methods(root_module, cls): return def register_Ns3SocketIpTosTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTosTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag() [constructor] cls.add_constructor([]) @@ -11557,7 +11984,7 @@ def register_Ns3SocketIpTosTag_methods(root_module, cls): return def register_Ns3SocketIpTtlTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor] cls.add_constructor([]) @@ -11603,7 +12030,7 @@ def register_Ns3SocketIpTtlTag_methods(root_module, cls): return def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6HopLimitTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag() [constructor] cls.add_constructor([]) @@ -11649,7 +12076,7 @@ def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): return def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6TclassTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag() [constructor] cls.add_constructor([]) @@ -11695,7 +12122,7 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): return def register_Ns3SocketPriorityTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor] cls.add_constructor([]) @@ -11741,7 +12168,7 @@ def register_Ns3SocketPriorityTag_methods(root_module, cls): return def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor] cls.add_constructor([]) @@ -11791,22 +12218,8 @@ def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): return def register_Ns3SpectrumInterference_methods(root_module, cls): - ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [copy constructor] - cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference() [constructor] cls.add_constructor([]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] - cls.add_method('AbortRx', - 'void', - []) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] - cls.add_method('AddSignal', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) - ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] - cls.add_method('EndRx', - 'bool', - []) ## spectrum-interference.h (module 'spectrum'): static ns3::TypeId ns3::SpectrumInterference::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -11816,14 +12229,28 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): cls.add_method('SetErrorModel', 'void', [param('ns3::Ptr< ns3::SpectrumErrorModel >', 'e')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] - cls.add_method('SetNoisePowerSpectralDensity', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] cls.add_method('StartRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::SpectrumValue const >', 'rxPsd')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] + cls.add_method('AbortRx', + 'void', + []) + ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] + cls.add_method('EndRx', + 'bool', + []) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] + cls.add_method('AddSignal', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + cls.add_method('SetNoisePowerSpectralDensity', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) + ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [constructor] + cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -11833,20 +12260,20 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): def register_Ns3SpectrumModel_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumModel const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(std::vector > centerFreqs) [constructor] cls.add_constructor([param('std::vector< double >', 'centerFreqs')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::Bands bands) [constructor] cls.add_constructor([param('ns3::Bands', 'bands')]) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::Begin() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::End() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) ## spectrum-model.h (module 'spectrum'): size_t ns3::SpectrumModel::GetNumBands() const [member function] @@ -11899,7 +12326,7 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::SpectrumChannel >', 'c')], is_pure_virtual=True, is_virtual=True) - ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] + ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -11917,11 +12344,11 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): return def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel(ns3::SpectrumPropagationLossModel const & arg0) [copy constructor] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel(ns3::SpectrumPropagationLossModel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumPropagationLossModel const &', 'arg0')]) ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel() [constructor] cls.add_constructor([]) - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::CalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::CalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('CalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -11940,7 +12367,7 @@ def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('DoCalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -11950,34 +12377,34 @@ def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): def register_Ns3SpectrumSignalParameters_methods(root_module, cls): ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters() [constructor] cls.add_constructor([]) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [copy constructor] + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [constructor] cls.add_constructor([param('ns3::SpectrumSignalParameters const &', 'p')]) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::Ptr ns3::SpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::duration [variable] - cls.add_instance_attribute('duration', 'ns3::Time', is_const=False) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::psd [variable] cls.add_instance_attribute('psd', 'ns3::Ptr< ns3::SpectrumValue >', is_const=False) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txAntenna [variable] - cls.add_instance_attribute('txAntenna', 'ns3::Ptr< ns3::AntennaModel >', is_const=False) + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::duration [variable] + cls.add_instance_attribute('duration', 'ns3::Time', is_const=False) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txPhy [variable] cls.add_instance_attribute('txPhy', 'ns3::Ptr< ns3::SpectrumPhy >', is_const=False) + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txAntenna [variable] + cls.add_instance_attribute('txAntenna', 'ns3::Ptr< ns3::AntennaModel >', is_const=False) return def register_Ns3SpectrumValue_methods(root_module, cls): + cls.add_output_stream_operator() + cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_unary_numeric_operator('-') cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_output_stream_operator() + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('double', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::SpectrumValue const &', u'right')) @@ -11986,30 +12413,30 @@ def register_Ns3SpectrumValue_methods(root_module, cls): cls.add_inplace_numeric_operator('-=', param('double', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('/=', param('double', u'right')) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [copy constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumValue const &', 'arg0')]) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::SpectrumModel const >', 'sm')]) ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue() [constructor] cls.add_constructor([]) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsBegin() const [member function] cls.add_method('ConstBandsBegin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsEnd() const [member function] cls.add_method('ConstBandsEnd', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesBegin() const [member function] cls.add_method('ConstValuesBegin', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesEnd() const [member function] cls.add_method('ConstValuesEnd', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::Copy() const [member function] @@ -12017,7 +12444,7 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] + ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] cls.add_method('GetSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -12027,33 +12454,33 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::SpectrumModelUid_t', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesBegin() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesBegin() [member function] cls.add_method('ValuesBegin', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesEnd() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesEnd() [member function] cls.add_method('ValuesEnd', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -12236,7 +12663,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceFadingLossModel_methods(root_module, cls): - ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel(ns3::TraceFadingLossModel const & arg0) [copy constructor] + ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel(ns3::TraceFadingLossModel const & arg0) [constructor] cls.add_constructor([param('ns3::TraceFadingLossModel const &', 'arg0')]) ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel() [constructor] cls.add_constructor([]) @@ -12254,7 +12681,7 @@ def register_Ns3TraceFadingLossModel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## trace-fading-loss-model.h (module 'lte'): ns3::Ptr ns3::TraceFadingLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## trace-fading-loss-model.h (module 'lte'): ns3::Ptr ns3::TraceFadingLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('DoCalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -12262,7 +12689,7 @@ def register_Ns3TraceFadingLossModel_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -12292,7 +12719,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -12365,12 +12792,12 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): return def register_Ns3UeManager_methods(root_module, cls): - ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::UeManager const & arg0) [copy constructor] + ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::UeManager const & arg0) [constructor] cls.add_constructor([param('ns3::UeManager const &', 'arg0')]) ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager() [constructor] cls.add_constructor([]) - ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::Ptr rrc, uint16_t rnti, ns3::UeManager::State s) [constructor] - cls.add_constructor([param('ns3::Ptr< ns3::LteEnbRrc >', 'rrc'), param('uint16_t', 'rnti'), param('ns3::UeManager::State', 's')]) + ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::Ptr rrc, uint16_t rnti, ns3::UeManager::State s, uint8_t componentCarrierId) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::LteEnbRrc >', 'rrc'), param('uint16_t', 'rnti'), param('ns3::UeManager::State', 's'), param('uint8_t', 'componentCarrierId')]) ## lte-enb-rrc.h (module 'lte'): void ns3::UeManager::CmacUeConfigUpdateInd(ns3::LteEnbCmacSapUser::UeConfig cmacParams) [member function] cls.add_method('CmacUeConfigUpdateInd', 'void', @@ -12383,6 +12810,11 @@ def register_Ns3UeManager_methods(root_module, cls): cls.add_method('DoReceivePdcpSdu', 'void', [param('ns3::LtePdcpSapUser::ReceivePdcpSduParameters', 'params')]) + ## lte-enb-rrc.h (module 'lte'): uint8_t ns3::UeManager::GetComponentCarrierId() const [member function] + cls.add_method('GetComponentCarrierId', + 'uint8_t', + [], + is_const=True) ## lte-enb-rrc.h (module 'lte'): std::vector > ns3::UeManager::GetErabList() [member function] cls.add_method('GetErabList', 'std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', @@ -12561,7 +12993,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): def register_Ns3VendorSpecificValue_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue(ns3::VendorSpecificValue const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue(ns3::VendorSpecificValue const & arg0) [constructor] cls.add_constructor([param('ns3::VendorSpecificValue const &', 'arg0')]) return @@ -12609,7 +13041,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): return def register_Ns3X2CellInfo_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(ns3::X2CellInfo const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(ns3::X2CellInfo const & arg0) [constructor] cls.add_constructor([param('ns3::X2CellInfo const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(uint16_t localCellId, uint16_t remoteCellId) [constructor] cls.add_constructor([param('uint16_t', 'localCellId'), param('uint16_t', 'remoteCellId')]) @@ -12620,7 +13052,7 @@ def register_Ns3X2CellInfo_methods(root_module, cls): return def register_Ns3X2IfaceInfo_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::X2IfaceInfo const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::X2IfaceInfo const & arg0) [constructor] cls.add_constructor([param('ns3::X2IfaceInfo const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::Ipv4Address remoteIpAddr, ns3::Ptr localCtrlPlaneSocket, ns3::Ptr localUserPlaneSocket) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'remoteIpAddr'), param('ns3::Ptr< ns3::Socket >', 'localCtrlPlaneSocket'), param('ns3::Ptr< ns3::Socket >', 'localUserPlaneSocket')]) @@ -12704,7 +13136,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3Application_methods(root_module, cls): - ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [copy constructor] + ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [constructor] cls.add_constructor([param('ns3::Application const &', 'arg0')]) ## application.h (module 'network'): ns3::Application::Application() [constructor] cls.add_constructor([]) @@ -12753,7 +13185,7 @@ def register_Ns3Application_methods(root_module, cls): return def register_Ns3Asn1Header_methods(root_module, cls): - ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header(ns3::Asn1Header const & arg0) [copy constructor] + ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header(ns3::Asn1Header const & arg0) [constructor] cls.add_constructor([param('ns3::Asn1Header const &', 'arg0')]) ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header() [constructor] cls.add_constructor([]) @@ -12792,50 +13224,50 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [param('ns3::Buffer::Iterator', 'bIterator')], is_const=True, is_virtual=True) - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitset(std::bitset<8ul> * data, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitset(std::bitset<8> * data, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitset', 'ns3::Buffer::Iterator', - [param('std::bitset< 8ul > *', 'data'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 8 > *', 'data'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<1ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<1> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 1ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 1 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<2ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<2> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 2ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 2 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<8ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<8> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 8ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 8 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<10ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<10> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 10ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 10 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<16ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<16> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 16ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 16 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<27ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<27> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 27ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 27 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<28ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<28> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 28ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 28 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<32ul> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<32> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 32ul > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 32 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBoolean(bool * value, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBoolean', @@ -12862,60 +13294,60 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<0ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<0> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 0ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 0 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<1ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<1> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 1ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 1 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<2ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<2> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 2ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 2 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<3ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<3> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 3ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 3 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<4ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<4> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 4ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 4 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<5ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<5> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 5ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 5 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<6ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<6> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 6ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 6 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<7ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<7> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 7ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 7 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<9ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<9> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 9ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 9 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<10ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<10> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 10ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 10 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<11ul> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<11> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 11ul > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 11 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequenceOf(int * numElems, int nMax, int nMin, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequenceOf', @@ -12927,45 +13359,45 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<1ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<1> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 1ul >', 'bitstring')], + [param('std::bitset< 1 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<2ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<2> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 2ul >', 'bitstring')], + [param('std::bitset< 2 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<8ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<8> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 8ul >', 'bitstring')], + [param('std::bitset< 8 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<10ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<10> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 10ul >', 'bitstring')], + [param('std::bitset< 10 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<16ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<16> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 16ul >', 'bitstring')], + [param('std::bitset< 16 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<27ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<27> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 27ul >', 'bitstring')], + [param('std::bitset< 27 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<28ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<28> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 28ul >', 'bitstring')], + [param('std::bitset< 28 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<32ul> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<32> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 32ul >', 'bitstring')], + [param('std::bitset< 32 >', 'bitstring')], is_const=True, visibility='protected') ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBoolean(bool value) const [member function] cls.add_method('SerializeBoolean', @@ -12992,60 +13424,60 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<0ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<0> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 0ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 0 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<1ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<1> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 1ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 1 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<2ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<2> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 2ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 2 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<3ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<3> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 3ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 3 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<4ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<4> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 4ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 4 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<5ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<5> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 5ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 5 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<6ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<6> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 6ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 6 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<7ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<7> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 7ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 7 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<9ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<9> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 9ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 9 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<10ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<10> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 10ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 10 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<11ul> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<11> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 11ul >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 11 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequenceOf(int numElems, int nMax, int nMin) const [member function] cls.add_method('SerializeSequenceOf', @@ -13060,7 +13492,7 @@ def register_Ns3Asn1Header_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -13087,7 +13519,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -13129,7 +13561,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -13138,12 +13570,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13153,13 +13585,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -13170,7 +13602,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13180,7 +13612,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13194,21 +13626,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -13218,10 +13650,140 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::PhyReceptionStatParameters']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'double']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::PhyTransmissionStatParameters']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteUePhy::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::EpcUeNas::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::SpectrumValue const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned long']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UeManager::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteRrcSap::MeasurementReport']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::DlSchedulingCallbackInfo']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteUeRrc::State']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -13232,12 +13794,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13249,7 +13811,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3CcHelper_methods(root_module, cls): - ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper(ns3::CcHelper const & arg0) [copy constructor] + ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper(ns3::CcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::CcHelper const &', 'arg0')]) ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper() [constructor] cls.add_constructor([]) @@ -13262,7 +13824,7 @@ def register_Ns3CcHelper_methods(root_module, cls): 'void', [], is_virtual=True) - ## cc-helper.h (module 'lte'): std::map, std::allocator > > ns3::CcHelper::EquallySpacedCcs() [member function] + ## cc-helper.h (module 'lte'): std::map, std::allocator > > ns3::CcHelper::EquallySpacedCcs() [member function] cls.add_method('EquallySpacedCcs', 'std::map< unsigned char, ns3::ComponentCarrier >', []) @@ -13323,7 +13885,7 @@ def register_Ns3CcHelper_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -13350,7 +13912,7 @@ def register_Ns3Channel_methods(root_module, cls): return def register_Ns3ComponentCarrier_methods(root_module, cls): - ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier(ns3::ComponentCarrier const & arg0) [copy constructor] + ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier(ns3::ComponentCarrier const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrier const &', 'arg0')]) ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier() [constructor] cls.add_constructor([]) @@ -13443,7 +14005,7 @@ def register_Ns3ComponentCarrier_methods(root_module, cls): return def register_Ns3ComponentCarrierEnb_methods(root_module, cls): - ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb(ns3::ComponentCarrierEnb const & arg0) [copy constructor] + ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb(ns3::ComponentCarrierEnb const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrierEnb const &', 'arg0')]) ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb() [constructor] cls.add_constructor([]) @@ -13452,6 +14014,10 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): 'void', [], is_virtual=True) + ## component-carrier-enb.h (module 'lte'): uint16_t ns3::ComponentCarrierEnb::GetCellId() [member function] + cls.add_method('GetCellId', + 'uint16_t', + []) ## component-carrier-enb.h (module 'lte'): ns3::Ptr ns3::ComponentCarrierEnb::GetFfMacScheduler() [member function] cls.add_method('GetFfMacScheduler', 'ns3::Ptr< ns3::FfMacScheduler >', @@ -13473,6 +14039,10 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) + ## component-carrier-enb.h (module 'lte'): void ns3::ComponentCarrierEnb::SetCellId(uint16_t cellId) [member function] + cls.add_method('SetCellId', + 'void', + [param('uint16_t', 'cellId')]) ## component-carrier-enb.h (module 'lte'): void ns3::ComponentCarrierEnb::SetFfMacScheduler(ns3::Ptr s) [member function] cls.add_method('SetFfMacScheduler', 'void', @@ -13497,7 +14067,7 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): return def register_Ns3ComponentCarrierUe_methods(root_module, cls): - ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe(ns3::ComponentCarrierUe const & arg0) [copy constructor] + ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe(ns3::ComponentCarrierUe const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrierUe const &', 'arg0')]) ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe() [constructor] cls.add_constructor([]) @@ -13570,7 +14140,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DataCalculator_methods(root_module, cls): - ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')]) ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator() [constructor] cls.add_constructor([]) @@ -13633,7 +14203,7 @@ def register_Ns3DataCalculator_methods(root_module, cls): return def register_Ns3DataOutputInterface_methods(root_module, cls): - ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')]) ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface() [constructor] cls.add_constructor([]) @@ -13666,23 +14236,23 @@ def register_Ns3DataOutputInterface_methods(root_module, cls): def register_Ns3DataRateChecker_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')]) return def register_Ns3DataRateValue_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'value')]) + ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::Ptr ns3::DataRateValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13692,7 +14262,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): 'ns3::DataRate', [], is_const=True) - ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13730,16 +14300,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13749,7 +14319,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13795,7 +14365,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -13822,7 +14392,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -13859,7 +14429,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -13868,12 +14438,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13881,7 +14451,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -13926,7 +14496,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -13937,7 +14507,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13947,7 +14517,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13959,7 +14529,7 @@ def register_Ns3EnumValue_methods(root_module, cls): return def register_Ns3EpcEnbApplication_methods(root_module, cls): - ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::EpcEnbApplication const & arg0) [copy constructor] + ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::EpcEnbApplication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbApplication const &', 'arg0')]) ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::Ptr lteSocket, ns3::Ptr s1uSocket, ns3::Ipv4Address enbS1uAddress, ns3::Ipv4Address sgwS1uAddress, uint16_t cellId) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::Socket >', 'lteSocket'), param('ns3::Ptr< ns3::Socket >', 's1uSocket'), param('ns3::Ipv4Address', 'enbS1uAddress'), param('ns3::Ipv4Address', 'sgwS1uAddress'), param('uint16_t', 'cellId')]) @@ -14002,7 +14572,7 @@ def register_Ns3EpcEnbApplication_methods(root_module, cls): def register_Ns3EpcEnbApplicationEpsFlowId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t(ns3::EpcEnbApplication::EpsFlowId_t const & arg0) [copy constructor] + ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t(ns3::EpcEnbApplication::EpsFlowId_t const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbApplication::EpsFlowId_t const &', 'arg0')]) ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t() [constructor] cls.add_constructor([]) @@ -14015,7 +14585,7 @@ def register_Ns3EpcEnbApplicationEpsFlowId_t_methods(root_module, cls): return def register_Ns3EpcHelper_methods(root_module, cls): - ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper(ns3::EpcHelper const & arg0) [copy constructor] + ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper(ns3::EpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EpcHelper const &', 'arg0')]) ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper() [constructor] cls.add_constructor([]) @@ -14067,7 +14637,7 @@ def register_Ns3EpcHelper_methods(root_module, cls): return def register_Ns3EpcMme_methods(root_module, cls): - ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme(ns3::EpcMme const & arg0) [copy constructor] + ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme(ns3::EpcMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcMme const &', 'arg0')]) ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme() [constructor] cls.add_constructor([]) @@ -14108,7 +14678,7 @@ def register_Ns3EpcMme_methods(root_module, cls): return def register_Ns3EpcSgwPgwApplication_methods(root_module, cls): - ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::EpcSgwPgwApplication const & arg0) [copy constructor] + ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::EpcSgwPgwApplication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcSgwPgwApplication const &', 'arg0')]) ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::Ptr const tunDevice, ns3::Ptr const s1uSocket) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::VirtualNetDevice > const', 'tunDevice'), param('ns3::Ptr< ns3::Socket > const', 's1uSocket')]) @@ -14161,7 +14731,7 @@ def register_Ns3EpcSgwPgwApplication_methods(root_module, cls): return def register_Ns3EpcTft_methods(root_module, cls): - ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft(ns3::EpcTft const & arg0) [copy constructor] + ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft(ns3::EpcTft const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTft const &', 'arg0')]) ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft() [constructor] cls.add_constructor([]) @@ -14181,7 +14751,7 @@ def register_Ns3EpcTft_methods(root_module, cls): return def register_Ns3EpcTftPacketFilter_methods(root_module, cls): - ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter(ns3::EpcTft::PacketFilter const & arg0) [copy constructor] + ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter(ns3::EpcTft::PacketFilter const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTft::PacketFilter const &', 'arg0')]) ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter() [constructor] cls.add_constructor([]) @@ -14216,7 +14786,7 @@ def register_Ns3EpcTftPacketFilter_methods(root_module, cls): return def register_Ns3EpcTftClassifier_methods(root_module, cls): - ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier(ns3::EpcTftClassifier const & arg0) [copy constructor] + ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier(ns3::EpcTftClassifier const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTftClassifier const &', 'arg0')]) ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier() [constructor] cls.add_constructor([]) @@ -14235,7 +14805,7 @@ def register_Ns3EpcTftClassifier_methods(root_module, cls): return def register_Ns3EpcUeNas_methods(root_module, cls): - ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas(ns3::EpcUeNas const & arg0) [copy constructor] + ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas(ns3::EpcUeNas const & arg0) [constructor] cls.add_constructor([param('ns3::EpcUeNas const &', 'arg0')]) ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas() [constructor] cls.add_constructor([]) @@ -14310,7 +14880,7 @@ def register_Ns3EpcUeNas_methods(root_module, cls): return def register_Ns3EpcX2_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2(ns3::EpcX2 const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2(ns3::EpcX2 const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2 const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2() [constructor] cls.add_constructor([]) @@ -14387,7 +14957,7 @@ def register_Ns3EpcX2_methods(root_module, cls): return def register_Ns3EpcX2HandoverPreparationFailureHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader(ns3::EpcX2HandoverPreparationFailureHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader(ns3::EpcX2HandoverPreparationFailureHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverPreparationFailureHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader() [constructor] cls.add_constructor([]) @@ -14461,7 +15031,7 @@ def register_Ns3EpcX2HandoverPreparationFailureHeader_methods(root_module, cls): return def register_Ns3EpcX2HandoverRequestAckHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader(ns3::EpcX2HandoverRequestAckHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader(ns3::EpcX2HandoverRequestAckHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverRequestAckHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader() [constructor] cls.add_constructor([]) @@ -14544,7 +15114,7 @@ def register_Ns3EpcX2HandoverRequestAckHeader_methods(root_module, cls): return def register_Ns3EpcX2HandoverRequestHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader(ns3::EpcX2HandoverRequestHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader(ns3::EpcX2HandoverRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverRequestHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader() [constructor] cls.add_constructor([]) @@ -14654,7 +15224,7 @@ def register_Ns3EpcX2HandoverRequestHeader_methods(root_module, cls): return def register_Ns3EpcX2Header_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header(ns3::EpcX2Header const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header(ns3::EpcX2Header const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Header const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header() [constructor] cls.add_constructor([]) @@ -14717,7 +15287,7 @@ def register_Ns3EpcX2Header_methods(root_module, cls): return def register_Ns3EpcX2LoadInformationHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader(ns3::EpcX2LoadInformationHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader(ns3::EpcX2LoadInformationHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2LoadInformationHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader() [constructor] cls.add_constructor([]) @@ -14773,7 +15343,7 @@ def register_Ns3EpcX2LoadInformationHeader_methods(root_module, cls): return def register_Ns3EpcX2ResourceStatusUpdateHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader(ns3::EpcX2ResourceStatusUpdateHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader(ns3::EpcX2ResourceStatusUpdateHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2ResourceStatusUpdateHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader() [constructor] cls.add_constructor([]) @@ -14847,7 +15417,7 @@ def register_Ns3EpcX2ResourceStatusUpdateHeader_methods(root_module, cls): return def register_Ns3EpcX2SnStatusTransferHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader(ns3::EpcX2SnStatusTransferHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader(ns3::EpcX2SnStatusTransferHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SnStatusTransferHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader() [constructor] cls.add_constructor([]) @@ -14921,7 +15491,7 @@ def register_Ns3EpcX2SnStatusTransferHeader_methods(root_module, cls): return def register_Ns3EpcX2UeContextReleaseHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader(ns3::EpcX2UeContextReleaseHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader(ns3::EpcX2UeContextReleaseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2UeContextReleaseHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader() [constructor] cls.add_constructor([]) @@ -15024,7 +15594,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -15086,7 +15656,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): return def register_Ns3FfMacScheduler_methods(root_module, cls): - ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler(ns3::FfMacScheduler const & arg0) [copy constructor] + ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler(ns3::FfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacScheduler const &', 'arg0')]) ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler() [constructor] cls.add_constructor([]) @@ -15172,7 +15742,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3GtpuHeader_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader(ns3::GtpuHeader const & arg0) [copy constructor] + ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader(ns3::GtpuHeader const & arg0) [constructor] cls.add_constructor([param('ns3::GtpuHeader const &', 'arg0')]) ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader() [constructor] cls.add_constructor([]) @@ -15261,65 +15831,65 @@ def register_Ns3GtpuHeader_methods(root_module, cls): 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetExtensionHeaderFlag(bool m_extensionHeaderFlag) [member function] + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetExtensionHeaderFlag(bool extensionHeaderFlag) [member function] cls.add_method('SetExtensionHeaderFlag', 'void', - [param('bool', 'm_extensionHeaderFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetLength(uint16_t m_length) [member function] + [param('bool', 'extensionHeaderFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetLength(uint16_t length) [member function] cls.add_method('SetLength', 'void', - [param('uint16_t', 'm_length')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetMessageType(uint8_t m_messageType) [member function] + [param('uint16_t', 'length')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetMessageType(uint8_t messageType) [member function] cls.add_method('SetMessageType', 'void', - [param('uint8_t', 'm_messageType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumber(uint8_t m_nPduNumber) [member function] + [param('uint8_t', 'messageType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumber(uint8_t nPduNumber) [member function] cls.add_method('SetNPduNumber', 'void', - [param('uint8_t', 'm_nPduNumber')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumberFlag(bool m_nPduNumberFlag) [member function] + [param('uint8_t', 'nPduNumber')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumberFlag(bool nPduNumberFlag) [member function] cls.add_method('SetNPduNumberFlag', 'void', - [param('bool', 'm_nPduNumberFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNextExtensionType(uint8_t m_nextExtensionType) [member function] + [param('bool', 'nPduNumberFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNextExtensionType(uint8_t nextExtensionType) [member function] cls.add_method('SetNextExtensionType', 'void', - [param('uint8_t', 'm_nextExtensionType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetProtocolType(bool m_protocolType) [member function] + [param('uint8_t', 'nextExtensionType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetProtocolType(bool protocolType) [member function] cls.add_method('SetProtocolType', 'void', - [param('bool', 'm_protocolType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumber(uint16_t m_sequenceNumber) [member function] + [param('bool', 'protocolType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumber(uint16_t sequenceNumber) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('uint16_t', 'm_sequenceNumber')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumberFlag(bool m_sequenceNumberFlag) [member function] + [param('uint16_t', 'sequenceNumber')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumberFlag(bool sequenceNumberFlag) [member function] cls.add_method('SetSequenceNumberFlag', 'void', - [param('bool', 'm_sequenceNumberFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetTeid(uint32_t m_teid) [member function] + [param('bool', 'sequenceNumberFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetTeid(uint32_t teid) [member function] cls.add_method('SetTeid', 'void', - [param('uint32_t', 'm_teid')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetVersion(uint8_t m_version) [member function] + [param('uint32_t', 'teid')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetVersion(uint8_t version) [member function] cls.add_method('SetVersion', 'void', - [param('uint8_t', 'm_version')]) + [param('uint8_t', 'version')]) return def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15329,7 +15899,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15341,7 +15911,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): return def register_Ns3Ipv4_methods(root_module, cls): - ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor] + ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')]) ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4() [constructor] cls.add_constructor([]) @@ -15547,23 +16117,23 @@ def register_Ns3Ipv4_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15573,7 +16143,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15587,23 +16157,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15613,7 +16183,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15625,7 +16195,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): return def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): - ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & arg0) [copy constructor] + ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'arg0')]) ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor] cls.add_constructor([]) @@ -15639,7 +16209,7 @@ def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-route.h (module 'internet'): std::map, std::allocator > > ns3::Ipv4MulticastRoute::GetOutputTtlMap() const [member function] + ## ipv4-route.h (module 'internet'): std::map, std::allocator > > ns3::Ipv4MulticastRoute::GetOutputTtlMap() const [member function] cls.add_method('GetOutputTtlMap', 'std::map< unsigned int, unsigned int >', [], @@ -15673,7 +16243,7 @@ def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): def register_Ns3Ipv4Route_methods(root_module, cls): cls.add_output_stream_operator() - ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & arg0) [copy constructor] + ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Route const &', 'arg0')]) ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route() [constructor] cls.add_constructor([]) @@ -15718,23 +16288,23 @@ def register_Ns3Ipv4Route_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15744,7 +16314,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15758,23 +16328,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15784,7 +16354,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15834,7 +16404,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): return def register_Ns3LteAmc_methods(root_module, cls): - ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc(ns3::LteAmc const & arg0) [copy constructor] + ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc(ns3::LteAmc const & arg0) [constructor] cls.add_constructor([param('ns3::LteAmc const &', 'arg0')]) ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc() [constructor] cls.add_constructor([]) @@ -15866,7 +16436,7 @@ def register_Ns3LteAmc_methods(root_module, cls): return def register_Ns3LteAnr_methods(root_module, cls): - ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(ns3::LteAnr const & arg0) [copy constructor] + ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(ns3::LteAnr const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnr const &', 'arg0')]) ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(uint16_t servingCellId) [constructor] cls.add_constructor([param('uint16_t', 'servingCellId')]) @@ -15906,14 +16476,14 @@ def register_Ns3LteAnr_methods(root_module, cls): return def register_Ns3LteChunkProcessor_methods(root_module, cls): - ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor(ns3::LteChunkProcessor const & arg0) [copy constructor] + ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor(ns3::LteChunkProcessor const & arg0) [constructor] cls.add_constructor([param('ns3::LteChunkProcessor const &', 'arg0')]) ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor() [constructor] cls.add_constructor([]) ## lte-chunk-processor.h (module 'lte'): void ns3::LteChunkProcessor::AddCallback(ns3::LteChunkProcessorCallback c) [member function] cls.add_method('AddCallback', 'void', - [param('ns3::LteChunkProcessorCallback', 'c')], + [param('ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')], is_virtual=True) ## lte-chunk-processor.h (module 'lte'): void ns3::LteChunkProcessor::End() [member function] cls.add_method('End', @@ -15933,7 +16503,7 @@ def register_Ns3LteChunkProcessor_methods(root_module, cls): return def register_Ns3LteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage(ns3::LteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage(ns3::LteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::LteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage() [constructor] cls.add_constructor([]) @@ -15948,7 +16518,7 @@ def register_Ns3LteControlMessage_methods(root_module, cls): return def register_Ns3LteEnbComponentCarrierManager_methods(root_module, cls): - ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager(ns3::LteEnbComponentCarrierManager const & arg0) [copy constructor] + ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager(ns3::LteEnbComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbComponentCarrierManager const &', 'arg0')]) ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -16010,7 +16580,7 @@ def register_Ns3LteEnbComponentCarrierManager_methods(root_module, cls): return def register_Ns3LteEnbMac_methods(root_module, cls): - ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac(ns3::LteEnbMac const & arg0) [copy constructor] + ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac(ns3::LteEnbMac const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbMac const &', 'arg0')]) ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac() [constructor] cls.add_constructor([]) @@ -16083,7 +16653,7 @@ def register_Ns3LteEnbMac_methods(root_module, cls): return def register_Ns3LteEnbRrc_methods(root_module, cls): - ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc(ns3::LteEnbRrc const & arg0) [copy constructor] + ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc(ns3::LteEnbRrc const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrc const &', 'arg0')]) ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc() [constructor] cls.add_constructor([]) @@ -16095,14 +16665,22 @@ def register_Ns3LteEnbRrc_methods(root_module, cls): cls.add_method('AddX2Neighbour', 'void', [param('uint16_t', 'cellId')]) - ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCarriers(std::map, std::allocator > > ccPhyConf, uint16_t numberOfCarriers) [member function] + ## lte-enb-rrc.h (module 'lte'): uint8_t ns3::LteEnbRrc::CellToComponentCarrierId(uint16_t cellId) [member function] + cls.add_method('CellToComponentCarrierId', + 'uint8_t', + [param('uint16_t', 'cellId')]) + ## lte-enb-rrc.h (module 'lte'): uint16_t ns3::LteEnbRrc::ComponentCarrierToCellId(uint8_t componentCarrierId) [member function] + cls.add_method('ComponentCarrierToCellId', + 'uint16_t', + [param('uint8_t', 'componentCarrierId')]) + ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCarriers(std::map, std::less, std::allocator > > > ccPhyConf) [member function] cls.add_method('ConfigureCarriers', 'void', - [param('std::map< unsigned char, ns3::ComponentCarrier >', 'ccPhyConf'), param('uint16_t', 'numberOfCarriers')]) - ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCell(uint16_t cellId) [member function] + [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccPhyConf')]) + ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCell(std::map, std::less, std::allocator > > > ccPhyConf) [member function] cls.add_method('ConfigureCell', 'void', - [param('uint16_t', 'cellId')]) + [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccPhyConf')]) ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConnectionRejectedTimeout(uint16_t rnti) [member function] cls.add_method('ConnectionRejectedTimeout', 'void', @@ -16286,7 +16864,7 @@ def register_Ns3LteEnbRrc_methods(root_module, cls): return def register_Ns3LteEnbRrcProtocolIdeal_methods(root_module, cls): - ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal(ns3::LteEnbRrcProtocolIdeal const & arg0) [copy constructor] + ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal(ns3::LteEnbRrcProtocolIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolIdeal const &', 'arg0')]) ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal() [constructor] cls.add_constructor([]) @@ -16323,7 +16901,7 @@ def register_Ns3LteEnbRrcProtocolIdeal_methods(root_module, cls): return def register_Ns3LteEnbRrcProtocolReal_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal(ns3::LteEnbRrcProtocolReal const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal(ns3::LteEnbRrcProtocolReal const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolReal const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal() [constructor] cls.add_constructor([]) @@ -16360,7 +16938,7 @@ def register_Ns3LteEnbRrcProtocolReal_methods(root_module, cls): return def register_Ns3LteFfrAlgorithm_methods(root_module, cls): - ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm(ns3::LteFfrAlgorithm const & arg0) [copy constructor] + ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm(ns3::LteFfrAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrAlgorithm const &', 'arg0')]) ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm() [constructor] cls.add_constructor([]) @@ -16471,7 +17049,7 @@ def register_Ns3LteFfrAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], is_pure_virtual=True, visibility='protected', is_virtual=True) - ## lte-ffr-algorithm.h (module 'lte'): void ns3::LteFfrAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-algorithm.h (module 'lte'): void ns3::LteFfrAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16499,7 +17077,7 @@ def register_Ns3LteFfrAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): - ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm(ns3::LteFfrDistributedAlgorithm const & arg0) [copy constructor] + ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm(ns3::LteFfrDistributedAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrDistributedAlgorithm const &', 'arg0')]) ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm() [constructor] cls.add_constructor([]) @@ -16588,7 +17166,7 @@ def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-distributed-algorithm.h (module 'lte'): void ns3::LteFfrDistributedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-distributed-algorithm.h (module 'lte'): void ns3::LteFfrDistributedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16601,7 +17179,7 @@ def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): - ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm(ns3::LteFfrEnhancedAlgorithm const & arg0) [copy constructor] + ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm(ns3::LteFfrEnhancedAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrEnhancedAlgorithm const &', 'arg0')]) ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm() [constructor] cls.add_constructor([]) @@ -16690,7 +17268,7 @@ def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-enhanced-algorithm.h (module 'lte'): void ns3::LteFfrEnhancedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-enhanced-algorithm.h (module 'lte'): void ns3::LteFfrEnhancedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16703,7 +17281,7 @@ def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): - ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm(ns3::LteFfrSoftAlgorithm const & arg0) [copy constructor] + ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm(ns3::LteFfrSoftAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSoftAlgorithm const &', 'arg0')]) ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm() [constructor] cls.add_constructor([]) @@ -16792,7 +17370,7 @@ def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-soft-algorithm.h (module 'lte'): void ns3::LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-soft-algorithm.h (module 'lte'): void ns3::LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16805,7 +17383,7 @@ def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): return def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): - ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm(ns3::LteFrHardAlgorithm const & arg0) [copy constructor] + ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm(ns3::LteFrHardAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrHardAlgorithm const &', 'arg0')]) ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm() [constructor] cls.add_constructor([]) @@ -16894,7 +17472,7 @@ def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-hard-algorithm.h (module 'lte'): void ns3::LteFrHardAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-hard-algorithm.h (module 'lte'): void ns3::LteFrHardAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16907,7 +17485,7 @@ def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): return def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): - ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm(ns3::LteFrNoOpAlgorithm const & arg0) [copy constructor] + ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm(ns3::LteFrNoOpAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrNoOpAlgorithm const &', 'arg0')]) ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm() [constructor] cls.add_constructor([]) @@ -16996,7 +17574,7 @@ def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-no-op-algorithm.h (module 'lte'): void ns3::LteFrNoOpAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-no-op-algorithm.h (module 'lte'): void ns3::LteFrNoOpAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17009,7 +17587,7 @@ def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): return def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): - ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm(ns3::LteFrSoftAlgorithm const & arg0) [copy constructor] + ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm(ns3::LteFrSoftAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrSoftAlgorithm const &', 'arg0')]) ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm() [constructor] cls.add_constructor([]) @@ -17098,7 +17676,7 @@ def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-soft-algorithm.h (module 'lte'): void ns3::LteFrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-soft-algorithm.h (module 'lte'): void ns3::LteFrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17111,7 +17689,7 @@ def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): return def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): - ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm(ns3::LteFrStrictAlgorithm const & arg0) [copy constructor] + ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm(ns3::LteFrStrictAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrStrictAlgorithm const &', 'arg0')]) ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm() [constructor] cls.add_constructor([]) @@ -17200,7 +17778,7 @@ def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-strict-algorithm.h (module 'lte'): void ns3::LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-strict-algorithm.h (module 'lte'): void ns3::LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17213,7 +17791,7 @@ def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): return def register_Ns3LteHandoverAlgorithm_methods(root_module, cls): - ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm(ns3::LteHandoverAlgorithm const & arg0) [copy constructor] + ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm(ns3::LteHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverAlgorithm const &', 'arg0')]) ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -17245,7 +17823,7 @@ def register_Ns3LteHandoverAlgorithm_methods(root_module, cls): return def register_Ns3LteHarqPhy_methods(root_module, cls): - ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy(ns3::LteHarqPhy const & arg0) [copy constructor] + ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy(ns3::LteHarqPhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteHarqPhy const &', 'arg0')]) ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy() [constructor] cls.add_constructor([]) @@ -17288,7 +17866,7 @@ def register_Ns3LteHarqPhy_methods(root_module, cls): return def register_Ns3LteHelper_methods(root_module, cls): - ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper(ns3::LteHelper const & arg0) [copy constructor] + ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper(ns3::LteHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteHelper const &', 'arg0')]) ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper() [constructor] cls.add_constructor([]) @@ -17414,11 +17992,6 @@ def register_Ns3LteHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumChannel >', [], is_const=True) - ## lte-helper.h (module 'lte'): ns3::Ptr ns3::LteHelper::GetDownlinkSpectrumChannel(uint8_t carrierId) const [member function] - cls.add_method('GetDownlinkSpectrumChannel', - 'ns3::Ptr< ns3::SpectrumChannel >', - [param('uint8_t', 'carrierId')], - is_const=True) ## lte-helper.h (module 'lte'): std::string ns3::LteHelper::GetEnbComponentCarrierManagerType() const [member function] cls.add_method('GetEnbComponentCarrierManagerType', 'std::string', @@ -17466,6 +18039,10 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('HandoverRequest', 'void', [param('ns3::Time', 'hoTime'), param('ns3::Ptr< ns3::NetDevice >', 'ueDev'), param('ns3::Ptr< ns3::NetDevice >', 'sourceEnbDev'), param('ns3::Ptr< ns3::NetDevice >', 'targetEnbDev')]) + ## lte-helper.h (module 'lte'): void ns3::LteHelper::HandoverRequest(ns3::Time hoTime, ns3::Ptr ueDev, ns3::Ptr sourceEnbDev, uint16_t targetCellId) [member function] + cls.add_method('HandoverRequest', + 'void', + [param('ns3::Time', 'hoTime'), param('ns3::Ptr< ns3::NetDevice >', 'ueDev'), param('ns3::Ptr< ns3::NetDevice >', 'sourceEnbDev'), param('uint16_t', 'targetCellId')]) ## lte-helper.h (module 'lte'): ns3::NetDeviceContainer ns3::LteHelper::InstallEnbDevice(ns3::NodeContainer c) [member function] cls.add_method('InstallEnbDevice', 'ns3::NetDeviceContainer', @@ -17474,7 +18051,7 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('InstallUeDevice', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')]) - ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetCcPhyParams(std::map, std::allocator > > ccmap) [member function] + ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetCcPhyParams(std::map, std::allocator > > ccmap) [member function] cls.add_method('SetCcPhyParams', 'void', [param('std::map< unsigned char, ns3::ComponentCarrier >', 'ccmap')]) @@ -17530,10 +18107,10 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('SetPathlossModelAttribute', 'void', [param('std::string', 'n'), param('ns3::AttributeValue const &', 'v')]) - ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetPathlossModelType(std::string type) [member function] + ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetPathlossModelType(ns3::TypeId type) [member function] cls.add_method('SetPathlossModelType', 'void', - [param('std::string', 'type')]) + [param('ns3::TypeId', 'type')]) ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetSchedulerAttribute(std::string n, ns3::AttributeValue const & v) [member function] cls.add_method('SetSchedulerAttribute', 'void', @@ -17578,7 +18155,7 @@ def register_Ns3LteHelper_methods(root_module, cls): return def register_Ns3LteHexGridEnbTopologyHelper_methods(root_module, cls): - ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper(ns3::LteHexGridEnbTopologyHelper const & arg0) [copy constructor] + ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper(ns3::LteHexGridEnbTopologyHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteHexGridEnbTopologyHelper const &', 'arg0')]) ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper() [constructor] cls.add_constructor([]) @@ -17603,7 +18180,7 @@ def register_Ns3LteHexGridEnbTopologyHelper_methods(root_module, cls): return def register_Ns3LteInterference_methods(root_module, cls): - ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference(ns3::LteInterference const & arg0) [copy constructor] + ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference(ns3::LteInterference const & arg0) [constructor] cls.add_constructor([param('ns3::LteInterference const &', 'arg0')]) ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference() [constructor] cls.add_constructor([]) @@ -17615,7 +18192,7 @@ def register_Ns3LteInterference_methods(root_module, cls): cls.add_method('AddRsPowerChunkProcessor', 'void', [param('ns3::Ptr< ns3::LteChunkProcessor >', 'p')]) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] cls.add_method('AddSignal', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) @@ -17637,18 +18214,18 @@ def register_Ns3LteInterference_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] cls.add_method('SetNoisePowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::StartRx(ns3::Ptr rxPsd) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::StartRx(ns3::Ptr rxPsd) [member function] cls.add_method('StartRx', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'rxPsd')]) return def register_Ns3LtePdcp_methods(root_module, cls): - ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp(ns3::LtePdcp const & arg0) [copy constructor] + ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp(ns3::LtePdcp const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcp const &', 'arg0')]) ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp() [constructor] cls.add_constructor([]) @@ -17711,7 +18288,7 @@ def register_Ns3LtePdcp_methods(root_module, cls): def register_Ns3LtePdcpStatus_methods(root_module, cls): ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status() [constructor] cls.add_constructor([]) - ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status(ns3::LtePdcp::Status const & arg0) [copy constructor] + ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status(ns3::LtePdcp::Status const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcp::Status const &', 'arg0')]) ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::rxSn [variable] cls.add_instance_attribute('rxSn', 'uint16_t', is_const=False) @@ -17720,7 +18297,7 @@ def register_Ns3LtePdcpStatus_methods(root_module, cls): return def register_Ns3LtePhy_methods(root_module, cls): - ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy(ns3::LtePhy const & arg0) [copy constructor] + ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy(ns3::LtePhy const & arg0) [constructor] cls.add_constructor([param('ns3::LtePhy const &', 'arg0')]) ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy() [constructor] cls.add_constructor([]) @@ -17846,7 +18423,7 @@ def register_Ns3LtePhy_methods(root_module, cls): return def register_Ns3LteRadioBearerInfo_methods(root_module, cls): - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo(ns3::LteRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo(ns3::LteRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo() [constructor] cls.add_constructor([]) @@ -17862,7 +18439,7 @@ def register_Ns3LteRadioBearerInfo_methods(root_module, cls): return def register_Ns3LteRlc_methods(root_module, cls): - ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc(ns3::LteRlc const & arg0) [copy constructor] + ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc(ns3::LteRlc const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlc const &', 'arg0')]) ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc() [constructor] cls.add_constructor([]) @@ -17923,7 +18500,7 @@ def register_Ns3LteRlc_methods(root_module, cls): return def register_Ns3LteRlcAm_methods(root_module, cls): - ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm(ns3::LteRlcAm const & arg0) [copy constructor] + ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm(ns3::LteRlcAm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcAm const &', 'arg0')]) ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm() [constructor] cls.add_constructor([]) @@ -17960,7 +18537,7 @@ def register_Ns3LteRlcAm_methods(root_module, cls): return def register_Ns3LteRlcSm_methods(root_module, cls): - ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm(ns3::LteRlcSm const & arg0) [copy constructor] + ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm(ns3::LteRlcSm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSm const &', 'arg0')]) ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm() [constructor] cls.add_constructor([]) @@ -18002,7 +18579,7 @@ def register_Ns3LteRlcSm_methods(root_module, cls): return def register_Ns3LteRlcTm_methods(root_module, cls): - ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm(ns3::LteRlcTm const & arg0) [copy constructor] + ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm(ns3::LteRlcTm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcTm const &', 'arg0')]) ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm() [constructor] cls.add_constructor([]) @@ -18039,7 +18616,7 @@ def register_Ns3LteRlcTm_methods(root_module, cls): return def register_Ns3LteRlcUm_methods(root_module, cls): - ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm(ns3::LteRlcUm const & arg0) [copy constructor] + ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm(ns3::LteRlcUm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcUm const &', 'arg0')]) ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm() [constructor] cls.add_constructor([]) @@ -18078,7 +18655,7 @@ def register_Ns3LteRlcUm_methods(root_module, cls): def register_Ns3LteSignalingRadioBearerInfo_methods(root_module, cls): ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo() [constructor] cls.add_constructor([]) - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo(ns3::LteSignalingRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo(ns3::LteSignalingRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteSignalingRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): static ns3::TypeId ns3::LteSignalingRadioBearerInfo::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -18129,7 +18706,7 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): 'ns3::Ptr< ns3::NetDevice >', [], is_const=True, is_virtual=True) - ## lte-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::LteSpectrumPhy::GetRxSpectrumModel() const [member function] + ## lte-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::LteSpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -18164,7 +18741,7 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): cls.add_method('SetTxPowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue >', 'txPsd')]) - ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] cls.add_method('SetNoisePowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) @@ -18191,35 +18768,35 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyTxEndCallback(ns3::LtePhyTxEndCallback c) [member function] cls.add_method('SetLtePhyTxEndCallback', 'void', - [param('ns3::LtePhyTxEndCallback', 'c')]) + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxDataEndErrorCallback(ns3::LtePhyRxDataEndErrorCallback c) [member function] cls.add_method('SetLtePhyRxDataEndErrorCallback', 'void', - [param('ns3::LtePhyRxDataEndErrorCallback', 'c')]) + [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxDataEndOkCallback(ns3::LtePhyRxDataEndOkCallback c) [member function] cls.add_method('SetLtePhyRxDataEndOkCallback', 'void', - [param('ns3::LtePhyRxDataEndOkCallback', 'c')]) + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxCtrlEndOkCallback(ns3::LtePhyRxCtrlEndOkCallback c) [member function] cls.add_method('SetLtePhyRxCtrlEndOkCallback', 'void', - [param('ns3::LtePhyRxCtrlEndOkCallback', 'c')]) + [param('ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxCtrlEndErrorCallback(ns3::LtePhyRxCtrlEndErrorCallback c) [member function] cls.add_method('SetLtePhyRxCtrlEndErrorCallback', 'void', - [param('ns3::LtePhyRxCtrlEndErrorCallback', 'c')]) + [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxPssCallback(ns3::LtePhyRxPssCallback c) [member function] cls.add_method('SetLtePhyRxPssCallback', 'void', - [param('ns3::LtePhyRxPssCallback', 'c')]) + [param('ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyDlHarqFeedbackCallback(ns3::LtePhyDlHarqFeedbackCallback c) [member function] cls.add_method('SetLtePhyDlHarqFeedbackCallback', 'void', - [param('ns3::LtePhyDlHarqFeedbackCallback', 'c')]) + [param('ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyUlHarqFeedbackCallback(ns3::LtePhyUlHarqFeedbackCallback c) [member function] cls.add_method('SetLtePhyUlHarqFeedbackCallback', 'void', - [param('ns3::LtePhyUlHarqFeedbackCallback', 'c')]) + [param('ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetState(ns3::LteSpectrumPhy::State newState) [member function] cls.add_method('SetState', 'void', @@ -18279,71 +18856,71 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): return def register_Ns3LteSpectrumSignalParameters_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters(ns3::LteSpectrumSignalParameters const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParameters const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters(ns3::LteSpectrumSignalParameters const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParameters const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::packetBurst [variable] cls.add_instance_attribute('packetBurst', 'ns3::Ptr< ns3::PacketBurst >', is_const=False) return def register_Ns3LteSpectrumSignalParametersDataFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame(ns3::LteSpectrumSignalParametersDataFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersDataFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersDataFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::cellId [variable] - cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::ctrlMsgList [variable] - cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame(ns3::LteSpectrumSignalParametersDataFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersDataFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::packetBurst [variable] cls.add_instance_attribute('packetBurst', 'ns3::Ptr< ns3::PacketBurst >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::ctrlMsgList [variable] + cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::cellId [variable] + cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) return def register_Ns3LteSpectrumSignalParametersDlCtrlFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame(ns3::LteSpectrumSignalParametersDlCtrlFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersDlCtrlFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersDlCtrlFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::cellId [variable] - cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame(ns3::LteSpectrumSignalParametersDlCtrlFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersDlCtrlFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::ctrlMsgList [variable] cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::cellId [variable] + cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::pss [variable] cls.add_instance_attribute('pss', 'bool', is_const=False) return def register_Ns3LteSpectrumSignalParametersUlSrsFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame(ns3::LteSpectrumSignalParametersUlSrsFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersUlSrsFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersUlSrsFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame(ns3::LteSpectrumSignalParametersUlSrsFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersUlSrsFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::cellId [variable] cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) return def register_Ns3LteStatsCalculator_methods(root_module, cls): - ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator(ns3::LteStatsCalculator const & arg0) [copy constructor] + ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator(ns3::LteStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::LteStatsCalculator const &', 'arg0')]) ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator() [constructor] cls.add_constructor([]) @@ -18435,7 +19012,7 @@ def register_Ns3LteStatsCalculator_methods(root_module, cls): return def register_Ns3LteUeComponentCarrierManager_methods(root_module, cls): - ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager(ns3::LteUeComponentCarrierManager const & arg0) [copy constructor] + ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager(ns3::LteUeComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeComponentCarrierManager const &', 'arg0')]) ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -18475,7 +19052,7 @@ def register_Ns3LteUeComponentCarrierManager_methods(root_module, cls): return def register_Ns3LteUeMac_methods(root_module, cls): - ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac(ns3::LteUeMac const & arg0) [copy constructor] + ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac(ns3::LteUeMac const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeMac const &', 'arg0')]) ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac() [constructor] cls.add_constructor([]) @@ -18524,7 +19101,7 @@ def register_Ns3LteUeMac_methods(root_module, cls): return def register_Ns3LteUePhy_methods(root_module, cls): - ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy(ns3::LteUePhy const & arg0) [copy constructor] + ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy(ns3::LteUePhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhy const &', 'arg0')]) ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy() [constructor] cls.add_constructor([]) @@ -18624,10 +19201,10 @@ def register_Ns3LteUePhy_methods(root_module, cls): cls.add_method('PhyPduReceived', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')]) - ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteControlMessageList(std::list, std::allocator > > arg0) [member function] + ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteControlMessageList(std::list, std::allocator > > msgList) [member function] cls.add_method('ReceiveLteControlMessageList', 'void', - [param('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'arg0')], + [param('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'msgList')], is_virtual=True) ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteDlHarqFeedback(ns3::DlInfoListElement_s mes) [member function] cls.add_method('ReceiveLteDlHarqFeedback', @@ -18708,7 +19285,7 @@ def register_Ns3LteUePhy_methods(root_module, cls): return def register_Ns3LteUePowerControl_methods(root_module, cls): - ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl(ns3::LteUePowerControl const & arg0) [copy constructor] + ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl(ns3::LteUePowerControl const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePowerControl const &', 'arg0')]) ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl() [constructor] cls.add_constructor([]) @@ -18798,7 +19375,7 @@ def register_Ns3LteUePowerControl_methods(root_module, cls): return def register_Ns3LteUeRrc_methods(root_module, cls): - ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc(ns3::LteUeRrc const & arg0) [copy constructor] + ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc(ns3::LteUeRrc const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrc const &', 'arg0')]) ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc() [constructor] cls.add_constructor([]) @@ -18934,7 +19511,7 @@ def register_Ns3LteUeRrc_methods(root_module, cls): return def register_Ns3LteUeRrcProtocolIdeal_methods(root_module, cls): - ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal(ns3::LteUeRrcProtocolIdeal const & arg0) [copy constructor] + ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal(ns3::LteUeRrcProtocolIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcProtocolIdeal const &', 'arg0')]) ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal() [constructor] cls.add_constructor([]) @@ -18963,7 +19540,7 @@ def register_Ns3LteUeRrcProtocolIdeal_methods(root_module, cls): return def register_Ns3LteUeRrcProtocolReal_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal(ns3::LteUeRrcProtocolReal const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal(ns3::LteUeRrcProtocolReal const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcProtocolReal const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal() [constructor] cls.add_constructor([]) @@ -18994,23 +19571,23 @@ def register_Ns3LteUeRrcProtocolReal_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19020,7 +19597,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19032,7 +19609,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): return def register_Ns3MacStatsCalculator_methods(root_module, cls): - ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator(ns3::MacStatsCalculator const & arg0) [copy constructor] + ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator(ns3::MacStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::MacStatsCalculator const &', 'arg0')]) ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator() [constructor] cls.add_constructor([]) @@ -19078,7 +19655,7 @@ def register_Ns3MacStatsCalculator_methods(root_module, cls): return def register_Ns3MibLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage(ns3::MibLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage(ns3::MibLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::MibLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage() [constructor] cls.add_constructor([]) @@ -19093,75 +19670,215 @@ def register_Ns3MibLteControlMessage_methods(root_module, cls): [param('ns3::LteRrcSap::MasterInformationBlock', 'mib')]) return -def register_Ns3MobilityModel_methods(root_module, cls): - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor] - cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] +def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls): + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] + cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) - ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::AssignStreams(int64_t stream) [member function] - cls.add_method('AssignStreams', - 'int64_t', - [param('int64_t', 'stream')]) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] - cls.add_method('GetDistanceFrom', - 'double', - [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], - is_const=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetPosition() const [member function] - cls.add_method('GetPosition', - 'ns3::Vector', - [], - is_const=True) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] - cls.add_method('GetRelativeSpeed', - 'double', - [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], - is_const=True) - ## mobility-model.h (module 'mobility'): static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function] + ## basic-data-calculators.h (module 'stats'): static ns3::TypeId ns3::MinMaxAvgTotalCalculator::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetVelocity() const [member function] - cls.add_method('GetVelocity', - 'ns3::Vector', - [], - is_const=True) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function] - cls.add_method('SetPosition', + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function] + cls.add_method('Output', 'void', - [param('ns3::Vector const &', 'position')]) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::NotifyCourseChange() const [member function] - cls.add_method('NotifyCourseChange', + [param('ns3::DataOutputCallback &', 'callback')], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Reset() [member function] + cls.add_method('Reset', + 'void', + []) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Update(unsigned int const i) [member function] + cls.add_method('Update', 'void', + [param('unsigned int const', 'i')]) + ## basic-data-calculators.h (module 'stats'): long int ns3::MinMaxAvgTotalCalculator::getCount() const [member function] + cls.add_method('getCount', + 'long int', [], - is_const=True, visibility='protected') - ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::DoAssignStreams(int64_t start) [member function] - cls.add_method('DoAssignStreams', - 'int64_t', - [param('int64_t', 'start')], - visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function] - cls.add_method('DoGetPosition', - 'ns3::Vector', + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMax() const [member function] + cls.add_method('getMax', + 'double', [], - is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function] - cls.add_method('DoGetVelocity', - 'ns3::Vector', + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMean() const [member function] + cls.add_method('getMean', + 'double', [], - is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function] - cls.add_method('DoSetPosition', - 'void', - [param('ns3::Vector const &', 'position')], - is_pure_virtual=True, visibility='private', is_virtual=True) - return - -def register_Ns3NetDevice_methods(root_module, cls): - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] - cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMin() const [member function] + cls.add_method('getMin', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSqrSum() const [member function] + cls.add_method('getSqrSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getStddev() const [member function] + cls.add_method('getStddev', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSum() const [member function] + cls.add_method('getSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getVariance() const [member function] + cls.add_method('getVariance', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3MinMaxAvgTotalCalculator__Unsigned_long_methods(root_module, cls): + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] + cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned long > const &', 'arg0')]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] + cls.add_constructor([]) + ## basic-data-calculators.h (module 'stats'): static ns3::TypeId ns3::MinMaxAvgTotalCalculator::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function] + cls.add_method('Output', + 'void', + [param('ns3::DataOutputCallback &', 'callback')], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Reset() [member function] + cls.add_method('Reset', + 'void', + []) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Update(long unsigned int const i) [member function] + cls.add_method('Update', + 'void', + [param('long unsigned int const', 'i')]) + ## basic-data-calculators.h (module 'stats'): long int ns3::MinMaxAvgTotalCalculator::getCount() const [member function] + cls.add_method('getCount', + 'long int', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMax() const [member function] + cls.add_method('getMax', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMean() const [member function] + cls.add_method('getMean', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMin() const [member function] + cls.add_method('getMin', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSqrSum() const [member function] + cls.add_method('getSqrSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getStddev() const [member function] + cls.add_method('getStddev', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSum() const [member function] + cls.add_method('getSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getVariance() const [member function] + cls.add_method('getVariance', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3MobilityModel_methods(root_module, cls): + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [constructor] + cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] + cls.add_constructor([]) + ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::AssignStreams(int64_t stream) [member function] + cls.add_method('AssignStreams', + 'int64_t', + [param('int64_t', 'stream')]) + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] + cls.add_method('GetDistanceFrom', + 'double', + [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], + is_const=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetPosition() const [member function] + cls.add_method('GetPosition', + 'ns3::Vector', + [], + is_const=True) + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] + cls.add_method('GetRelativeSpeed', + 'double', + [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], + is_const=True) + ## mobility-model.h (module 'mobility'): static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetVelocity() const [member function] + cls.add_method('GetVelocity', + 'ns3::Vector', + [], + is_const=True) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function] + cls.add_method('SetPosition', + 'void', + [param('ns3::Vector const &', 'position')]) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::NotifyCourseChange() const [member function] + cls.add_method('NotifyCourseChange', + 'void', + [], + is_const=True, visibility='protected') + ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::DoAssignStreams(int64_t start) [member function] + cls.add_method('DoAssignStreams', + 'int64_t', + [param('int64_t', 'start')], + visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', + 'ns3::Vector', + [], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', + 'ns3::Vector', + [], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', + 'void', + [param('ns3::Vector const &', 'position')], + is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3NetDevice_methods(root_module, cls): + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] + cls.add_constructor([]) + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -19273,12 +19990,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -19294,7 +20011,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -19335,7 +20052,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3NoOpComponentCarrierManager_methods(root_module, cls): - ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager(ns3::NoOpComponentCarrierManager const & arg0) [copy constructor] + ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager(ns3::NoOpComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::NoOpComponentCarrierManager const &', 'arg0')]) ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -19427,7 +20144,7 @@ def register_Ns3NoOpComponentCarrierManager_methods(root_module, cls): return def register_Ns3NoOpHandoverAlgorithm_methods(root_module, cls): - ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm(ns3::NoOpHandoverAlgorithm const & arg0) [copy constructor] + ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm(ns3::NoOpHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::NoOpHandoverAlgorithm const &', 'arg0')]) ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -19464,7 +20181,7 @@ def register_Ns3NoOpHandoverAlgorithm_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -19523,19 +20240,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -19599,23 +20316,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19625,7 +20342,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19640,7 +20357,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -19833,7 +20550,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -19870,7 +20587,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): return def register_Ns3PfFfMacScheduler_methods(root_module, cls): - ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler(ns3::PfFfMacScheduler const & arg0) [copy constructor] + ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler(ns3::PfFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::PfFfMacScheduler const &', 'arg0')]) ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler() [constructor] cls.add_constructor([]) @@ -19921,7 +20638,7 @@ def register_Ns3PfFfMacScheduler_methods(root_module, cls): return def register_Ns3PhyRxStatsCalculator_methods(root_module, cls): - ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator(ns3::PhyRxStatsCalculator const & arg0) [copy constructor] + ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator(ns3::PhyRxStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyRxStatsCalculator const &', 'arg0')]) ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator() [constructor] cls.add_constructor([]) @@ -19967,7 +20684,7 @@ def register_Ns3PhyRxStatsCalculator_methods(root_module, cls): return def register_Ns3PhyStatsCalculator_methods(root_module, cls): - ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator(ns3::PhyStatsCalculator const & arg0) [copy constructor] + ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator(ns3::PhyStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyStatsCalculator const &', 'arg0')]) ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator() [constructor] cls.add_constructor([]) @@ -20030,7 +20747,7 @@ def register_Ns3PhyStatsCalculator_methods(root_module, cls): return def register_Ns3PhyTxStatsCalculator_methods(root_module, cls): - ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator(ns3::PhyTxStatsCalculator const & arg0) [copy constructor] + ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator(ns3::PhyTxStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyTxStatsCalculator const &', 'arg0')]) ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator() [constructor] cls.add_constructor([]) @@ -20076,7 +20793,7 @@ def register_Ns3PhyTxStatsCalculator_methods(root_module, cls): return def register_Ns3PointToPointEpcHelper_methods(root_module, cls): - ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper(ns3::PointToPointEpcHelper const & arg0) [copy constructor] + ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper(ns3::PointToPointEpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PointToPointEpcHelper const &', 'arg0')]) ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper() [constructor] cls.add_constructor([]) @@ -20130,7 +20847,7 @@ def register_Ns3PointToPointEpcHelper_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -20140,7 +20857,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -20151,7 +20868,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -20161,7 +20878,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -20173,7 +20890,7 @@ def register_Ns3PointerValue_methods(root_module, cls): return def register_Ns3PssFfMacScheduler_methods(root_module, cls): - ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler(ns3::PssFfMacScheduler const & arg0) [copy constructor] + ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler(ns3::PssFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::PssFfMacScheduler const &', 'arg0')]) ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler() [constructor] cls.add_constructor([]) @@ -20224,7 +20941,7 @@ def register_Ns3PssFfMacScheduler_methods(root_module, cls): return def register_Ns3RachPreambleLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage(ns3::RachPreambleLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage(ns3::RachPreambleLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RachPreambleLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage() [constructor] cls.add_constructor([]) @@ -20240,7 +20957,7 @@ def register_Ns3RachPreambleLteControlMessage_methods(root_module, cls): return def register_Ns3RadioBearerStatsCalculator_methods(root_module, cls): - ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator(ns3::RadioBearerStatsCalculator const & arg0) [copy constructor] + ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator(ns3::RadioBearerStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::RadioBearerStatsCalculator const &', 'arg0')]) ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator() [constructor] cls.add_constructor([]) @@ -20381,7 +21098,7 @@ def register_Ns3RadioBearerStatsCalculator_methods(root_module, cls): return def register_Ns3RarLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage(ns3::RarLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage(ns3::RarLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RarLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage() [constructor] cls.add_constructor([]) @@ -20394,14 +21111,14 @@ def register_Ns3RarLteControlMessage_methods(root_module, cls): 'uint16_t', [], is_const=True) - ## lte-control-messages.h (module 'lte'): std::_List_const_iterator ns3::RarLteControlMessage::RarListBegin() const [member function] + ## lte-control-messages.h (module 'lte'): std::list >::const_iterator ns3::RarLteControlMessage::RarListBegin() const [member function] cls.add_method('RarListBegin', - 'std::_List_const_iterator< ns3::RarLteControlMessage::Rar >', + 'std::list< ns3::RarLteControlMessage::Rar > const_iterator', [], is_const=True) - ## lte-control-messages.h (module 'lte'): std::_List_const_iterator ns3::RarLteControlMessage::RarListEnd() const [member function] + ## lte-control-messages.h (module 'lte'): std::list >::const_iterator ns3::RarLteControlMessage::RarListEnd() const [member function] cls.add_method('RarListEnd', - 'std::_List_const_iterator< ns3::RarLteControlMessage::Rar >', + 'std::list< ns3::RarLteControlMessage::Rar > const_iterator', [], is_const=True) ## lte-control-messages.h (module 'lte'): void ns3::RarLteControlMessage::SetRaRnti(uint16_t raRnti) [member function] @@ -20413,7 +21130,7 @@ def register_Ns3RarLteControlMessage_methods(root_module, cls): def register_Ns3RarLteControlMessageRar_methods(root_module, cls): ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar(ns3::RarLteControlMessage::Rar const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar(ns3::RarLteControlMessage::Rar const & arg0) [constructor] cls.add_constructor([param('ns3::RarLteControlMessage::Rar const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::rapId [variable] cls.add_instance_attribute('rapId', 'uint8_t', is_const=False) @@ -20459,7 +21176,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): 'ns3::Ptr< ns3::NetDevice >', [], is_const=True, is_virtual=True) - ## rem-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::RemSpectrumPhy::GetRxSpectrumModel() const [member function] + ## rem-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::RemSpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -20474,7 +21191,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::SpectrumSignalParameters >', 'params')], is_virtual=True) - ## rem-spectrum-phy.h (module 'lte'): void ns3::RemSpectrumPhy::SetRxSpectrumModel(ns3::Ptr m) [member function] + ## rem-spectrum-phy.h (module 'lte'): void ns3::RemSpectrumPhy::SetRxSpectrumModel(ns3::Ptr m) [member function] cls.add_method('SetRxSpectrumModel', 'void', [param('ns3::Ptr< ns3::SpectrumModel const >', 'm')]) @@ -20505,7 +21222,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): return def register_Ns3RrComponentCarrierManager_methods(root_module, cls): - ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager(ns3::RrComponentCarrierManager const & arg0) [copy constructor] + ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager(ns3::RrComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::RrComponentCarrierManager const &', 'arg0')]) ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -20527,7 +21244,7 @@ def register_Ns3RrComponentCarrierManager_methods(root_module, cls): return def register_Ns3RrFfMacScheduler_methods(root_module, cls): - ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler(ns3::RrFfMacScheduler const & arg0) [copy constructor] + ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler(ns3::RrFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::RrFfMacScheduler const &', 'arg0')]) ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler() [constructor] cls.add_constructor([]) @@ -20578,7 +21295,7 @@ def register_Ns3RrFfMacScheduler_methods(root_module, cls): return def register_Ns3RrcAsn1Header_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header(ns3::RrcAsn1Header const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header(ns3::RrcAsn1Header const & arg0) [constructor] cls.add_constructor([param('ns3::RrcAsn1Header const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header() [constructor] cls.add_constructor([]) @@ -20814,7 +21531,7 @@ def register_Ns3RrcAsn1Header_methods(root_module, cls): return def register_Ns3RrcDlCcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage(ns3::RrcDlCcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage(ns3::RrcDlCcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcDlCcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage() [constructor] cls.add_constructor([]) @@ -20846,7 +21563,7 @@ def register_Ns3RrcDlCcchMessage_methods(root_module, cls): return def register_Ns3RrcDlDcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage(ns3::RrcDlDcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage(ns3::RrcDlDcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcDlDcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage() [constructor] cls.add_constructor([]) @@ -20878,7 +21595,7 @@ def register_Ns3RrcDlDcchMessage_methods(root_module, cls): return def register_Ns3RrcUlCcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage(ns3::RrcUlCcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage(ns3::RrcUlCcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcUlCcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage() [constructor] cls.add_constructor([]) @@ -20910,7 +21627,7 @@ def register_Ns3RrcUlCcchMessage_methods(root_module, cls): return def register_Ns3RrcUlDcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage(ns3::RrcUlDcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage(ns3::RrcUlDcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcUlDcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage() [constructor] cls.add_constructor([]) @@ -20942,7 +21659,7 @@ def register_Ns3RrcUlDcchMessage_methods(root_module, cls): return def register_Ns3Sib1LteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage(ns3::Sib1LteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage(ns3::Sib1LteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::Sib1LteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage() [constructor] cls.add_constructor([]) @@ -20958,7 +21675,7 @@ def register_Ns3Sib1LteControlMessage_methods(root_module, cls): return def register_Ns3SimpleUeComponentCarrierManager_methods(root_module, cls): - ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager(ns3::SimpleUeComponentCarrierManager const & arg0) [copy constructor] + ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager(ns3::SimpleUeComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleUeComponentCarrierManager const &', 'arg0')]) ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -21047,7 +21764,7 @@ def register_Ns3SimpleUeComponentCarrierManager_methods(root_module, cls): def register_Ns3SpectrumChannel_methods(root_module, cls): ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel() [constructor] cls.add_constructor([]) - ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [copy constructor] + ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumChannel const &', 'arg0')]) ## spectrum-channel.h (module 'spectrum'): void ns3::SpectrumChannel::AddPropagationLossModel(ns3::Ptr loss) [member function] cls.add_method('AddPropagationLossModel', @@ -21082,7 +21799,7 @@ def register_Ns3SpectrumChannel_methods(root_module, cls): return def register_Ns3SrsCqiRntiVsp_methods(root_module, cls): - ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(ns3::SrsCqiRntiVsp const & arg0) [copy constructor] + ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(ns3::SrsCqiRntiVsp const & arg0) [constructor] cls.add_constructor([param('ns3::SrsCqiRntiVsp const &', 'arg0')]) ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(uint16_t rnti) [constructor] cls.add_constructor([param('uint16_t', 'rnti')]) @@ -21095,23 +21812,23 @@ def register_Ns3SrsCqiRntiVsp_methods(root_module, cls): def register_Ns3StringChecker_methods(root_module, cls): ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [constructor] cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) return def register_Ns3StringValue_methods(root_module, cls): ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21121,7 +21838,7 @@ def register_Ns3StringValue_methods(root_module, cls): 'std::string', [], is_const=True) - ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21133,7 +21850,7 @@ def register_Ns3StringValue_methods(root_module, cls): return def register_Ns3TdBetFfMacScheduler_methods(root_module, cls): - ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler(ns3::TdBetFfMacScheduler const & arg0) [copy constructor] + ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler(ns3::TdBetFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdBetFfMacScheduler const &', 'arg0')]) ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21184,7 +21901,7 @@ def register_Ns3TdBetFfMacScheduler_methods(root_module, cls): return def register_Ns3TdMtFfMacScheduler_methods(root_module, cls): - ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler(ns3::TdMtFfMacScheduler const & arg0) [copy constructor] + ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler(ns3::TdMtFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdMtFfMacScheduler const &', 'arg0')]) ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21235,7 +21952,7 @@ def register_Ns3TdMtFfMacScheduler_methods(root_module, cls): return def register_Ns3TdTbfqFfMacScheduler_methods(root_module, cls): - ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler(ns3::TdTbfqFfMacScheduler const & arg0) [copy constructor] + ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler(ns3::TdTbfqFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdTbfqFfMacScheduler const &', 'arg0')]) ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21288,16 +22005,16 @@ def register_Ns3TdTbfqFfMacScheduler_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21307,7 +22024,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21319,7 +22036,7 @@ def register_Ns3TimeValue_methods(root_module, cls): return def register_Ns3TtaFfMacScheduler_methods(root_module, cls): - ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler(ns3::TtaFfMacScheduler const & arg0) [copy constructor] + ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler(ns3::TtaFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TtaFfMacScheduler const &', 'arg0')]) ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21372,23 +22089,23 @@ def register_Ns3TtaFfMacScheduler_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21398,7 +22115,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21412,16 +22129,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21431,7 +22148,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21443,7 +22160,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): return def register_Ns3UlDciLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage(ns3::UlDciLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage(ns3::UlDciLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::UlDciLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage() [constructor] cls.add_constructor([]) @@ -21460,23 +22177,23 @@ def register_Ns3UlDciLteControlMessage_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21486,7 +22203,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21500,23 +22217,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21526,7 +22243,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21538,7 +22255,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): return def register_Ns3VirtualNetDevice_methods(root_module, cls): - ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice(ns3::VirtualNetDevice const & arg0) [copy constructor] + ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice(ns3::VirtualNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::VirtualNetDevice const &', 'arg0')]) ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice() [constructor] cls.add_constructor([]) @@ -21664,17 +22381,17 @@ def register_Ns3VirtualNetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetSendCallback(ns3::Callback, ns3::Address const&, ns3::Address const&, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> transmitCb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetSendCallback(ns3::VirtualNetDevice::SendCallback transmitCb) [member function] cls.add_method('SetSendCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::Address const &, ns3::Address const &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'transmitCb')]) @@ -21695,7 +22412,7 @@ def register_Ns3VirtualNetDevice_methods(root_module, cls): return def register_Ns3A2A4RsrqHandoverAlgorithm_methods(root_module, cls): - ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm(ns3::A2A4RsrqHandoverAlgorithm const & arg0) [copy constructor] + ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm(ns3::A2A4RsrqHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::A2A4RsrqHandoverAlgorithm const &', 'arg0')]) ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -21732,7 +22449,7 @@ def register_Ns3A2A4RsrqHandoverAlgorithm_methods(root_module, cls): return def register_Ns3A3RsrpHandoverAlgorithm_methods(root_module, cls): - ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm(ns3::A3RsrpHandoverAlgorithm const & arg0) [copy constructor] + ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm(ns3::A3RsrpHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::A3RsrpHandoverAlgorithm const &', 'arg0')]) ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -21771,23 +22488,23 @@ def register_Ns3A3RsrpHandoverAlgorithm_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21797,7 +22514,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21809,7 +22526,7 @@ def register_Ns3AddressValue_methods(root_module, cls): return def register_Ns3BsrLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage(ns3::BsrLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage(ns3::BsrLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::BsrLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage() [constructor] cls.add_constructor([]) @@ -21823,89 +22540,881 @@ def register_Ns3BsrLteControlMessage_methods(root_module, cls): [param('ns3::MacCeListElement_s', 'bsr')]) return -def register_Ns3CqaFfMacScheduler_methods(root_module, cls): - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler(ns3::CqaFfMacScheduler const & arg0) [copy constructor] - cls.add_constructor([param('ns3::CqaFfMacScheduler const &', 'arg0')]) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler() [constructor] +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] cls.add_constructor([]) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::DoDispose() [member function] - cls.add_method('DoDispose', - 'void', + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacCschedSapProvider * ns3::CqaFfMacScheduler::GetFfMacCschedSapProvider() [member function] - cls.add_method('GetFfMacCschedSapProvider', - 'ns3::FfMacCschedSapProvider *', + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacSchedSapProvider * ns3::CqaFfMacScheduler::GetFfMacSchedSapProvider() [member function] - cls.add_method('GetFfMacSchedSapProvider', - 'ns3::FfMacSchedSapProvider *', + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::LteFfrSapUser * ns3::CqaFfMacScheduler::GetLteFfrSapUser() [member function] - cls.add_method('GetLteFfrSapUser', - 'ns3::LteFfrSapUser *', + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): static ns3::TypeId ns3::CqaFfMacScheduler::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Packet__gt___Const_ns3Address___amp___Const_ns3Address___amp___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Packet >, ns3::Address const &, ns3::Address const &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], is_static=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacCschedSapUser(ns3::FfMacCschedSapUser * s) [member function] - cls.add_method('SetFfMacCschedSapUser', - 'void', - [param('ns3::FfMacCschedSapUser *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacSchedSapUser(ns3::FfMacSchedSapUser * s) [member function] - cls.add_method('SetFfMacSchedSapUser', - 'void', - [param('ns3::FfMacSchedSapUser *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetLteFfrSapProvider(ns3::LteFfrSapProvider * s) [member function] - cls.add_method('SetLteFfrSapProvider', - 'void', - [param('ns3::LteFfrSapProvider *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::TransmissionModeConfigurationUpdate(uint16_t rnti, uint8_t txMode) [member function] - cls.add_method('TransmissionModeConfigurationUpdate', - 'void', - [param('uint16_t', 'rnti'), param('uint8_t', 'txMode')]) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1, ns3::Address const & arg2, short unsigned int arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::Address const &', 'arg1'), param('ns3::Address const &', 'arg2'), param('short unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') return -def register_Ns3DlCqiLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage(ns3::DlCqiLteControlMessage const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlCqiLteControlMessage const &', 'arg0')]) - ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage() [constructor] +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::CqiListElement_s ns3::DlCqiLteControlMessage::GetDlCqi() [member function] - cls.add_method('GetDlCqi', - 'ns3::CqiListElement_s', - []) - ## lte-control-messages.h (module 'lte'): void ns3::DlCqiLteControlMessage::SetDlCqi(ns3::CqiListElement_s dlcqi) [member function] - cls.add_method('SetDlCqi', - 'void', - [param('ns3::CqiListElement_s', 'dlcqi')]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') return -def register_Ns3DlDciLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage(ns3::DlDciLteControlMessage const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlDciLteControlMessage const &', 'arg0')]) - ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage() [constructor] +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::DlDciListElement_s ns3::DlDciLteControlMessage::GetDci() [member function] - cls.add_method('GetDci', - 'ns3::DlDciListElement_s', - []) - ## lte-control-messages.h (module 'lte'): void ns3::DlDciLteControlMessage::SetDci(ns3::DlDciListElement_s dci) [member function] - cls.add_method('SetDci', - 'void', + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Const_ns3SpectrumValue___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::SpectrumValue const & arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::SpectrumValue const &', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3DlSchedulingCallbackInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::DlSchedulingCallbackInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::DlSchedulingCallbackInfo arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::DlSchedulingCallbackInfo', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3EpcUeNasState_Ns3EpcUeNasState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::EpcUeNas::State, ns3::EpcUeNas::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::EpcUeNas::State arg0, ns3::EpcUeNas::State arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::EpcUeNas::State', 'arg0'), param('ns3::EpcUeNas::State', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3PhyReceptionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::PhyReceptionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::PhyReceptionStatParameters arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::PhyReceptionStatParameters', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3PhyTransmissionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::PhyTransmissionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::PhyTransmissionStatParameters arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::PhyTransmissionStatParameters', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::MobilityModel const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::MobilityModel const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3PacketBurst__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::PacketBurst const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, unsigned short, unsigned char, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned int arg0, unsigned int arg1, short unsigned int arg2, unsigned char arg3, short unsigned int arg4, unsigned char arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned int', 'arg0'), param('unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('unsigned char', 'arg3'), param('short unsigned int', 'arg4'), param('unsigned char', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteRrcSapMeasurementReport_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteRrcSap::MeasurementReport, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::LteRrcSap::MeasurementReport arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::LteRrcSap::MeasurementReport', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteUeRrcState_Ns3LteUeRrcState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::LteUeRrc::State, ns3::LteUeRrc::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::LteUeRrc::State arg3, ns3::LteUeRrc::State arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::LteUeRrc::State', 'arg3'), param('ns3::LteUeRrc::State', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3UeManagerState_Ns3UeManagerState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::UeManager::State, ns3::UeManager::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::UeManager::State arg3, ns3::UeManager::State arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::UeManager::State', 'arg3'), param('ns3::UeManager::State', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long, unsigned short, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, short unsigned int arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('short unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Ns3Ptr__lt__ns3SpectrumValue__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(short unsigned int arg0, ns3::Ptr arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('ns3::Ptr< ns3::SpectrumValue >', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, unsigned char arg1, unsigned int arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('unsigned char', 'arg1'), param('unsigned int', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, unsigned char arg1, unsigned int arg2, long unsigned int arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('unsigned char', 'arg1'), param('unsigned int', 'arg2'), param('long unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Bool_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, bool, unsigned char, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, double arg3, bool arg4, unsigned char arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('double', 'arg3'), param('bool', 'arg4'), param('unsigned char', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, double arg3, unsigned char arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('double', 'arg3'), param('unsigned char', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, unsigned char arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('unsigned char', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3LteUePhyState_Ns3LteUePhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::LteUePhy::State, ns3::LteUePhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, ns3::LteUePhy::State arg2, ns3::LteUePhy::State arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('ns3::LteUePhy::State', 'arg2'), param('ns3::LteUePhy::State', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CqaFfMacScheduler_methods(root_module, cls): + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler(ns3::CqaFfMacScheduler const & arg0) [constructor] + cls.add_constructor([param('ns3::CqaFfMacScheduler const &', 'arg0')]) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler() [constructor] + cls.add_constructor([]) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacCschedSapProvider * ns3::CqaFfMacScheduler::GetFfMacCschedSapProvider() [member function] + cls.add_method('GetFfMacCschedSapProvider', + 'ns3::FfMacCschedSapProvider *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacSchedSapProvider * ns3::CqaFfMacScheduler::GetFfMacSchedSapProvider() [member function] + cls.add_method('GetFfMacSchedSapProvider', + 'ns3::FfMacSchedSapProvider *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::LteFfrSapUser * ns3::CqaFfMacScheduler::GetLteFfrSapUser() [member function] + cls.add_method('GetLteFfrSapUser', + 'ns3::LteFfrSapUser *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): static ns3::TypeId ns3::CqaFfMacScheduler::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacCschedSapUser(ns3::FfMacCschedSapUser * s) [member function] + cls.add_method('SetFfMacCschedSapUser', + 'void', + [param('ns3::FfMacCschedSapUser *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacSchedSapUser(ns3::FfMacSchedSapUser * s) [member function] + cls.add_method('SetFfMacSchedSapUser', + 'void', + [param('ns3::FfMacSchedSapUser *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetLteFfrSapProvider(ns3::LteFfrSapProvider * s) [member function] + cls.add_method('SetLteFfrSapProvider', + 'void', + [param('ns3::LteFfrSapProvider *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::TransmissionModeConfigurationUpdate(uint16_t rnti, uint8_t txMode) [member function] + cls.add_method('TransmissionModeConfigurationUpdate', + 'void', + [param('uint16_t', 'rnti'), param('uint8_t', 'txMode')]) + return + +def register_Ns3DlCqiLteControlMessage_methods(root_module, cls): + ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage(ns3::DlCqiLteControlMessage const & arg0) [constructor] + cls.add_constructor([param('ns3::DlCqiLteControlMessage const &', 'arg0')]) + ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage() [constructor] + cls.add_constructor([]) + ## lte-control-messages.h (module 'lte'): ns3::CqiListElement_s ns3::DlCqiLteControlMessage::GetDlCqi() [member function] + cls.add_method('GetDlCqi', + 'ns3::CqiListElement_s', + []) + ## lte-control-messages.h (module 'lte'): void ns3::DlCqiLteControlMessage::SetDlCqi(ns3::CqiListElement_s dlcqi) [member function] + cls.add_method('SetDlCqi', + 'void', + [param('ns3::CqiListElement_s', 'dlcqi')]) + return + +def register_Ns3DlDciLteControlMessage_methods(root_module, cls): + ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage(ns3::DlDciLteControlMessage const & arg0) [constructor] + cls.add_constructor([param('ns3::DlDciLteControlMessage const &', 'arg0')]) + ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage() [constructor] + cls.add_constructor([]) + ## lte-control-messages.h (module 'lte'): ns3::DlDciListElement_s ns3::DlDciLteControlMessage::GetDci() [member function] + cls.add_method('GetDci', + 'ns3::DlDciListElement_s', + []) + ## lte-control-messages.h (module 'lte'): void ns3::DlDciLteControlMessage::SetDci(ns3::DlDciListElement_s dci) [member function] + cls.add_method('SetDci', + 'void', [param('ns3::DlDciListElement_s', 'dci')]) return def register_Ns3DlHarqFeedbackLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage(ns3::DlHarqFeedbackLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage(ns3::DlHarqFeedbackLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::DlHarqFeedbackLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage() [constructor] cls.add_constructor([]) @@ -21920,7 +23429,7 @@ def register_Ns3DlHarqFeedbackLteControlMessage_methods(root_module, cls): return def register_Ns3EmuEpcHelper_methods(root_module, cls): - ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper(ns3::EmuEpcHelper const & arg0) [copy constructor] + ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper(ns3::EmuEpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EmuEpcHelper const &', 'arg0')]) ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper() [constructor] cls.add_constructor([]) @@ -21977,7 +23486,7 @@ def register_Ns3EmuEpcHelper_methods(root_module, cls): return def register_Ns3FdBetFfMacScheduler_methods(root_module, cls): - ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler(ns3::FdBetFfMacScheduler const & arg0) [copy constructor] + ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler(ns3::FdBetFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdBetFfMacScheduler const &', 'arg0')]) ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22028,7 +23537,7 @@ def register_Ns3FdBetFfMacScheduler_methods(root_module, cls): return def register_Ns3FdMtFfMacScheduler_methods(root_module, cls): - ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler(ns3::FdMtFfMacScheduler const & arg0) [copy constructor] + ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler(ns3::FdMtFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdMtFfMacScheduler const &', 'arg0')]) ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22079,7 +23588,7 @@ def register_Ns3FdMtFfMacScheduler_methods(root_module, cls): return def register_Ns3FdTbfqFfMacScheduler_methods(root_module, cls): - ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler(ns3::FdTbfqFfMacScheduler const & arg0) [copy constructor] + ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler(ns3::FdTbfqFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdTbfqFfMacScheduler const &', 'arg0')]) ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22130,7 +23639,7 @@ def register_Ns3FdTbfqFfMacScheduler_methods(root_module, cls): return def register_Ns3HandoverPreparationInfoHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader(ns3::HandoverPreparationInfoHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader(ns3::HandoverPreparationInfoHeader const & arg0) [constructor] cls.add_constructor([param('ns3::HandoverPreparationInfoHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader() [constructor] cls.add_constructor([]) @@ -22168,7 +23677,7 @@ def register_Ns3HandoverPreparationInfoHeader_methods(root_module, cls): def register_Ns3LteDataRadioBearerInfo_methods(root_module, cls): ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo() [constructor] cls.add_constructor([]) - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo(ns3::LteDataRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo(ns3::LteDataRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteDataRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): static ns3::TypeId ns3::LteDataRadioBearerInfo::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -22194,7 +23703,7 @@ def register_Ns3LteDataRadioBearerInfo_methods(root_module, cls): return def register_Ns3LteEnbPhy_methods(root_module, cls): - ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy(ns3::LteEnbPhy const & arg0) [copy constructor] + ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy(ns3::LteEnbPhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhy const &', 'arg0')]) ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy() [constructor] cls.add_constructor([]) @@ -22222,7 +23731,7 @@ def register_Ns3LteEnbPhy_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [], is_virtual=True) - ## lte-enb-phy.h (module 'lte'): std::list > ns3::LteEnbPhy::DequeueUlDci() [member function] + ## lte-enb-phy.h (module 'lte'): std::list > ns3::LteEnbPhy::DequeueUlDci() [member function] cls.add_method('DequeueUlDci', 'std::list< ns3::UlDciLteControlMessage >', []) @@ -22491,7 +24000,7 @@ def register_Ns3LteNetDevice_methods(root_module, cls): 'bool', [], is_const=True, is_virtual=True) - ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -22506,7 +24015,7 @@ def register_Ns3LteNetDevice_methods(root_module, cls): 'ns3::Address', [param('ns3::Ipv6Address', 'addr')], is_const=True, is_virtual=True) - ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -22601,11 +24110,11 @@ def register_Ns3LteUeNetDevice_methods(root_module, cls): cls.add_method('GetTargetEnb', 'ns3::Ptr< ns3::LteEnbNetDevice >', []) - ## lte-ue-net-device.h (module 'lte'): void ns3::LteUeNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] + ## lte-ue-net-device.h (module 'lte'): void ns3::LteUeNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] cls.add_method('SetCcMap', 'void', [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', 'ccm')]) - ## lte-ue-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteUeNetDevice::GetCcMap() [member function] + ## lte-ue-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteUeNetDevice::GetCcMap() [member function] cls.add_method('GetCcMap', 'std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', []) @@ -22617,7 +24126,7 @@ def register_Ns3LteUeNetDevice_methods(root_module, cls): return def register_Ns3MeasurementReportHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader(ns3::MeasurementReportHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader(ns3::MeasurementReportHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MeasurementReportHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader() [constructor] cls.add_constructor([]) @@ -22648,7 +24157,7 @@ def register_Ns3MeasurementReportHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReconfigurationCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader(ns3::RrcConnectionReconfigurationCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader(ns3::RrcConnectionReconfigurationCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReconfigurationCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader() [constructor] cls.add_constructor([]) @@ -22684,7 +24193,7 @@ def register_Ns3RrcConnectionReconfigurationCompleteHeader_methods(root_module, return def register_Ns3RrcConnectionReconfigurationHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader(ns3::RrcConnectionReconfigurationHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader(ns3::RrcConnectionReconfigurationHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReconfigurationHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader() [constructor] cls.add_constructor([]) @@ -22782,7 +24291,7 @@ def register_Ns3RrcConnectionReconfigurationHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReestablishmentCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader(ns3::RrcConnectionReestablishmentCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader(ns3::RrcConnectionReestablishmentCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader() [constructor] cls.add_constructor([]) @@ -22818,7 +24327,7 @@ def register_Ns3RrcConnectionReestablishmentCompleteHeader_methods(root_module, return def register_Ns3RrcConnectionReestablishmentHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader(ns3::RrcConnectionReestablishmentHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader(ns3::RrcConnectionReestablishmentHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader() [constructor] cls.add_constructor([]) @@ -22859,7 +24368,7 @@ def register_Ns3RrcConnectionReestablishmentHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReestablishmentRejectHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader(ns3::RrcConnectionReestablishmentRejectHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader(ns3::RrcConnectionReestablishmentRejectHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentRejectHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader() [constructor] cls.add_constructor([]) @@ -22890,7 +24399,7 @@ def register_Ns3RrcConnectionReestablishmentRejectHeader_methods(root_module, cl return def register_Ns3RrcConnectionReestablishmentRequestHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader(ns3::RrcConnectionReestablishmentRequestHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader(ns3::RrcConnectionReestablishmentRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentRequestHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader() [constructor] cls.add_constructor([]) @@ -22931,7 +24440,7 @@ def register_Ns3RrcConnectionReestablishmentRequestHeader_methods(root_module, c return def register_Ns3RrcConnectionRejectHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader(ns3::RrcConnectionRejectHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader(ns3::RrcConnectionRejectHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionRejectHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader() [constructor] cls.add_constructor([]) @@ -22962,7 +24471,7 @@ def register_Ns3RrcConnectionRejectHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReleaseHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader(ns3::RrcConnectionReleaseHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader(ns3::RrcConnectionReleaseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReleaseHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader() [constructor] cls.add_constructor([]) @@ -22993,7 +24502,7 @@ def register_Ns3RrcConnectionReleaseHeader_methods(root_module, cls): return def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader(ns3::RrcConnectionRequestHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader(ns3::RrcConnectionRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionRequestHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader() [constructor] cls.add_constructor([]) @@ -23007,14 +24516,14 @@ def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): 'ns3::LteRrcSap::RrcConnectionRequest', [], is_const=True) - ## lte-rrc-header.h (module 'lte'): std::bitset<8ul> ns3::RrcConnectionRequestHeader::GetMmec() const [member function] + ## lte-rrc-header.h (module 'lte'): std::bitset<8> ns3::RrcConnectionRequestHeader::GetMmec() const [member function] cls.add_method('GetMmec', - 'std::bitset< 8ul >', + 'std::bitset< 8 >', [], is_const=True) - ## lte-rrc-header.h (module 'lte'): std::bitset<32ul> ns3::RrcConnectionRequestHeader::GetMtmsi() const [member function] + ## lte-rrc-header.h (module 'lte'): std::bitset<32> ns3::RrcConnectionRequestHeader::GetMtmsi() const [member function] cls.add_method('GetMtmsi', - 'std::bitset< 32ul >', + 'std::bitset< 32 >', [], is_const=True) ## lte-rrc-header.h (module 'lte'): static ns3::TypeId ns3::RrcConnectionRequestHeader::GetTypeId() [member function] @@ -23039,7 +24548,7 @@ def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): return def register_Ns3RrcConnectionSetupCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader(ns3::RrcConnectionSetupCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader(ns3::RrcConnectionSetupCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionSetupCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader() [constructor] cls.add_constructor([]) @@ -23075,7 +24584,7 @@ def register_Ns3RrcConnectionSetupCompleteHeader_methods(root_module, cls): return def register_Ns3RrcConnectionSetupHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader(ns3::RrcConnectionSetupHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader(ns3::RrcConnectionSetupHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionSetupHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader() [constructor] cls.add_constructor([]) @@ -23191,6 +24700,11 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): 'uint16_t', [], is_const=True) + ## lte-enb-net-device.h (module 'lte'): bool ns3::LteEnbNetDevice::HasCellId(uint16_t cellId) const [member function] + cls.add_method('HasCellId', + 'bool', + [param('uint16_t', 'cellId')], + is_const=True) ## lte-enb-net-device.h (module 'lte'): uint8_t ns3::LteEnbNetDevice::GetUlBandwidth() const [member function] cls.add_method('GetUlBandwidth', 'uint8_t', @@ -23245,11 +24759,11 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): cls.add_method('SetCsgIndication', 'void', [param('bool', 'csgIndication')]) - ## lte-enb-net-device.h (module 'lte'): void ns3::LteEnbNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] + ## lte-enb-net-device.h (module 'lte'): void ns3::LteEnbNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] cls.add_method('SetCcMap', 'void', [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccm')]) - ## lte-enb-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteEnbNetDevice::GetCcMap() [member function] + ## lte-enb-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteEnbNetDevice::GetCcMap() [member function] cls.add_method('GetCcMap', 'std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', []) @@ -23261,15 +24775,15 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): return def register_Ns3ConfigMatchContainer_methods(root_module, cls): - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')]) ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer() [constructor] cls.add_constructor([]) - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector > const & contexts, std::string path) [constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector, std::allocator > > const & contexts, std::string path) [constructor] cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::Begin() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function] @@ -23288,9 +24802,9 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): cls.add_method('DisconnectWithoutContext', 'void', [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::End() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): ns3::Ptr ns3::Config::MatchContainer::Get(uint32_t i) const [member function] @@ -23320,7 +24834,7 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -23342,7 +24856,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -23364,7 +24878,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -23381,7 +24895,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -23403,7 +24917,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) From 67df11a5d9eb2f85c1865e380b991ed923c1810f Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Wed, 26 Jul 2017 23:58:24 +0200 Subject: [PATCH 200/551] Applications: Add an attribute to UdpTraceClient to read the trace only once. --- src/applications/model/udp-trace-client.cc | 34 ++++++++++++++++++++-- src/applications/model/udp-trace-client.h | 15 +++++++++- 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/src/applications/model/udp-trace-client.cc b/src/applications/model/udp-trace-client.cc index bd1414caec1..fe02031042c 100644 --- a/src/applications/model/udp-trace-client.cc +++ b/src/applications/model/udp-trace-client.cc @@ -28,6 +28,7 @@ #include "ns3/socket-factory.h" #include "ns3/packet.h" #include "ns3/uinteger.h" +#include "ns3/boolean.h" #include "ns3/string.h" #include "seq-ts-header.h" #include "udp-trace-client.h" @@ -84,6 +85,11 @@ UdpTraceClient::GetTypeId (void) StringValue (""), MakeStringAccessor (&UdpTraceClient::SetTraceFile), MakeStringChecker ()) + .AddAttribute ("TraceLoop", + "Loops through the trace file, starting again once it is over.", + BooleanValue (true), + MakeBooleanAccessor (&UdpTraceClient::SetTraceLoop), + MakeBooleanChecker ()) ; return tid; @@ -178,7 +184,7 @@ void UdpTraceClient::LoadTrace (std::string filename) { NS_LOG_FUNCTION (this << filename); - uint32_t time, index, size, prevTime = 0; + uint32_t time, index, oldIndex, size, prevTime = 0; char frameType; TraceEntry entry; std::ifstream ifTraceFile; @@ -191,6 +197,10 @@ UdpTraceClient::LoadTrace (std::string filename) while (ifTraceFile.good ()) { ifTraceFile >> index >> frameType >> time >> size; + if (index == oldIndex) + { + continue; + } if (frameType == 'B') { entry.timeToSend = 0; @@ -203,8 +213,10 @@ UdpTraceClient::LoadTrace (std::string filename) entry.packetSize = size; entry.frameType = frameType; m_entries.push_back (entry); + oldIndex = index; } ifTraceFile.close (); + NS_ASSERT_MSG (prevTime != 0, "A trace file can not contain B frames only."); m_currentEntry = 0; } @@ -341,6 +353,8 @@ UdpTraceClient::Send (void) NS_LOG_FUNCTION (this); NS_ASSERT (m_sendEvent.IsExpired ()); + + bool cycled = false; Ptr p; struct TraceEntry *entry = &m_entries[m_currentEntry]; do @@ -354,11 +368,25 @@ UdpTraceClient::Send (void) SendPacket (sizetosend); m_currentEntry++; - m_currentEntry %= m_entries.size (); + if (m_currentEntry >= m_entries.size ()) + { + m_currentEntry = 0; + cycled = true; + } entry = &m_entries[m_currentEntry]; } while (entry->timeToSend == 0); - m_sendEvent = Simulator::Schedule (MilliSeconds (entry->timeToSend), &UdpTraceClient::Send, this); + + if (!cycled || m_traceLoop) + { + m_sendEvent = Simulator::Schedule (MilliSeconds (entry->timeToSend), &UdpTraceClient::Send, this); + } +} + +void +UdpTraceClient::SetTraceLoop (bool traceLoop) +{ + m_traceLoop = traceLoop; } } // Namespace ns3 diff --git a/src/applications/model/udp-trace-client.h b/src/applications/model/udp-trace-client.h index ca96c399803..6d1e07afa84 100644 --- a/src/applications/model/udp-trace-client.h +++ b/src/applications/model/udp-trace-client.h @@ -45,11 +45,17 @@ class Packet; * A valid trace file is a file with 4 columns: * \li -1- the first one represents the frame index * \li -2- the second one indicates the type of the frame: I, P or B - * \li -3- the third one indicates the time on which the frame was generated by the encoder + * \li -3- the third one indicates the time on which the frame was generated by the encoder (integer, milliseconds) * \li -4- the fourth one indicates the frame size in byte * * If no valid MPEG4 trace file is provided to the application the trace from * g_defaultEntries array will be loaded. + * + * Also note that: + * \li -1- consecutive 'B' frames are sent together, + * \li -2- any trace file is (by default) read again once finished (loop). + * + * The latter behavior can be changed through the "TraceLoop" attribute. */ class UdpTraceClient : public Application { @@ -109,6 +115,12 @@ class UdpTraceClient : public Application */ void SetMaxPacketSize (uint16_t maxPacketSize); + /** + * \brief Set the trace loop flag + * \param traceLoop true if the trace should be re-used + */ + void SetTraceLoop (bool traceLoop); + protected: virtual void DoDispose (void); @@ -157,6 +169,7 @@ class UdpTraceClient : public Application uint32_t m_currentEntry; //!< Current entry index static struct TraceEntry g_defaultEntries[]; //!< Default trace to send uint16_t m_maxPacketSize; //!< Maximum packet size to send (including the SeqTsHeader) + bool m_traceLoop; //!< Loop through the trace file }; } // namespace ns3 From a35b036bc151c4e71ec8f263101816ed1e463508 Mon Sep 17 00:00:00 2001 From: Tommaso Pecorella Date: Thu, 27 Jul 2017 22:07:12 +0200 Subject: [PATCH 201/551] Applications: UdpTraceClient - fix use of uninitialized variable --- src/applications/model/udp-trace-client.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/applications/model/udp-trace-client.cc b/src/applications/model/udp-trace-client.cc index fe02031042c..31d588d6db5 100644 --- a/src/applications/model/udp-trace-client.cc +++ b/src/applications/model/udp-trace-client.cc @@ -184,7 +184,11 @@ void UdpTraceClient::LoadTrace (std::string filename) { NS_LOG_FUNCTION (this << filename); - uint32_t time, index, oldIndex, size, prevTime = 0; + uint32_t time = 0; + uint32_t index = 0; + uint32_t oldIndex = 0; + uint32_t size = 0; + uint32_t prevTime = 0; char frameType; TraceEntry entry; std::ifstream ifTraceFile; From 90a897f20be66632a19d54253fced6defaa50c02 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 1 Aug 2017 20:01:53 -0700 Subject: [PATCH 202/551] core: Update rng example to current API --- src/core/examples/sample-rng-plot.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/core/examples/sample-rng-plot.py b/src/core/examples/sample-rng-plot.py index eef70a8515e..a01f6f5b965 100644 --- a/src/core/examples/sample-rng-plot.py +++ b/src/core/examples/sample-rng-plot.py @@ -22,7 +22,9 @@ import ns.core # mu, var = 100, 225 -rng = ns.core.NormalVariable(100.0, 225.0) +rng = ns.core.NormalRandomVariable() +rng.SetAttribute("Mean", ns.core.DoubleValue(100.0)) +rng.SetAttribute("Variance", ns.core.DoubleValue(225.0)) x = [rng.GetValue() for t in range(10000)] # the histogram of the data From 3bcaef5a5beef93ec7f106093b6e55507214b651 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 8 Aug 2017 10:00:36 -0700 Subject: [PATCH 203/551] core: Update ILP32 bindings --- src/core/bindings/modulegen__gcc_ILP32.py | 1062 +++++++++++++-------- 1 file changed, 664 insertions(+), 398 deletions(-) diff --git a/src/core/bindings/modulegen__gcc_ILP32.py b/src/core/bindings/modulegen__gcc_ILP32.py index 64e99c4cc7e..293123f4c8c 100644 --- a/src/core/bindings/modulegen__gcc_ILP32.py +++ b/src/core/bindings/modulegen__gcc_ILP32.py @@ -32,6 +32,22 @@ def register_types(module): module.add_class('CommandLine', allow_subclassing=True) ## system-mutex.h (module 'core'): ns3::CriticalSection [class] module.add_class('CriticalSection') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::SystemThread']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::TraceSourceAccessor']) ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector [class] module.add_class('EventGarbageCollector') ## event-id.h (module 'core'): ns3::EventId [class] @@ -130,9 +146,9 @@ def register_types(module): module.add_class('Watchdog') ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t']) ## des-metrics.h (module 'core'): ns3::DesMetrics [class] module.add_class('DesMetrics', parent=root_module['ns3::Singleton< ns3::DesMetrics >']) @@ -298,21 +314,15 @@ def register_types(module): module.add_class('Vector3DChecker', parent=root_module['ns3::AttributeChecker']) ## vector.h (module 'core'): ns3::Vector3DValue [class] module.add_class('Vector3DValue', parent=root_module['ns3::AttributeValue']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['bool', 'std::basic_string', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned char *', 'long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) module.add_container('std::map< std::string, ns3::LogComponent * >', ('std::string', 'ns3::LogComponent *'), container_type=u'map') - typehandlers.add_type_alias(u'ns3::RngSeedManager', u'ns3::SeedManager') - typehandlers.add_type_alias(u'ns3::RngSeedManager*', u'ns3::SeedManager*') - typehandlers.add_type_alias(u'ns3::RngSeedManager&', u'ns3::SeedManager&') - module.add_typedef(root_module['ns3::RngSeedManager'], 'SeedManager') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectVectorValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectVectorValue*') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectVectorValue&') - module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectVectorValue') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') @@ -321,14 +331,28 @@ def register_types(module): typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectMapValue') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectMapValue*') - typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectMapValue&') - module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectMapValue') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') + typehandlers.add_type_alias(u'ns3::RngSeedManager', u'ns3::SeedManager') + typehandlers.add_type_alias(u'ns3::RngSeedManager*', u'ns3::SeedManager*') + typehandlers.add_type_alias(u'ns3::RngSeedManager&', u'ns3::SeedManager&') + module.add_typedef(root_module['ns3::RngSeedManager'], 'SeedManager') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectVectorValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectVectorValue*') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectVectorValue&') + module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectVectorValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue', u'ns3::ObjectMapValue') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue*', u'ns3::ObjectMapValue*') + typehandlers.add_type_alias(u'ns3::ObjectPtrContainerValue&', u'ns3::ObjectMapValue&') + module.add_typedef(root_module['ns3::ObjectPtrContainerValue'], 'ObjectMapValue') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') ## Register a nested module for the namespace CommandLineHelper @@ -393,12 +417,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -426,36 +450,36 @@ def register_types_ns3_SystemPath(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -467,6 +491,14 @@ def register_methods(root_module): register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) register_Ns3CommandLine_methods(root_module, root_module['ns3::CommandLine']) register_Ns3CriticalSection_methods(root_module, root_module['ns3::CriticalSection']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3SystemThread_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SystemThread >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3EventGarbageCollector_methods(root_module, root_module['ns3::EventGarbageCollector']) register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) register_Ns3GlobalValue_methods(root_module, root_module['ns3::GlobalValue']) @@ -584,6 +616,10 @@ def register_methods(root_module): register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue']) register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker']) register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue']) + register_Ns3CallbackImpl__Bool_StdBasic_string__lt__char__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, std::basic_string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_char___star___Long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned char *, long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3ConfigMatchContainer_methods(root_module, root_module['ns3::Config::MatchContainer']) register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation']) register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a']) @@ -593,25 +629,25 @@ def register_methods(root_module): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -621,7 +657,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -632,7 +668,7 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -650,12 +686,12 @@ def register_Ns3CommandLine_methods(root_module, cls): cls.add_output_stream_operator() ## command-line.h (module 'core'): ns3::CommandLine::CommandLine() [constructor] cls.add_constructor([]) - ## command-line.h (module 'core'): ns3::CommandLine::CommandLine(ns3::CommandLine const & cmd) [copy constructor] + ## command-line.h (module 'core'): ns3::CommandLine::CommandLine(ns3::CommandLine const & cmd) [constructor] cls.add_constructor([param('ns3::CommandLine const &', 'cmd')]) - ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback callback) [member function] + ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & help, ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function] cls.add_method('AddValue', 'void', - [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::string, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) + [param('std::string const &', 'name'), param('std::string const &', 'help'), param('ns3::Callback< bool, std::basic_string< char >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) ## command-line.h (module 'core'): void ns3::CommandLine::AddValue(std::string const & name, std::string const & attributePath) [member function] cls.add_method('AddValue', 'void', @@ -681,14 +717,110 @@ def register_Ns3CommandLine_methods(root_module, cls): return def register_Ns3CriticalSection_methods(root_module, cls): - ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [copy constructor] - cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')]) ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::SystemMutex & mutex) [constructor] cls.add_constructor([param('ns3::SystemMutex &', 'mutex')]) + ## system-mutex.h (module 'core'): ns3::CriticalSection::CriticalSection(ns3::CriticalSection const & arg0) [constructor] + cls.add_constructor([param('ns3::CriticalSection const &', 'arg0')]) + return + +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SystemThread_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SystemThread > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SystemThread * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SystemThread *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) return def register_Ns3EventGarbageCollector_methods(root_module, cls): - ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [copy constructor] + ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector(ns3::EventGarbageCollector const & arg0) [constructor] cls.add_constructor([param('ns3::EventGarbageCollector const &', 'arg0')]) ## event-garbage-collector.h (module 'core'): ns3::EventGarbageCollector::EventGarbageCollector() [constructor] cls.add_constructor([]) @@ -699,9 +831,9 @@ def register_Ns3EventGarbageCollector_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -744,13 +876,13 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3GlobalValue_methods(root_module, cls): - ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [copy constructor] + ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(ns3::GlobalValue const & arg0) [constructor] cls.add_constructor([param('ns3::GlobalValue const &', 'arg0')]) - ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr checker) [constructor] + ## global-value.h (module 'core'): ns3::GlobalValue::GlobalValue(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr checker) [constructor] cls.add_constructor([param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')]) - ## global-value.h (module 'core'): static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::Begin() [member function] + ## global-value.h (module 'core'): static ns3::GlobalValue::Iterator ns3::GlobalValue::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', + 'ns3::GlobalValue::Iterator', [], is_static=True) ## global-value.h (module 'core'): static void ns3::GlobalValue::Bind(std::string name, ns3::AttributeValue const & value) [member function] @@ -763,12 +895,12 @@ def register_Ns3GlobalValue_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')], is_static=True) - ## global-value.h (module 'core'): static __gnu_cxx::__normal_iterator > > ns3::GlobalValue::End() [member function] + ## global-value.h (module 'core'): static ns3::GlobalValue::Iterator ns3::GlobalValue::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::GlobalValue * const *, std::vector< ns3::GlobalValue * > >', + 'ns3::GlobalValue::Iterator', [], is_static=True) - ## global-value.h (module 'core'): ns3::Ptr ns3::GlobalValue::GetChecker() const [member function] + ## global-value.h (module 'core'): ns3::Ptr ns3::GlobalValue::GetChecker() const [member function] cls.add_method('GetChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [], @@ -809,7 +941,7 @@ def register_Ns3GlobalValue_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -840,57 +972,57 @@ def register_Ns3Hasher_methods(root_module, cls): def register_Ns3IntToType__0_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<0>::IntToType(ns3::IntToType<0> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 0 > const &', 'arg0')]) return def register_Ns3IntToType__1_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<1>::IntToType(ns3::IntToType<1> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 1 > const &', 'arg0')]) return def register_Ns3IntToType__2_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<2>::IntToType(ns3::IntToType<2> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 2 > const &', 'arg0')]) return def register_Ns3IntToType__3_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<3>::IntToType(ns3::IntToType<3> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 3 > const &', 'arg0')]) return def register_Ns3IntToType__4_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<4>::IntToType(ns3::IntToType<4> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 4 > const &', 'arg0')]) return def register_Ns3IntToType__5_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<5>::IntToType(ns3::IntToType<5> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 5 > const &', 'arg0')]) return def register_Ns3IntToType__6_methods(root_module, cls): ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType() [constructor] cls.add_constructor([]) - ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [copy constructor] + ## int-to-type.h (module 'core'): ns3::IntToType<6>::IntToType(ns3::IntToType<6> const & arg0) [constructor] cls.add_constructor([param('ns3::IntToType< 6 > const &', 'arg0')]) return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -904,9 +1036,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -938,7 +1070,7 @@ def register_Ns3LogComponent_methods(root_module, cls): def register_Ns3Names_methods(root_module, cls): ## names.h (module 'core'): ns3::Names::Names() [constructor] cls.add_constructor([]) - ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [copy constructor] + ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [constructor] cls.add_constructor([param('ns3::Names const &', 'arg0')]) ## names.h (module 'core'): static void ns3::Names::Add(std::string name, ns3::Ptr object) [member function] cls.add_method('Add', @@ -996,7 +1128,7 @@ def register_Ns3NonCopyable_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -1057,7 +1189,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -1068,7 +1200,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -1103,7 +1235,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -1112,7 +1244,7 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3RandomVariableStreamHelper_methods(root_module, cls): ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper() [constructor] cls.add_constructor([]) - ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper(ns3::RandomVariableStreamHelper const & arg0) [copy constructor] + ## random-variable-stream-helper.h (module 'core'): ns3::RandomVariableStreamHelper::RandomVariableStreamHelper(ns3::RandomVariableStreamHelper const & arg0) [constructor] cls.add_constructor([param('ns3::RandomVariableStreamHelper const &', 'arg0')]) ## random-variable-stream-helper.h (module 'core'): static int64_t ns3::RandomVariableStreamHelper::AssignStreams(std::string path, int64_t stream) [member function] cls.add_method('AssignStreams', @@ -1124,7 +1256,7 @@ def register_Ns3RandomVariableStreamHelper_methods(root_module, cls): def register_Ns3RngSeedManager_methods(root_module, cls): ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager() [constructor] cls.add_constructor([]) - ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager(ns3::RngSeedManager const & arg0) [copy constructor] + ## rng-seed-manager.h (module 'core'): ns3::RngSeedManager::RngSeedManager(ns3::RngSeedManager const & arg0) [constructor] cls.add_constructor([param('ns3::RngSeedManager const &', 'arg0')]) ## rng-seed-manager.h (module 'core'): static uint64_t ns3::RngSeedManager::GetNextStreamIndex() [member function] cls.add_method('GetNextStreamIndex', @@ -1156,7 +1288,7 @@ def register_Ns3RngSeedManager_methods(root_module, cls): def register_Ns3RngStream_methods(root_module, cls): ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(uint32_t seed, uint64_t stream, uint64_t substream) [constructor] cls.add_constructor([param('uint32_t', 'seed'), param('uint64_t', 'stream'), param('uint64_t', 'substream')]) - ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(ns3::RngStream const & r) [copy constructor] + ## rng-stream.h (module 'core'): ns3::RngStream::RngStream(ns3::RngStream const & r) [constructor] cls.add_constructor([param('ns3::RngStream const &', 'r')]) ## rng-stream.h (module 'core'): double ns3::RngStream::RandU01() [member function] cls.add_method('RandU01', @@ -1167,7 +1299,7 @@ def register_Ns3RngStream_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -1177,7 +1309,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -1257,17 +1389,17 @@ def register_Ns3Simulator_methods(root_module, cls): return def register_Ns3Singleton__Ns3DesMetrics_methods(root_module, cls): - ## singleton.h (module 'core'): ns3::Singleton::Singleton() [constructor] - cls.add_constructor([]) ## singleton.h (module 'core'): static ns3::DesMetrics * ns3::Singleton::Get() [member function] cls.add_method('Get', 'ns3::DesMetrics *', [], is_static=True) + ## singleton.h (module 'core'): ns3::Singleton::Singleton() [constructor] + cls.add_constructor([]) return def register_Ns3SystemCondition_methods(root_module, cls): - ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [copy constructor] + ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition(ns3::SystemCondition const & arg0) [constructor] cls.add_constructor([param('ns3::SystemCondition const &', 'arg0')]) ## system-condition.h (module 'core'): ns3::SystemCondition::SystemCondition() [constructor] cls.add_constructor([]) @@ -1298,7 +1430,7 @@ def register_Ns3SystemCondition_methods(root_module, cls): return def register_Ns3SystemMutex_methods(root_module, cls): - ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [copy constructor] + ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex(ns3::SystemMutex const & arg0) [constructor] cls.add_constructor([param('ns3::SystemMutex const &', 'arg0')]) ## system-mutex.h (module 'core'): ns3::SystemMutex::SystemMutex() [constructor] cls.add_constructor([]) @@ -1313,7 +1445,7 @@ def register_Ns3SystemMutex_methods(root_module, cls): return def register_Ns3SystemWallClockMs_methods(root_module, cls): - ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor] + ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [constructor] cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')]) ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs() [constructor] cls.add_constructor([]) @@ -1344,14 +1476,14 @@ def register_Ns3SystemWallClockMs_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) return def register_Ns3Timer_methods(root_module, cls): - ## timer.h (module 'core'): ns3::Timer::Timer(ns3::Timer const & arg0) [copy constructor] + ## timer.h (module 'core'): ns3::Timer::Timer(ns3::Timer const & arg0) [constructor] cls.add_constructor([param('ns3::Timer const &', 'arg0')]) ## timer.h (module 'core'): ns3::Timer::Timer() [constructor] cls.add_constructor([]) @@ -1420,7 +1552,7 @@ def register_Ns3Timer_methods(root_module, cls): def register_Ns3TimerImpl_methods(root_module, cls): ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl() [constructor] cls.add_constructor([]) - ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [copy constructor] + ## timer-impl.h (module 'core'): ns3::TimerImpl::TimerImpl(ns3::TimerImpl const & arg0) [constructor] cls.add_constructor([param('ns3::TimerImpl const &', 'arg0')]) ## timer-impl.h (module 'core'): void ns3::TimerImpl::Invoke() [member function] cls.add_method('Invoke', @@ -1435,33 +1567,32 @@ def register_Ns3TimerImpl_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -1477,7 +1608,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -1487,9 +1618,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -1556,12 +1687,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -1571,12 +1702,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -1586,7 +1717,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -1611,13 +1742,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -1636,7 +1766,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -1653,14 +1783,21 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -1668,14 +1805,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -1685,7 +1829,7 @@ def register_Ns3Vector3D_methods(root_module, cls): return def register_Ns3Watchdog_methods(root_module, cls): - ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [copy constructor] + ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog(ns3::Watchdog const & arg0) [constructor] cls.add_constructor([param('ns3::Watchdog const &', 'arg0')]) ## watchdog.h (module 'core'): ns3::Watchdog::Watchdog() [constructor] cls.add_constructor([]) @@ -1698,80 +1842,78 @@ def register_Ns3Watchdog_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3DesMetrics_methods(root_module, cls): - ## des-metrics.h (module 'core'): ns3::DesMetrics::DesMetrics() [constructor] - cls.add_constructor([]) ## des-metrics.h (module 'core'): void ns3::DesMetrics::Initialize(int argc, char * * argv, std::string outDir="") [member function] cls.add_method('Initialize', 'void', @@ -1784,6 +1926,8 @@ def register_Ns3DesMetrics_methods(root_module, cls): cls.add_method('TraceWithContext', 'void', [param('uint32_t', 'context'), param('ns3::Time const &', 'now'), param('ns3::Time const &', 'delay')]) + ## des-metrics.h (module 'core'): ns3::DesMetrics::DesMetrics() [constructor] + cls.add_constructor([]) return def register_Ns3Object_methods(root_module, cls): @@ -1811,7 +1955,7 @@ def register_Ns3Object_methods(root_module, cls): cls.add_method('GetObject', 'ns3::Ptr< ns3::Object >', [param('ns3::TypeId', 'tid')], - is_const=True, template_parameters=['ns3::Object'], custom_template_method_name=u'GetObject') + is_const=True, template_parameters=[u'ns3::Object'], custom_template_method_name=u'GetObject') ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -1826,7 +1970,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -1847,7 +1991,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -1856,7 +2000,7 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) @@ -1908,7 +2052,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): def register_Ns3Scheduler_methods(root_module, cls): ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::Scheduler(ns3::Scheduler const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler const &', 'arg0')]) ## scheduler.h (module 'core'): static ns3::TypeId ns3::Scheduler::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -1946,7 +2090,7 @@ def register_Ns3SchedulerEvent_methods(root_module, cls): cls.add_binary_comparison_operator('<') ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event(ns3::Scheduler::Event const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::Event::Event(ns3::Scheduler::Event const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler::Event const &', 'arg0')]) ## scheduler.h (module 'core'): ns3::Scheduler::Event::impl [variable] cls.add_instance_attribute('impl', 'ns3::EventImpl *', is_const=False) @@ -1956,11 +2100,11 @@ def register_Ns3SchedulerEvent_methods(root_module, cls): def register_Ns3SchedulerEventKey_methods(root_module, cls): cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('>') ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey() [constructor] cls.add_constructor([]) - ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [copy constructor] + ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::EventKey(ns3::Scheduler::EventKey const & arg0) [constructor] cls.add_constructor([param('ns3::Scheduler::EventKey const &', 'arg0')]) ## scheduler.h (module 'core'): ns3::Scheduler::EventKey::m_context [variable] cls.add_instance_attribute('m_context', 'uint32_t', is_const=False) @@ -2013,7 +2157,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2025,7 +2169,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2037,7 +2181,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2049,7 +2193,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2061,7 +2205,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2073,7 +2217,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3FdReader_Ns3Empty_Ns3DefaultDeleter__lt__ns3FdReader__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::FdReader, ns3::empty, ns3::DefaultDeleter< ns3::FdReader > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2085,7 +2229,7 @@ def register_Ns3SimpleRefCount__Ns3FdReader_Ns3Empty_Ns3DefaultDeleter__lt__ns3F def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2097,7 +2241,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3RefCountBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3RefCountBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::RefCountBase, ns3::empty, ns3::DefaultDeleter< ns3::RefCountBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2109,7 +2253,7 @@ def register_Ns3SimpleRefCount__Ns3RefCountBase_Ns3Empty_Ns3DefaultDeleter__lt__ def register_Ns3SimpleRefCount__Ns3SystemThread_Ns3Empty_Ns3DefaultDeleter__lt__ns3SystemThread__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SystemThread, ns3::empty, ns3::DefaultDeleter< ns3::SystemThread > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2121,7 +2265,7 @@ def register_Ns3SimpleRefCount__Ns3SystemThread_Ns3Empty_Ns3DefaultDeleter__lt__ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -2133,7 +2277,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete def register_Ns3SimulatorImpl_methods(root_module, cls): ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl() [constructor] cls.add_constructor([]) - ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [copy constructor] + ## simulator-impl.h (module 'core'): ns3::SimulatorImpl::SimulatorImpl(ns3::SimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::SimulatorImpl const &', 'arg0')]) ## simulator-impl.h (module 'core'): void ns3::SimulatorImpl::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -2233,7 +2377,7 @@ def register_Ns3SimulatorImpl_methods(root_module, cls): return def register_Ns3Synchronizer_methods(root_module, cls): - ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [copy constructor] + ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer(ns3::Synchronizer const & arg0) [constructor] cls.add_constructor([param('ns3::Synchronizer const &', 'arg0')]) ## synchronizer.h (module 'core'): ns3::Synchronizer::Synchronizer() [constructor] cls.add_constructor([]) @@ -2330,11 +2474,11 @@ def register_Ns3Synchronizer_methods(root_module, cls): return def register_Ns3SystemThread_methods(root_module, cls): - ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [copy constructor] + ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::SystemThread const & arg0) [constructor] cls.add_constructor([param('ns3::SystemThread const &', 'arg0')]) ## system-thread.h (module 'core'): ns3::SystemThread::SystemThread(ns3::Callback callback) [constructor] cls.add_constructor([param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## system-thread.h (module 'core'): static bool ns3::SystemThread::Equals(pthread_t id) [member function] + ## system-thread.h (module 'core'): static bool ns3::SystemThread::Equals(ns3::SystemThread::ThreadId id) [member function] cls.add_method('Equals', 'bool', [param('pthread_t', 'id')], @@ -2343,9 +2487,9 @@ def register_Ns3SystemThread_methods(root_module, cls): cls.add_method('Join', 'void', []) - ## system-thread.h (module 'core'): static pthread_t ns3::SystemThread::Self() [member function] + ## system-thread.h (module 'core'): static ns3::SystemThread::ThreadId ns3::SystemThread::Self() [member function] cls.add_method('Self', - 'pthread_t', + 'ns3::SystemThread::ThreadId', [], is_static=True) ## system-thread.h (module 'core'): void ns3::SystemThread::Start() [member function] @@ -2355,22 +2499,22 @@ def register_Ns3SystemThread_methods(root_module, cls): return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -2553,7 +2697,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -2661,7 +2805,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): return def register_Ns3WallClockSynchronizer_methods(root_module, cls): - ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [copy constructor] + ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer(ns3::WallClockSynchronizer const & arg0) [constructor] cls.add_constructor([param('ns3::WallClockSynchronizer const &', 'arg0')]) ## wall-clock-synchronizer.h (module 'core'): ns3::WallClockSynchronizer::WallClockSynchronizer() [constructor] cls.add_constructor([]) @@ -2878,7 +3022,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -2905,7 +3049,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -2947,7 +3091,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -2956,12 +3100,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2971,13 +3115,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -2988,7 +3132,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2998,7 +3142,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3010,7 +3154,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): return def register_Ns3CalendarScheduler_methods(root_module, cls): - ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler(ns3::CalendarScheduler const & arg0) [copy constructor] + ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler(ns3::CalendarScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::CalendarScheduler const &', 'arg0')]) ## calendar-scheduler.h (module 'core'): ns3::CalendarScheduler::CalendarScheduler() [constructor] cls.add_constructor([]) @@ -3049,21 +3193,21 @@ def register_Ns3CalendarScheduler_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -3073,10 +3217,40 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'std::__cxx11::basic_string', u' std::allocator > ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'long']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -3087,12 +3261,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3137,7 +3311,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DefaultSimulatorImpl_methods(root_module, cls): - ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [copy constructor] + ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl(ns3::DefaultSimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::DefaultSimulatorImpl const &', 'arg0')]) ## default-simulator-impl.h (module 'core'): ns3::DefaultSimulatorImpl::DefaultSimulatorImpl() [constructor] cls.add_constructor([]) @@ -3270,16 +3444,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3289,7 +3463,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3335,7 +3509,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -3362,7 +3536,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -3399,7 +3573,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -3408,12 +3582,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3421,7 +3595,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -3466,7 +3640,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -3477,7 +3651,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3487,7 +3661,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3537,7 +3711,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -3599,11 +3773,11 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): return def register_Ns3FdReader_methods(root_module, cls): - ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader(ns3::FdReader const & arg0) [copy constructor] + ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader(ns3::FdReader const & arg0) [constructor] cls.add_constructor([param('ns3::FdReader const &', 'arg0')]) ## unix-fd-reader.h (module 'core'): ns3::FdReader::FdReader() [constructor] cls.add_constructor([]) - ## unix-fd-reader.h (module 'core'): void ns3::FdReader::Start(int fd, ns3::Callback readCallback) [member function] + ## unix-fd-reader.h (module 'core'): void ns3::FdReader::Start(int fd, ns3::Callback readCallback) [member function] cls.add_method('Start', 'void', [param('int', 'fd'), param('ns3::Callback< void, unsigned char *, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'readCallback')]) @@ -3657,7 +3831,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): return def register_Ns3HeapScheduler_methods(root_module, cls): - ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [copy constructor] + ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler(ns3::HeapScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::HeapScheduler const &', 'arg0')]) ## heap-scheduler.h (module 'core'): ns3::HeapScheduler::HeapScheduler() [constructor] cls.add_constructor([]) @@ -3696,16 +3870,16 @@ def register_Ns3HeapScheduler_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3715,7 +3889,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3727,7 +3901,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): return def register_Ns3ListScheduler_methods(root_module, cls): - ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [copy constructor] + ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler(ns3::ListScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::ListScheduler const &', 'arg0')]) ## list-scheduler.h (module 'core'): ns3::ListScheduler::ListScheduler() [constructor] cls.add_constructor([]) @@ -3802,7 +3976,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): return def register_Ns3MapScheduler_methods(root_module, cls): - ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [copy constructor] + ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler(ns3::MapScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::MapScheduler const &', 'arg0')]) ## map-scheduler.h (module 'core'): ns3::MapScheduler::MapScheduler() [constructor] cls.add_constructor([]) @@ -3886,23 +4060,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3912,7 +4086,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -3926,7 +4100,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor(ns3::ObjectPtrContainerAccessor const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerAccessor::ObjectPtrContainerAccessor(ns3::ObjectPtrContainerAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerAccessor const &', 'arg0')]) ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & value) const [member function] cls.add_method('Get', @@ -3963,7 +4137,7 @@ def register_Ns3ObjectPtrContainerAccessor_methods(root_module, cls): def register_Ns3ObjectPtrContainerChecker_methods(root_module, cls): ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker(ns3::ObjectPtrContainerChecker const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerChecker::ObjectPtrContainerChecker(ns3::ObjectPtrContainerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerChecker const &', 'arg0')]) ## object-ptr-container.h (module 'core'): ns3::TypeId ns3::ObjectPtrContainerChecker::GetItemTypeId() const [member function] cls.add_method('GetItemTypeId', @@ -3973,13 +4147,13 @@ def register_Ns3ObjectPtrContainerChecker_methods(root_module, cls): return def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): - ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue(ns3::ObjectPtrContainerValue const & arg0) [copy constructor] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue(ns3::ObjectPtrContainerValue const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectPtrContainerValue const &', 'arg0')]) ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::ObjectPtrContainerValue() [constructor] cls.add_constructor([]) - ## object-ptr-container.h (module 'core'): std::_Rb_tree_const_iterator > > ns3::ObjectPtrContainerValue::Begin() const [member function] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::Iterator ns3::ObjectPtrContainerValue::Begin() const [member function] cls.add_method('Begin', - 'std::_Rb_tree_const_iterator< std::pair< unsigned int const, ns3::Ptr< ns3::Object > > >', + 'ns3::ObjectPtrContainerValue::Iterator', [], is_const=True) ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerValue::Copy() const [member function] @@ -3987,14 +4161,14 @@ def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-ptr-container.h (module 'core'): bool ns3::ObjectPtrContainerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## object-ptr-container.h (module 'core'): std::_Rb_tree_const_iterator > > ns3::ObjectPtrContainerValue::End() const [member function] + ## object-ptr-container.h (module 'core'): ns3::ObjectPtrContainerValue::Iterator ns3::ObjectPtrContainerValue::End() const [member function] cls.add_method('End', - 'std::_Rb_tree_const_iterator< std::pair< unsigned int const, ns3::Ptr< ns3::Object > > >', + 'ns3::ObjectPtrContainerValue::Iterator', [], is_const=True) ## object-ptr-container.h (module 'core'): ns3::Ptr ns3::ObjectPtrContainerValue::Get(uint32_t i) const [member function] @@ -4007,7 +4181,7 @@ def register_Ns3ObjectPtrContainerValue_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## object-ptr-container.h (module 'core'): std::string ns3::ObjectPtrContainerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-ptr-container.h (module 'core'): std::string ns3::ObjectPtrContainerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4026,7 +4200,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -4065,7 +4239,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -4075,7 +4249,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -4086,7 +4260,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4096,7 +4270,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4108,7 +4282,7 @@ def register_Ns3PointerValue_methods(root_module, cls): return def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): - ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [copy constructor] + ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl(ns3::RealtimeSimulatorImpl const & arg0) [constructor] cls.add_constructor([param('ns3::RealtimeSimulatorImpl const &', 'arg0')]) ## realtime-simulator-impl.h (module 'core'): ns3::RealtimeSimulatorImpl::RealtimeSimulatorImpl() [constructor] cls.add_constructor([]) @@ -4256,30 +4430,30 @@ def register_Ns3RealtimeSimulatorImpl_methods(root_module, cls): def register_Ns3RefCountBase_methods(root_module, cls): ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase() [constructor] cls.add_constructor([]) - ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & arg0) [copy constructor] + ## ref-count-base.h (module 'core'): ns3::RefCountBase::RefCountBase(ns3::RefCountBase const & arg0) [constructor] cls.add_constructor([param('ns3::RefCountBase const &', 'arg0')]) return def register_Ns3StringChecker_methods(root_module, cls): ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [constructor] cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) return def register_Ns3StringValue_methods(root_module, cls): ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4289,7 +4463,7 @@ def register_Ns3StringValue_methods(root_module, cls): 'std::string', [], is_const=True) - ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4303,16 +4477,16 @@ def register_Ns3StringValue_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4322,7 +4496,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4336,23 +4510,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4362,7 +4536,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4376,16 +4550,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4395,7 +4569,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4409,23 +4583,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4435,7 +4609,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4449,23 +4623,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4475,7 +4649,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -4486,16 +4660,104 @@ def register_Ns3Vector3DValue_methods(root_module, cls): [param('ns3::Vector3D const &', 'value')]) return +def register_Ns3CallbackImpl__Bool_StdBasic_string__lt__char__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, std::basic_string< char >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(std::basic_string, std::allocator > arg0) [member operator] + cls.add_method('operator()', + 'bool', + [param('std::string', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_char___star___Long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned char *, long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned char * arg0, long int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned char *', 'arg0'), param('long int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3ConfigMatchContainer_methods(root_module, cls): - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')]) ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer() [constructor] cls.add_constructor([]) - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector > const & contexts, std::string path) [constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector, std::allocator > > const & contexts, std::string path) [constructor] cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::Begin() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function] @@ -4514,9 +4776,9 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): cls.add_method('DisconnectWithoutContext', 'void', [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::End() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): ns3::Ptr ns3::Config::MatchContainer::Get(uint32_t i) const [member function] @@ -4546,7 +4808,7 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -4568,7 +4830,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -4590,7 +4852,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -4607,7 +4869,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -4629,7 +4891,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -4660,28 +4922,28 @@ def register_functions(root_module): module.add_function('Abs', 'ns3::int64x64_t', [param('ns3::int64x64_t const &', 'value')]) - ## breakpoint.h (module 'core'): extern void ns3::BreakpointFallback() [free function] + ## breakpoint.h (module 'core'): void ns3::BreakpointFallback() [free function] module.add_function('BreakpointFallback', 'void', []) - ## vector.h (module 'core'): extern double ns3::CalculateDistance(ns3::Vector2D const & a, ns3::Vector2D const & b) [free function] + ## vector.h (module 'core'): double ns3::CalculateDistance(ns3::Vector2D const & a, ns3::Vector2D const & b) [free function] module.add_function('CalculateDistance', 'double', [param('ns3::Vector2D const &', 'a'), param('ns3::Vector2D const &', 'b')]) - ## vector.h (module 'core'): extern double ns3::CalculateDistance(ns3::Vector3D const & a, ns3::Vector3D const & b) [free function] + ## vector.h (module 'core'): double ns3::CalculateDistance(ns3::Vector3D const & a, ns3::Vector3D const & b) [free function] module.add_function('CalculateDistance', 'double', [param('ns3::Vector3D const &', 'a'), param('ns3::Vector3D const &', 'b')]) - ## ptr.h (module 'core'): extern ns3::Ptr ns3::Create() [free function] + ## ptr.h (module 'core'): ns3::Ptr ns3::Create() [free function] module.add_function('Create', 'ns3::Ptr< ns3::ObjectPtrContainerValue >', [], - template_parameters=['ns3::ObjectPtrContainerValue']) - ## ptr.h (module 'core'): extern ns3::Ptr ns3::Create() [free function] + template_parameters=[u'ns3::ObjectPtrContainerValue']) + ## ptr.h (module 'core'): ns3::Ptr ns3::Create() [free function] module.add_function('Create', 'ns3::Ptr< ns3::PointerValue >', [], - template_parameters=['ns3::PointerValue']) + template_parameters=[u'ns3::PointerValue']) ## nstime.h (module 'core'): ns3::Time ns3::Days(ns3::int64x64_t value) [free function] module.add_function('Days', 'ns3::Time', @@ -4698,6 +4960,10 @@ def register_functions(root_module): module.add_function('FemtoSeconds', 'ns3::Time', [param('uint64_t', 'value')]) + ## log.h (module 'core'): ns3::LogComponent & ns3::GetLogComponent(std::string const name) [free function] + module.add_function('GetLogComponent', + 'ns3::LogComponent &', + [param('std::string const', 'name')]) ## hash.h (module 'core'): uint32_t ns3::Hash32(std::string const s) [free function] module.add_function('Hash32', 'uint32_t', @@ -4722,51 +4988,51 @@ def register_functions(root_module): module.add_function('Hours', 'ns3::Time', [param('double', 'value')]) - ## log.h (module 'core'): extern void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentDisable(char const * name, ns3::LogLevel level) [free function] module.add_function('LogComponentDisable', 'void', [param('char const *', 'name'), param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentDisableAll(ns3::LogLevel level) [free function] module.add_function('LogComponentDisableAll', 'void', [param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentEnable(char const * name, ns3::LogLevel level) [free function] module.add_function('LogComponentEnable', 'void', [param('char const *', 'name'), param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function] + ## log.h (module 'core'): void ns3::LogComponentEnableAll(ns3::LogLevel level) [free function] module.add_function('LogComponentEnableAll', 'void', [param('ns3::LogLevel', 'level')]) - ## log.h (module 'core'): extern void ns3::LogComponentPrintList() [free function] + ## log.h (module 'core'): void ns3::LogComponentPrintList() [free function] module.add_function('LogComponentPrintList', 'void', []) - ## log.h (module 'core'): extern ns3::LogNodePrinter ns3::LogGetNodePrinter() [free function] + ## log.h (module 'core'): ns3::LogNodePrinter ns3::LogGetNodePrinter() [free function] module.add_function('LogGetNodePrinter', 'ns3::LogNodePrinter', []) - ## log.h (module 'core'): extern ns3::LogTimePrinter ns3::LogGetTimePrinter() [free function] + ## log.h (module 'core'): ns3::LogTimePrinter ns3::LogGetTimePrinter() [free function] module.add_function('LogGetTimePrinter', 'ns3::LogTimePrinter', []) - ## log.h (module 'core'): extern void ns3::LogSetNodePrinter(ns3::LogNodePrinter np) [free function] + ## log.h (module 'core'): void ns3::LogSetNodePrinter(ns3::LogNodePrinter np) [free function] module.add_function('LogSetNodePrinter', 'void', [param('ns3::LogNodePrinter', 'np')]) - ## log.h (module 'core'): extern void ns3::LogSetTimePrinter(ns3::LogTimePrinter lp) [free function] + ## log.h (module 'core'): void ns3::LogSetTimePrinter(ns3::LogTimePrinter lp) [free function] module.add_function('LogSetTimePrinter', 'void', [param('ns3::LogTimePrinter', 'lp')]) - ## boolean.h (module 'core'): extern ns3::Ptr ns3::MakeBooleanChecker() [free function] + ## boolean.h (module 'core'): ns3::Ptr ns3::MakeBooleanChecker() [free function] module.add_function('MakeBooleanChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## callback.h (module 'core'): extern ns3::Ptr ns3::MakeCallbackChecker() [free function] + ## callback.h (module 'core'): ns3::Ptr ns3::MakeCallbackChecker() [free function] module.add_function('MakeCallbackChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## attribute.h (module 'core'): ns3::Ptr ns3::MakeEmptyAttributeAccessor() [free function] + ## attribute.h (module 'core'): ns3::Ptr ns3::MakeEmptyAttributeAccessor() [free function] module.add_function('MakeEmptyAttributeAccessor', 'ns3::Ptr< ns3::AttributeAccessor const >', []) @@ -4774,51 +5040,51 @@ def register_functions(root_module): module.add_function('MakeEmptyAttributeChecker', 'ns3::Ptr< ns3::AttributeChecker >', []) - ## trace-source-accessor.h (module 'core'): ns3::Ptr ns3::MakeEmptyTraceSourceAccessor() [free function] + ## trace-source-accessor.h (module 'core'): ns3::Ptr ns3::MakeEmptyTraceSourceAccessor() [free function] module.add_function('MakeEmptyTraceSourceAccessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', []) - ## enum.h (module 'core'): extern ns3::Ptr ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="", int v13=0, std::string n13="", int v14=0, std::string n14="", int v15=0, std::string n15="", int v16=0, std::string n16="", int v17=0, std::string n17="", int v18=0, std::string n18="", int v19=0, std::string n19="", int v20=0, std::string n20="", int v21=0, std::string n21="", int v22=0, std::string n22="") [free function] + ## enum.h (module 'core'): ns3::Ptr ns3::MakeEnumChecker(int v1, std::string n1, int v2=0, std::string n2="", int v3=0, std::string n3="", int v4=0, std::string n4="", int v5=0, std::string n5="", int v6=0, std::string n6="", int v7=0, std::string n7="", int v8=0, std::string n8="", int v9=0, std::string n9="", int v10=0, std::string n10="", int v11=0, std::string n11="", int v12=0, std::string n12="", int v13=0, std::string n13="", int v14=0, std::string n14="", int v15=0, std::string n15="", int v16=0, std::string n16="", int v17=0, std::string n17="", int v18=0, std::string n18="", int v19=0, std::string n19="", int v20=0, std::string n20="", int v21=0, std::string n21="", int v22=0, std::string n22="") [free function] module.add_function('MakeEnumChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int', 'v1'), param('std::string', 'n1'), param('int', 'v2', default_value='0'), param('std::string', 'n2', default_value='""'), param('int', 'v3', default_value='0'), param('std::string', 'n3', default_value='""'), param('int', 'v4', default_value='0'), param('std::string', 'n4', default_value='""'), param('int', 'v5', default_value='0'), param('std::string', 'n5', default_value='""'), param('int', 'v6', default_value='0'), param('std::string', 'n6', default_value='""'), param('int', 'v7', default_value='0'), param('std::string', 'n7', default_value='""'), param('int', 'v8', default_value='0'), param('std::string', 'n8', default_value='""'), param('int', 'v9', default_value='0'), param('std::string', 'n9', default_value='""'), param('int', 'v10', default_value='0'), param('std::string', 'n10', default_value='""'), param('int', 'v11', default_value='0'), param('std::string', 'n11', default_value='""'), param('int', 'v12', default_value='0'), param('std::string', 'n12', default_value='""'), param('int', 'v13', default_value='0'), param('std::string', 'n13', default_value='""'), param('int', 'v14', default_value='0'), param('std::string', 'n14', default_value='""'), param('int', 'v15', default_value='0'), param('std::string', 'n15', default_value='""'), param('int', 'v16', default_value='0'), param('std::string', 'n16', default_value='""'), param('int', 'v17', default_value='0'), param('std::string', 'n17', default_value='""'), param('int', 'v18', default_value='0'), param('std::string', 'n18', default_value='""'), param('int', 'v19', default_value='0'), param('std::string', 'n19', default_value='""'), param('int', 'v20', default_value='0'), param('std::string', 'n20', default_value='""'), param('int', 'v21', default_value='0'), param('std::string', 'n21', default_value='""'), param('int', 'v22', default_value='0'), param('std::string', 'n22', default_value='""')]) - ## make-event.h (module 'core'): extern ns3::EventImpl * ns3::MakeEvent(void (*)( ) * f) [free function] + ## make-event.h (module 'core'): ns3::EventImpl * ns3::MakeEvent(void (*)( ) f) [free function] module.add_function('MakeEvent', 'ns3::EventImpl *', - [param('void ( * ) ( ) *', 'f')]) - ## object-factory.h (module 'core'): extern ns3::Ptr ns3::MakeObjectFactoryChecker() [free function] + [param('void ( * ) ( )', 'f')]) + ## object-factory.h (module 'core'): ns3::Ptr ns3::MakeObjectFactoryChecker() [free function] module.add_function('MakeObjectFactoryChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## string.h (module 'core'): extern ns3::Ptr ns3::MakeStringChecker() [free function] + ## string.h (module 'core'): ns3::Ptr ns3::MakeStringChecker() [free function] module.add_function('MakeStringChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker() [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker() [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min) [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min) [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('ns3::Time const', 'min')]) - ## nstime.h (module 'core'): extern ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min, ns3::Time const max) [free function] + ## nstime.h (module 'core'): ns3::Ptr ns3::MakeTimeChecker(ns3::Time const min, ns3::Time const max) [free function] module.add_function('MakeTimeChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('ns3::Time const', 'min'), param('ns3::Time const', 'max')]) - ## type-id.h (module 'core'): extern ns3::Ptr ns3::MakeTypeIdChecker() [free function] + ## type-id.h (module 'core'): ns3::Ptr ns3::MakeTypeIdChecker() [free function] module.add_function('MakeTypeIdChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVector2DChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVector2DChecker() [free function] module.add_function('MakeVector2DChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVector3DChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVector3DChecker() [free function] module.add_function('MakeVector3DChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## vector.h (module 'core'): extern ns3::Ptr ns3::MakeVectorChecker() [free function] + ## vector.h (module 'core'): ns3::Ptr ns3::MakeVectorChecker() [free function] module.add_function('MakeVectorChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) @@ -4870,7 +5136,7 @@ def register_functions(root_module): module.add_function('NanoSeconds', 'ns3::Time', [param('uint64_t', 'value')]) - ## simulator.h (module 'core'): extern ns3::Time ns3::Now() [free function] + ## simulator.h (module 'core'): ns3::Time ns3::Now() [free function] module.add_function('Now', 'ns3::Time', []) @@ -4890,7 +5156,7 @@ def register_functions(root_module): module.add_function('Seconds', 'ns3::Time', [param('double', 'value')]) - ## test.h (module 'core'): extern bool ns3::TestDoubleIsEqual(double const a, double const b, double const epsilon=std::numeric_limits::epsilon()) [free function] + ## test.h (module 'core'): bool ns3::TestDoubleIsEqual(double const a, double const b, double const epsilon=std::numeric_limits::epsilon()) [free function] module.add_function('TestDoubleIsEqual', 'bool', [param('double const', 'a'), param('double const', 'b'), param('double const', 'epsilon', default_value='std::numeric_limits::epsilon()')]) @@ -4898,56 +5164,56 @@ def register_functions(root_module): module.add_function('TimeStep', 'ns3::Time', [param('uint64_t', 'ts')]) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['double']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'signed char']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['float']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'short']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned long long']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'int']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned int']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'long']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned short']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned char']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['unsigned char']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned short']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['long']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned int']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['int']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'unsigned long long']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['short']) - ## type-name.h (module 'core'): extern std::string ns3::TypeNameGet() [free function] + template_parameters=[u'float']) + ## type-name.h (module 'core'): std::string ns3::TypeNameGet() [free function] module.add_function('TypeNameGet', 'std::string', [], - template_parameters=['signed char']) + template_parameters=[u'double']) ## nstime.h (module 'core'): ns3::Time ns3::Years(ns3::int64x64_t value) [free function] module.add_function('Years', 'ns3::Time', @@ -4966,91 +5232,91 @@ def register_functions(root_module): return def register_functions_ns3_CommandLineHelper(module, root_module): - ## command-line.h (module 'core'): extern std::string ns3::CommandLineHelper::GetDefault(bool const & val) [free function] + ## command-line.h (module 'core'): std::string ns3::CommandLineHelper::GetDefault(bool const & val) [free function] module.add_function('GetDefault', 'std::string', [param('bool const &', 'val')], - template_parameters=['bool']) - ## command-line.h (module 'core'): extern bool ns3::CommandLineHelper::UserItemParse(std::string const value, bool & val) [free function] + template_parameters=[u'bool']) + ## command-line.h (module 'core'): bool ns3::CommandLineHelper::UserItemParse(std::string const value, bool & val) [free function] module.add_function('UserItemParse', 'bool', [param('std::string const', 'value'), param('bool &', 'val')], - template_parameters=['bool']) + template_parameters=[u'bool']) return def register_functions_ns3_Config(module, root_module): - ## config.h (module 'core'): extern void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::Connect(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('Connect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::ConnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('ConnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::Disconnect(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('Disconnect', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] + ## config.h (module 'core'): void ns3::Config::DisconnectWithoutContext(std::string path, ns3::CallbackBase const & cb) [free function] module.add_function('DisconnectWithoutContext', 'void', [param('std::string', 'path'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): extern ns3::Ptr ns3::Config::GetRootNamespaceObject(uint32_t i) [free function] + ## config.h (module 'core'): ns3::Ptr ns3::Config::GetRootNamespaceObject(uint32_t i) [free function] module.add_function('GetRootNamespaceObject', 'ns3::Ptr< ns3::Object >', [param('uint32_t', 'i')]) - ## config.h (module 'core'): extern uint32_t ns3::Config::GetRootNamespaceObjectN() [free function] + ## config.h (module 'core'): uint32_t ns3::Config::GetRootNamespaceObjectN() [free function] module.add_function('GetRootNamespaceObjectN', 'uint32_t', []) - ## config.h (module 'core'): extern ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function] + ## config.h (module 'core'): ns3::Config::MatchContainer ns3::Config::LookupMatches(std::string path) [free function] module.add_function('LookupMatches', 'ns3::Config::MatchContainer', [param('std::string', 'path')]) - ## config.h (module 'core'): extern void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr obj) [free function] + ## config.h (module 'core'): void ns3::Config::RegisterRootNamespaceObject(ns3::Ptr obj) [free function] module.add_function('RegisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) - ## config.h (module 'core'): extern void ns3::Config::Reset() [free function] + ## config.h (module 'core'): void ns3::Config::Reset() [free function] module.add_function('Reset', 'void', []) - ## config.h (module 'core'): extern void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::Set(std::string path, ns3::AttributeValue const & value) [free function] module.add_function('Set', 'void', [param('std::string', 'path'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::SetDefault(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetDefault', 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): bool ns3::Config::SetDefaultFailSafe(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetDefaultFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): void ns3::Config::SetGlobal(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetGlobal', 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function] + ## config.h (module 'core'): bool ns3::Config::SetGlobalFailSafe(std::string name, ns3::AttributeValue const & value) [free function] module.add_function('SetGlobalFailSafe', 'bool', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')]) - ## config.h (module 'core'): extern void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr obj) [free function] + ## config.h (module 'core'): void ns3::Config::UnregisterRootNamespaceObject(ns3::Ptr obj) [free function] module.add_function('UnregisterRootNamespaceObject', 'void', [param('ns3::Ptr< ns3::Object >', 'obj')]) return def register_functions_ns3_FatalImpl(module, root_module): - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::FlushStreams() [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::FlushStreams() [free function] module.add_function('FlushStreams', 'void', []) - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::RegisterStream(std::ostream * stream) [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::RegisterStream(std::ostream * stream) [free function] module.add_function('RegisterStream', 'void', [param('std::ostream *', 'stream')]) - ## fatal-impl.h (module 'core'): extern void ns3::FatalImpl::UnregisterStream(std::ostream * stream) [free function] + ## fatal-impl.h (module 'core'): void ns3::FatalImpl::UnregisterStream(std::ostream * stream) [free function] module.add_function('UnregisterStream', 'void', [param('std::ostream *', 'stream')]) @@ -5064,31 +5330,31 @@ def register_functions_ns3_Hash_Function(module, root_module): return def register_functions_ns3_SystemPath(module, root_module): - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::Append(std::string left, std::string right) [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::Append(std::string left, std::string right) [free function] module.add_function('Append', 'std::string', [param('std::string', 'left'), param('std::string', 'right')]) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::FindSelfDirectory() [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::FindSelfDirectory() [free function] module.add_function('FindSelfDirectory', 'std::string', []) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::Join(std::_List_const_iterator, std::allocator > > begin, std::_List_const_iterator, std::allocator > > end) [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::Join(std::list, std::allocator > >::const_iterator begin, std::list, std::allocator > >::const_iterator end) [free function] module.add_function('Join', 'std::string', - [param('std::_List_const_iterator< std::basic_string< char, std::char_traits< char >, std::allocator< char > > >', 'begin'), param('std::_List_const_iterator< std::basic_string< char, std::char_traits< char >, std::allocator< char > > >', 'end')]) - ## system-path.h (module 'core'): extern void ns3::SystemPath::MakeDirectories(std::string path) [free function] + [param('std::list< std::string > const_iterator', 'begin'), param('std::list< std::string > const_iterator', 'end')]) + ## system-path.h (module 'core'): void ns3::SystemPath::MakeDirectories(std::string path) [free function] module.add_function('MakeDirectories', 'void', [param('std::string', 'path')]) - ## system-path.h (module 'core'): extern std::string ns3::SystemPath::MakeTemporaryDirectoryName() [free function] + ## system-path.h (module 'core'): std::string ns3::SystemPath::MakeTemporaryDirectoryName() [free function] module.add_function('MakeTemporaryDirectoryName', 'std::string', []) - ## system-path.h (module 'core'): extern std::list > ns3::SystemPath::ReadFiles(std::string path) [free function] + ## system-path.h (module 'core'): std::list, std::allocator > > ns3::SystemPath::ReadFiles(std::string path) [free function] module.add_function('ReadFiles', 'std::list< std::string >', [param('std::string', 'path')]) - ## system-path.h (module 'core'): extern std::list > ns3::SystemPath::Split(std::string path) [free function] + ## system-path.h (module 'core'): std::list, std::allocator > > ns3::SystemPath::Split(std::string path) [free function] module.add_function('Split', 'std::list< std::string >', [param('std::string', 'path')]) @@ -5098,15 +5364,15 @@ def register_functions_ns3_TracedValueCallback(module, root_module): return def register_functions_ns3_internal(module, root_module): - ## double.h (module 'core'): extern ns3::Ptr ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function] + ## double.h (module 'core'): ns3::Ptr ns3::internal::MakeDoubleChecker(double min, double max, std::string name) [free function] module.add_function('MakeDoubleChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('double', 'min'), param('double', 'max'), param('std::string', 'name')]) - ## integer.h (module 'core'): extern ns3::Ptr ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function] + ## integer.h (module 'core'): ns3::Ptr ns3::internal::MakeIntegerChecker(int64_t min, int64_t max, std::string name) [free function] module.add_function('MakeIntegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('int64_t', 'min'), param('int64_t', 'max'), param('std::string', 'name')]) - ## uinteger.h (module 'core'): extern ns3::Ptr ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function] + ## uinteger.h (module 'core'): ns3::Ptr ns3::internal::MakeUintegerChecker(uint64_t min, uint64_t max, std::string name) [free function] module.add_function('MakeUintegerChecker', 'ns3::Ptr< ns3::AttributeChecker const >', [param('uint64_t', 'min'), param('uint64_t', 'max'), param('std::string', 'name')]) From 4da6cea714cc197219226528f57e1ff7376f4b0d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 8 Aug 2017 12:37:14 -0700 Subject: [PATCH 204/551] network: Update ILP32 bindings --- src/network/bindings/modulegen__gcc_ILP32.py | 2176 ++++++++++++------ 1 file changed, 1420 insertions(+), 756 deletions(-) diff --git a/src/network/bindings/modulegen__gcc_ILP32.py b/src/network/bindings/modulegen__gcc_ILP32.py index 1a8dbf9dff1..0461325a53d 100644 --- a/src/network/bindings/modulegen__gcc_ILP32.py +++ b/src/network/bindings/modulegen__gcc_ILP32.py @@ -22,10 +22,10 @@ def register_types(module): ## packetbb.h (module 'network'): ns3::PbbAddressLength [enumeration] module.add_enum('PbbAddressLength', ['IPV4', 'IPV6']) - ## log.h (module 'core'): ns3::LogLevel [enumeration] - module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') ## ethernet-header.h (module 'network'): ns3::ethernet_header_t [enumeration] module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ']) + ## log.h (module 'core'): ns3::LogLevel [enumeration] + module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') ## address.h (module 'network'): ns3::Address [class] module.add_class('Address') ## address.h (module 'network'): ns3::Address::MaxSize_e [enumeration] @@ -64,6 +64,36 @@ def register_types(module): module.add_class('DataOutputCallback', allow_subclassing=True, import_from_module='ns.stats') ## data-rate.h (module 'network'): ns3::DataRate [class] module.add_class('DataRate') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::NetDeviceQueue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::OutputStreamWrapper']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbAddressBlock']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbMessage']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::PbbTlv']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::QueueItem']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation [class] module.add_class('DelayJitterEstimation') ## event-id.h (module 'core'): ns3::EventId [class] @@ -122,8 +152,8 @@ def register_types(module): module.add_class('PacketMetadata') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item']) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item']) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', outer_class=root_module['ns3::PacketMetadata']) ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress [class] @@ -190,9 +220,9 @@ def register_types(module): module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId']) ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## chunk.h (module 'network'): ns3::Chunk [class] module.add_class('Chunk', parent=root_module['ns3::ObjectBase']) @@ -472,9 +502,9 @@ def register_types(module): module.add_class('PbbTlv', parent=root_module['ns3::SimpleRefCount< ns3::PbbTlv, ns3::empty, ns3::DefaultDeleter >']) ## probe.h (module 'stats'): ns3::Probe [class] module.add_class('Probe', import_from_module='ns.stats', parent=root_module['ns3::DataCollectionObject']) - ## queue.h (module 'network'): ns3::Queue [class] + ## net-device-queue-interface.h (module 'network'): ns3::Queue [class] module.add_class('Queue', template_parameters=['ns3::Packet'], parent=root_module['ns3::QueueBase']) - ## queue.h (module 'network'): ns3::Queue [class] + ## net-device-queue-interface.h (module 'network'): ns3::Queue [class] module.add_class('Queue', template_parameters=['ns3::QueueDiscItem'], parent=root_module['ns3::QueueBase']) ## queue-item.h (module 'network'): ns3::QueueItem [class] module.add_class('QueueItem', parent=root_module['ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter >']) @@ -506,6 +536,36 @@ def register_types(module): module.add_class('BinaryErrorModel', parent=root_module['ns3::ErrorModel']) ## error-model.h (module 'network'): ns3::BurstErrorModel [class] module.add_class('BurstErrorModel', parent=root_module['ns3::ErrorModel']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned int', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator [class] module.add_class('CounterCalculator', import_from_module='ns.stats', template_parameters=['unsigned int'], parent=root_module['ns3::DataCalculator']) ## error-channel.h (module 'network'): ns3::ErrorChannel [class] @@ -522,36 +582,36 @@ def register_types(module): module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type=u'list') module.add_container('std::vector< ns3::Ipv6Address >', 'ns3::Ipv6Address', container_type=u'vector') module.add_container('std::list< unsigned int >', 'unsigned int', container_type=u'list') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >', u'ns3::SequenceNumber16') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >*', u'ns3::SequenceNumber16*') - typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >&', u'ns3::SequenceNumber16&') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >', u'ns3::SequenceNumber32') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >*', u'ns3::SequenceNumber32*') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned int, int >&', u'ns3::SequenceNumber32&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >', u'ns3::SequenceNumber16') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >*', u'ns3::SequenceNumber16*') + typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned short, short >&', u'ns3::SequenceNumber16&') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >', u'ns3::SequenceNumber8') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >*', u'ns3::SequenceNumber8*') typehandlers.add_type_alias(u'ns3::SequenceNumber< unsigned char, signed char >&', u'ns3::SequenceNumber8&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') ## Register a nested module for the namespace FatalImpl @@ -592,12 +652,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -620,39 +680,39 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) *', u'ns3::TracedValueCallback::SequenceNumber32') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) **', u'ns3::TracedValueCallback::SequenceNumber32*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 ) *&', u'ns3::TracedValueCallback::SequenceNumber32&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )', u'ns3::TracedValueCallback::SequenceNumber32') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )*', u'ns3::TracedValueCallback::SequenceNumber32*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::SequenceNumber32, ns3::SequenceNumber32 )&', u'ns3::TracedValueCallback::SequenceNumber32&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_addressUtils(module): root_module = module.get_root() @@ -681,6 +741,21 @@ def register_methods(root_module): register_Ns3ChannelList_methods(root_module, root_module['ns3::ChannelList']) register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback']) register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3NetDeviceQueue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NetDeviceQueue >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::DefaultDeleter< ns3::OutputStreamWrapper >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3PbbAddressBlock_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbAddressBlock >']) + register_Ns3DefaultDeleter__Ns3PbbMessage_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbMessage >']) + register_Ns3DefaultDeleter__Ns3PbbTlv_methods(root_module, root_module['ns3::DefaultDeleter< ns3::PbbTlv >']) + register_Ns3DefaultDeleter__Ns3QueueItem_methods(root_module, root_module['ns3::DefaultDeleter< ns3::QueueItem >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3DelayJitterEstimation_methods(root_module, root_module['ns3::DelayJitterEstimation']) register_Ns3EventId_methods(root_module, root_module['ns3::EventId']) register_Ns3Hasher_methods(root_module, root_module['ns3::Hasher']) @@ -870,6 +945,21 @@ def register_methods(root_module): register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) register_Ns3BinaryErrorModel_methods(root_module, root_module['ns3::BinaryErrorModel']) register_Ns3BurstErrorModel_methods(root_module, root_module['ns3::BurstErrorModel']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Unsigned_char_Ns3Ptr__lt__ns3QueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< unsigned char, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3QueueDiscItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3CounterCalculator__Unsigned_int_methods(root_module, root_module['ns3::CounterCalculator< unsigned int >']) register_Ns3ErrorChannel_methods(root_module, root_module['ns3::ErrorChannel']) register_Ns3PacketCounterCalculator_methods(root_module, root_module['ns3::PacketCounterCalculator']) @@ -884,15 +974,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -954,7 +1044,7 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3ApplicationContainer_methods(root_module, cls): - ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [copy constructor] + ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer(ns3::ApplicationContainer const & arg0) [constructor] cls.add_constructor([param('ns3::ApplicationContainer const &', 'arg0')]) ## application-container.h (module 'network'): ns3::ApplicationContainer::ApplicationContainer() [constructor] cls.add_constructor([]) @@ -974,14 +1064,14 @@ def register_Ns3ApplicationContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'name')]) - ## application-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::Begin() const [member function] + ## application-container.h (module 'network'): ns3::ApplicationContainer::Iterator ns3::ApplicationContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Application > const, std::vector< ns3::Ptr< ns3::Application > > >', + 'ns3::ApplicationContainer::Iterator', [], is_const=True) - ## application-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ApplicationContainer::End() const [member function] + ## application-container.h (module 'network'): ns3::ApplicationContainer::Iterator ns3::ApplicationContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Application > const, std::vector< ns3::Ptr< ns3::Application > > >', + 'ns3::ApplicationContainer::Iterator', [], is_const=True) ## application-container.h (module 'network'): ns3::Ptr ns3::ApplicationContainer::Get(uint32_t i) const [member function] @@ -1017,10 +1107,10 @@ def register_Ns3AsciiFile_methods(root_module, cls): 'bool', [], is_const=True) - ## ascii-file.h (module 'network'): void ns3::AsciiFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## ascii-file.h (module 'network'): void ns3::AsciiFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', - [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) + [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode', default_value='std::ios_base::out')]) ## ascii-file.h (module 'network'): void ns3::AsciiFile::Close() [member function] cls.add_method('Close', 'void', @@ -1037,50 +1127,50 @@ def register_Ns3AsciiFile_methods(root_module, cls): return def register_Ns3AsciiTraceHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::_Ios_Openmode filemode=std::ios_base::out) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::ios_base::openmode filemode=std::ios_base::out) [member function] cls.add_method('CreateFileStream', 'ns3::Ptr< ns3::OutputStreamWrapper >', [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode', default_value='std::ios_base::out')]) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDequeueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDequeueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultDropSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultDropSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultEnqueueSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultEnqueueSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithContext(ns3::Ptr file, std::string context, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('std::string', 'context'), param('ns3::Ptr< ns3::Packet const >', 'p')], is_static=True) - ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] + ## trace-helper.h (module 'network'): static void ns3::AsciiTraceHelper::DefaultReceiveSinkWithoutContext(ns3::Ptr file, ns3::Ptr p) [member function] cls.add_method('DefaultReceiveSinkWithoutContext', 'void', [param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')], @@ -1096,7 +1186,7 @@ def register_Ns3AsciiTraceHelper_methods(root_module, cls): return def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::AsciiTraceHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice() [constructor] cls.add_constructor([]) @@ -1156,25 +1246,25 @@ def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -1184,7 +1274,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -1195,14 +1285,14 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', @@ -1275,7 +1365,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -1435,7 +1525,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -1449,7 +1539,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -1476,7 +1566,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -1510,7 +1600,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -1529,7 +1619,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -1546,7 +1636,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -1563,21 +1653,21 @@ def register_Ns3CallbackBase_methods(root_module, cls): def register_Ns3ChannelList_methods(root_module, cls): ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList() [constructor] cls.add_constructor([]) - ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList(ns3::ChannelList const & arg0) [copy constructor] + ## channel-list.h (module 'network'): ns3::ChannelList::ChannelList(ns3::ChannelList const & arg0) [constructor] cls.add_constructor([param('ns3::ChannelList const &', 'arg0')]) ## channel-list.h (module 'network'): static uint32_t ns3::ChannelList::Add(ns3::Ptr channel) [member function] cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Channel >', 'channel')], is_static=True) - ## channel-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ChannelList::Begin() [member function] + ## channel-list.h (module 'network'): static ns3::ChannelList::Iterator ns3::ChannelList::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', + 'ns3::ChannelList::Iterator', [], is_static=True) - ## channel-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::ChannelList::End() [member function] + ## channel-list.h (module 'network'): static ns3::ChannelList::Iterator ns3::ChannelList::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', + 'ns3::ChannelList::Iterator', [], is_static=True) ## channel-list.h (module 'network'): static ns3::Ptr ns3::ChannelList::GetChannel(uint32_t n) [member function] @@ -1595,7 +1685,7 @@ def register_Ns3ChannelList_methods(root_module, cls): def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback() [constructor] cls.add_constructor([]) - ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')]) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function] cls.add_method('OutputSingleton', @@ -1637,7 +1727,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('>=') - ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRate::DataRate() [constructor] cls.add_constructor([]) @@ -1659,7 +1749,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], - deprecated=True, is_const=True) + is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', 'uint64_t', @@ -1667,8 +1757,188 @@ def register_Ns3DataRate_methods(root_module, cls): is_const=True) return +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NetDeviceQueue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NetDeviceQueue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NetDeviceQueue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NetDeviceQueue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3OutputStreamWrapper_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::OutputStreamWrapper > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::OutputStreamWrapper * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::OutputStreamWrapper *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbAddressBlock_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbAddressBlock > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbAddressBlock * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbAddressBlock *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbMessage_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbMessage > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbMessage * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbMessage *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3PbbTlv_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::PbbTlv > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::PbbTlv * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::PbbTlv *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3QueueItem_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::QueueItem > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::QueueItem * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::QueueItem *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + def register_Ns3DelayJitterEstimation_methods(root_module, cls): - ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [copy constructor] + ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation(ns3::DelayJitterEstimation const & arg0) [constructor] cls.add_constructor([param('ns3::DelayJitterEstimation const &', 'arg0')]) ## delay-jitter-estimation.h (module 'network'): ns3::DelayJitterEstimation::DelayJitterEstimation() [constructor] cls.add_constructor([]) @@ -1682,21 +1952,21 @@ def register_Ns3DelayJitterEstimation_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## delay-jitter-estimation.h (module 'network'): static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr packet) [member function] + ## delay-jitter-estimation.h (module 'network'): static void ns3::DelayJitterEstimation::PrepareTx(ns3::Ptr packet) [member function] cls.add_method('PrepareTx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')], is_static=True) - ## delay-jitter-estimation.h (module 'network'): void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr packet) [member function] + ## delay-jitter-estimation.h (module 'network'): void ns3::DelayJitterEstimation::RecordRx(ns3::Ptr packet) [member function] cls.add_method('RecordRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -1739,7 +2009,7 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -1768,7 +2038,7 @@ def register_Ns3Hasher_methods(root_module, cls): return def register_Ns3Inet6SocketAddress_methods(root_module, cls): - ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor] + ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')]) ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')]) @@ -1811,7 +2081,7 @@ def register_Ns3Inet6SocketAddress_methods(root_module, cls): return def register_Ns3InetSocketAddress_methods(root_module, cls): - ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor] + ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')]) ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')]) @@ -1863,11 +2133,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -1981,10 +2251,10 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -2044,17 +2314,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -2121,7 +2391,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -2243,9 +2513,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -2254,7 +2524,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -2301,10 +2571,10 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -2318,9 +2588,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -2350,11 +2620,11 @@ def register_Ns3LogComponent_methods(root_module, cls): return def register_Ns3Mac16Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address(ns3::Mac16Address const & arg0) [copy constructor] + ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address(ns3::Mac16Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac16Address const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Mac16Address::Mac16Address() [constructor] cls.add_constructor([]) @@ -2387,11 +2657,11 @@ def register_Ns3Mac16Address_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -2459,11 +2729,11 @@ def register_Ns3Mac48Address_methods(root_module, cls): return def register_Ns3Mac64Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [copy constructor] + ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address(ns3::Mac64Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac64Address const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Mac64Address::Mac64Address() [constructor] cls.add_constructor([]) @@ -2496,7 +2766,7 @@ def register_Ns3Mac64Address_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -2518,14 +2788,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -2541,7 +2811,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -2569,9 +2839,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -2582,9 +2852,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -2607,21 +2877,21 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3NodeList_methods(root_module, cls): ## node-list.h (module 'network'): ns3::NodeList::NodeList() [constructor] cls.add_constructor([]) - ## node-list.h (module 'network'): ns3::NodeList::NodeList(ns3::NodeList const & arg0) [copy constructor] + ## node-list.h (module 'network'): ns3::NodeList::NodeList(ns3::NodeList const & arg0) [constructor] cls.add_constructor([param('ns3::NodeList const &', 'arg0')]) ## node-list.h (module 'network'): static uint32_t ns3::NodeList::Add(ns3::Ptr node) [member function] cls.add_method('Add', 'uint32_t', [param('ns3::Ptr< ns3::Node >', 'node')], is_static=True) - ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::Begin() [member function] + ## node-list.h (module 'network'): static ns3::NodeList::Iterator ns3::NodeList::Begin() [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeList::Iterator', [], is_static=True) - ## node-list.h (module 'network'): static __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeList::End() [member function] + ## node-list.h (module 'network'): static ns3::NodeList::Iterator ns3::NodeList::End() [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeList::Iterator', [], is_static=True) ## node-list.h (module 'network'): static uint32_t ns3::NodeList::GetNNodes() [member function] @@ -2645,7 +2915,7 @@ def register_Ns3NonCopyable_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -2706,7 +2976,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -2717,7 +2987,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -2754,7 +3024,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -2832,7 +3102,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -2846,10 +3116,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -2865,7 +3137,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketSocketAddress_methods(root_module, cls): - ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [copy constructor] + ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress(ns3::PacketSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketAddress const &', 'arg0')]) ## packet-socket-address.h (module 'network'): ns3::PacketSocketAddress::PacketSocketAddress() [constructor] cls.add_constructor([]) @@ -2920,7 +3192,7 @@ def register_Ns3PacketSocketAddress_methods(root_module, cls): def register_Ns3PacketSocketHelper_methods(root_module, cls): ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper() [constructor] cls.add_constructor([]) - ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper(ns3::PacketSocketHelper const & arg0) [copy constructor] + ## packet-socket-helper.h (module 'network'): ns3::PacketSocketHelper::PacketSocketHelper(ns3::PacketSocketHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketHelper const &', 'arg0')]) ## packet-socket-helper.h (module 'network'): void ns3::PacketSocketHelper::Install(ns3::Ptr node) const [member function] cls.add_method('Install', @@ -2940,7 +3212,7 @@ def register_Ns3PacketSocketHelper_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2954,7 +3226,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -2971,7 +3243,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -3005,7 +3277,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -3020,7 +3292,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -3029,7 +3301,7 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock(ns3::PbbAddressTlvBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock(ns3::PbbAddressTlvBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressTlvBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::PbbAddressTlvBlock() [constructor] cls.add_constructor([]) @@ -3038,13 +3310,13 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv >', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Begin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Begin() [member function] cls.add_method('Begin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressTlvBlock::Begin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::ConstIterator ns3::PbbAddressTlvBlock::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::ConstIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressTlvBlock::Clear() [member function] @@ -3060,23 +3332,23 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::End() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::End() [member function] cls.add_method('End', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressTlvBlock::End() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::ConstIterator ns3::PbbAddressTlvBlock::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressTlvBlock::ConstIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Erase(ns3::PbbAddressTlvBlock::Iterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Erase(ns3::PbbAddressTlvBlock::Iterator first, ns3::PbbAddressTlvBlock::Iterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'last')]) + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbAddressTlvBlock::Front() const [member function] cls.add_method('Front', 'ns3::Ptr< ns3::PbbAddressTlv >', @@ -3087,10 +3359,10 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressTlvBlock::Insert(std::_List_iterator > position, ns3::Ptr const tlv) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressTlvBlock::Iterator ns3::PbbAddressTlvBlock::Insert(ns3::PbbAddressTlvBlock::Iterator position, ns3::Ptr const tlv) [member function] cls.add_method('Insert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position'), param('ns3::Ptr< ns3::PbbAddressTlv > const', 'tlv')]) + 'ns3::PbbAddressTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressTlv > > iterator', 'position'), param('ns3::Ptr< ns3::PbbAddressTlv > const', 'tlv')]) ## packetbb.h (module 'network'): void ns3::PbbAddressTlvBlock::PopBack() [member function] cls.add_method('PopBack', 'void', @@ -3132,7 +3404,7 @@ def register_Ns3PbbAddressTlvBlock_methods(root_module, cls): def register_Ns3PbbTlvBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock(ns3::PbbTlvBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock(ns3::PbbTlvBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbTlvBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbTlvBlock::PbbTlvBlock() [constructor] cls.add_constructor([]) @@ -3141,13 +3413,13 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv >', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Begin() [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Begin() [member function] cls.add_method('Begin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbTlvBlock::Begin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::ConstIterator ns3::PbbTlvBlock::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::ConstIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbTlvBlock::Clear() [member function] @@ -3163,23 +3435,23 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::End() [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::End() [member function] cls.add_method('End', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::Iterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbTlvBlock::End() const [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::ConstIterator ns3::PbbTlvBlock::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbTlvBlock::ConstIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Erase(ns3::PbbTlvBlock::Iterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Erase(ns3::PbbTlvBlock::Iterator first, ns3::PbbTlvBlock::Iterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbTlvBlock::Front() const [member function] cls.add_method('Front', 'ns3::Ptr< ns3::PbbTlv >', @@ -3190,10 +3462,10 @@ def register_Ns3PbbTlvBlock_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbTlvBlock::Insert(std::_List_iterator > position, ns3::Ptr const tlv) [member function] + ## packetbb.h (module 'network'): ns3::PbbTlvBlock::Iterator ns3::PbbTlvBlock::Insert(ns3::PbbTlvBlock::Iterator position, ns3::Ptr const tlv) [member function] cls.add_method('Insert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'tlv')]) + 'ns3::PbbTlvBlock::Iterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'tlv')]) ## packetbb.h (module 'network'): void ns3::PbbTlvBlock::PopBack() [member function] cls.add_method('PopBack', 'void', @@ -3298,7 +3570,7 @@ def register_Ns3PcapFile_methods(root_module, cls): cls.add_method('IsNanoSecMode', 'bool', []) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) @@ -3310,11 +3582,11 @@ def register_Ns3PcapFile_methods(root_module, cls): cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('uint8_t const * const', 'data'), param('uint32_t', 'totalLen')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] + ## pcap-file.h (module 'network'): void ns3::PcapFile::Write(uint32_t tsSec, uint32_t tsUsec, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) @@ -3325,11 +3597,11 @@ def register_Ns3PcapFile_methods(root_module, cls): return def register_Ns3PcapHelper_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelper const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper() [constructor] cls.add_constructor([]) - ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::_Ios_Openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] + ## trace-helper.h (module 'network'): ns3::Ptr ns3::PcapHelper::CreateFile(std::string filename, std::ios_base::openmode filemode, ns3::PcapHelper::DataLinkType dataLinkType, uint32_t snapLen=std::numeric_limits::max(), int32_t tzCorrection=0) [member function] cls.add_method('CreateFile', 'ns3::Ptr< ns3::PcapFileWrapper >', [param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('ns3::PcapHelper::DataLinkType', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='0')]) @@ -3344,7 +3616,7 @@ def register_Ns3PcapHelper_methods(root_module, cls): return def register_Ns3PcapHelperForDevice_methods(root_module, cls): - ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [copy constructor] + ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [constructor] cls.add_constructor([param('ns3::PcapHelperForDevice const &', 'arg0')]) ## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice() [constructor] cls.add_constructor([]) @@ -3395,7 +3667,7 @@ def register_Ns3SequenceNumber32_methods(root_module, cls): cls.add_constructor([]) ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(unsigned int value) [constructor] cls.add_constructor([param('unsigned int', 'value')]) - ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [copy constructor] + ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber< unsigned int, int > const &', 'value')]) ## sequence-number.h (module 'network'): unsigned int ns3::SequenceNumber::GetValue() const [member function] cls.add_method('GetValue', @@ -3420,7 +3692,7 @@ def register_Ns3SequenceNumber16_methods(root_module, cls): cls.add_constructor([]) ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(short unsigned int value) [constructor] cls.add_constructor([param('short unsigned int', 'value')]) - ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [copy constructor] + ## sequence-number.h (module 'network'): ns3::SequenceNumber::SequenceNumber(ns3::SequenceNumber const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber< unsigned short, short > const &', 'value')]) ## sequence-number.h (module 'network'): short unsigned int ns3::SequenceNumber::GetValue() const [member function] cls.add_method('GetValue', @@ -3430,7 +3702,7 @@ def register_Ns3SequenceNumber16_methods(root_module, cls): return def register_Ns3SimpleNetDeviceHelper_methods(root_module, cls): - ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper(ns3::SimpleNetDeviceHelper const & arg0) [copy constructor] + ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper(ns3::SimpleNetDeviceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleNetDeviceHelper const &', 'arg0')]) ## simple-net-device-helper.h (module 'network'): ns3::SimpleNetDeviceHelper::SimpleNetDeviceHelper() [constructor] cls.add_constructor([]) @@ -3479,7 +3751,7 @@ def register_Ns3SimpleNetDeviceHelper_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -3489,7 +3761,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -3571,7 +3843,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3StatisticalSummary_methods(root_module, cls): ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary() [constructor] cls.add_constructor([]) - ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [constructor] cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')]) ## data-calculator.h (module 'stats'): long int ns3::StatisticalSummary::getCount() const [member function] cls.add_method('getCount', @@ -3616,7 +3888,7 @@ def register_Ns3StatisticalSummary_methods(root_module, cls): return def register_Ns3SystemWallClockMs_methods(root_module, cls): - ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [copy constructor] + ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs(ns3::SystemWallClockMs const & arg0) [constructor] cls.add_constructor([param('ns3::SystemWallClockMs const &', 'arg0')]) ## system-wall-clock-ms.h (module 'core'): ns3::SystemWallClockMs::SystemWallClockMs() [constructor] cls.add_constructor([]) @@ -3648,7 +3920,7 @@ def register_Ns3SystemWallClockMs_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -3678,7 +3950,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -3722,14 +3994,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -3742,7 +4014,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -3751,11 +4023,15 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(unsigned int const & v) [constructor] cls.add_constructor([param('unsigned int const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< unsigned int > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -3763,7 +4039,7 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -3783,33 +4059,32 @@ def register_Ns3TracedValue__Unsigned_int_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -3825,7 +4100,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -3835,9 +4110,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -3904,12 +4179,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -3919,12 +4194,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -3934,7 +4209,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -3950,12 +4225,12 @@ def register_Ns3TypeId_methods(root_module, cls): cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::Object']) + template_parameters=[u'ns3::QueueBase']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent() [member function] cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::QueueBase']) + template_parameters=[u'ns3::Object']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', @@ -3969,13 +4244,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -3994,7 +4268,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -4013,81 +4287,81 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -4107,7 +4381,7 @@ def register_Ns3Chunk_methods(root_module, cls): return def register_Ns3DeviceNameTag_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag(ns3::DeviceNameTag const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag(ns3::DeviceNameTag const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceNameTag const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::DeviceNameTag::DeviceNameTag() [constructor] cls.add_constructor([]) @@ -4153,7 +4427,7 @@ def register_Ns3DeviceNameTag_methods(root_module, cls): return def register_Ns3FlowIdTag_methods(root_module, cls): - ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag(ns3::FlowIdTag const & arg0) [copy constructor] + ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag(ns3::FlowIdTag const & arg0) [constructor] cls.add_constructor([param('ns3::FlowIdTag const &', 'arg0')]) ## flow-id-tag.h (module 'network'): ns3::FlowIdTag::FlowIdTag() [constructor] cls.add_constructor([]) @@ -4209,7 +4483,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -4239,7 +4513,7 @@ def register_Ns3Header_methods(root_module, cls): return def register_Ns3LlcSnapHeader_methods(root_module, cls): - ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [copy constructor] + ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader(ns3::LlcSnapHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LlcSnapHeader const &', 'arg0')]) ## llc-snap-header.h (module 'network'): ns3::LlcSnapHeader::LlcSnapHeader() [constructor] cls.add_constructor([]) @@ -4308,7 +4582,7 @@ def register_Ns3Object_methods(root_module, cls): cls.add_method('GetObject', 'ns3::Ptr< ns3::NetDevice >', [], - is_const=True, template_parameters=['ns3::NetDevice']) + is_const=True, template_parameters=[u'ns3::NetDevice']) ## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -4323,7 +4597,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -4344,7 +4618,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -4353,14 +4627,14 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) return def register_Ns3PacketBurst_methods(root_module, cls): - ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor] + ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [constructor] cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')]) ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor] cls.add_constructor([]) @@ -4368,9 +4642,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): cls.add_method('AddPacket', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')]) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::Begin() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): ns3::Ptr ns3::PacketBurst::Copy() const [member function] @@ -4378,9 +4652,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): 'ns3::Ptr< ns3::PacketBurst >', [], is_const=True) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::End() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function] @@ -4411,7 +4685,7 @@ def register_Ns3PacketBurst_methods(root_module, cls): return def register_Ns3PacketSocketTag_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag(ns3::PacketSocketTag const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag(ns3::PacketSocketTag const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketTag const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::PacketSocketTag::PacketSocketTag() [constructor] cls.add_constructor([]) @@ -4487,7 +4761,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): cls.add_method('Clear', 'void', []) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::_Ios_Openmode mode) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Open(std::string const & filename, std::ios_base::openmode mode) [member function] cls.add_method('Open', 'void', [param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')]) @@ -4499,11 +4773,11 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): cls.add_method('Init', 'void', [param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='std::numeric_limits::max()'), param('int32_t', 'tzCorrection', default_value='ns3::PcapFile::ZONE_DEFAULT')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] + ## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Write(ns3::Time t, ns3::Header const & header, ns3::Ptr p) [member function] cls.add_method('Write', 'void', [param('ns3::Time', 't'), param('ns3::Header const &', 'header'), param('ns3::Ptr< ns3::Packet const >', 'p')]) @@ -4546,7 +4820,7 @@ def register_Ns3PcapFileWrapper_methods(root_module, cls): return def register_Ns3QueueBase_methods(root_module, cls): - ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [copy constructor] + ## queue.h (module 'network'): ns3::QueueBase::QueueBase(ns3::QueueBase const & arg0) [constructor] cls.add_constructor([param('ns3::QueueBase const &', 'arg0')]) ## queue.h (module 'network'): ns3::QueueBase::QueueBase() [constructor] cls.add_constructor([]) @@ -4646,17 +4920,12 @@ def register_Ns3QueueBase_methods(root_module, cls): cls.add_method('SetMode', 'void', [param('ns3::QueueBase::QueueMode', 'mode')]) - ## queue.h (module 'network'): void ns3::QueueBase::DoNsLog(ns3::LogLevel const level, std::string str) const [member function] - cls.add_method('DoNsLog', - 'void', - [param('ns3::LogLevel const', 'level'), param('std::string', 'str')], - is_const=True, visibility='protected') return def register_Ns3QueueLimits_methods(root_module, cls): ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits() [constructor] cls.add_constructor([]) - ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits(ns3::QueueLimits const & arg0) [copy constructor] + ## queue-limits.h (module 'network'): ns3::QueueLimits::QueueLimits(ns3::QueueLimits const & arg0) [constructor] cls.add_constructor([param('ns3::QueueLimits const &', 'arg0')]) ## queue-limits.h (module 'network'): int32_t ns3::QueueLimits::Available() const [member function] cls.add_method('Available', @@ -4686,7 +4955,7 @@ def register_Ns3QueueLimits_methods(root_module, cls): return def register_Ns3RadiotapHeader_methods(root_module, cls): - ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [copy constructor] + ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader(ns3::RadiotapHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RadiotapHeader const &', 'arg0')]) ## radiotap-header.h (module 'network'): ns3::RadiotapHeader::RadiotapHeader() [constructor] cls.add_constructor([]) @@ -4954,7 +5223,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4966,7 +5235,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4978,7 +5247,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -4990,7 +5259,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5002,7 +5271,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5014,7 +5283,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5026,7 +5295,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3NetDeviceQueue_Ns3Empty_Ns3DefaultDeleter__lt__ns3NetDeviceQueue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NetDeviceQueue, ns3::empty, ns3::DefaultDeleter< ns3::NetDeviceQueue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5038,7 +5307,7 @@ def register_Ns3SimpleRefCount__Ns3NetDeviceQueue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5050,7 +5319,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter< ns3::OutputStreamWrapper > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5062,7 +5331,7 @@ def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5074,7 +5343,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbAddressBlock__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbAddressBlock, ns3::empty, ns3::DefaultDeleter< ns3::PbbAddressBlock > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5086,7 +5355,7 @@ def register_Ns3SimpleRefCount__Ns3PbbAddressBlock_Ns3Empty_Ns3DefaultDeleter__l def register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbMessage__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbMessage, ns3::empty, ns3::DefaultDeleter< ns3::PbbMessage > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5098,7 +5367,7 @@ def register_Ns3SimpleRefCount__Ns3PbbMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3PbbPacket_Ns3Header_Ns3DefaultDeleter__lt__ns3PbbPacket__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbPacket, ns3::Header, ns3::DefaultDeleter< ns3::PbbPacket > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5110,7 +5379,7 @@ def register_Ns3SimpleRefCount__Ns3PbbPacket_Ns3Header_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3PbbTlv_Ns3Empty_Ns3DefaultDeleter__lt__ns3PbbTlv__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::PbbTlv, ns3::empty, ns3::DefaultDeleter< ns3::PbbTlv > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5122,7 +5391,7 @@ def register_Ns3SimpleRefCount__Ns3PbbTlv_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pbb def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3QueueItem__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::QueueItem, ns3::empty, ns3::DefaultDeleter< ns3::QueueItem > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5134,7 +5403,7 @@ def register_Ns3SimpleRefCount__Ns3QueueItem_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -5144,7 +5413,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete return def register_Ns3SllHeader_methods(root_module, cls): - ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader(ns3::SllHeader const & arg0) [copy constructor] + ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader(ns3::SllHeader const & arg0) [constructor] cls.add_constructor([param('ns3::SllHeader const &', 'arg0')]) ## sll-header.h (module 'network'): ns3::SllHeader::SllHeader() [constructor] cls.add_constructor([]) @@ -5199,7 +5468,7 @@ def register_Ns3SllHeader_methods(root_module, cls): return def register_Ns3Socket_methods(root_module, cls): - ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [constructor] cls.add_constructor([param('ns3::Socket const &', 'arg0')]) ## socket.h (module 'network'): ns3::Socket::Socket() [constructor] cls.add_constructor([]) @@ -5317,7 +5586,7 @@ def register_Ns3Socket_methods(root_module, cls): 'uint8_t', [param('uint8_t', 'ipTos')], is_static=True) - ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] + ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] cls.add_method('Ipv6JoinGroup', 'void', [param('ns3::Ipv6Address', 'address'), param('ns3::Socket::Ipv6MulticastFilterMode', 'filterMode'), param('std::vector< ns3::Ipv6Address >', 'sourceAddresses')], @@ -5410,7 +5679,7 @@ def register_Ns3Socket_methods(root_module, cls): cls.add_method('SendTo', 'int', [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')]) - ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] + ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] cls.add_method('SetAcceptCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')]) @@ -5559,7 +5828,7 @@ def register_Ns3Socket_methods(root_module, cls): return def register_Ns3SocketFactory_methods(root_module, cls): - ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [copy constructor] + ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory(ns3::SocketFactory const & arg0) [constructor] cls.add_constructor([param('ns3::SocketFactory const &', 'arg0')]) ## socket-factory.h (module 'network'): ns3::SocketFactory::SocketFactory() [constructor] cls.add_constructor([]) @@ -5576,7 +5845,7 @@ def register_Ns3SocketFactory_methods(root_module, cls): return def register_Ns3SocketIpTosTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTosTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag() [constructor] cls.add_constructor([]) @@ -5622,7 +5891,7 @@ def register_Ns3SocketIpTosTag_methods(root_module, cls): return def register_Ns3SocketIpTtlTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor] cls.add_constructor([]) @@ -5668,7 +5937,7 @@ def register_Ns3SocketIpTtlTag_methods(root_module, cls): return def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6HopLimitTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag() [constructor] cls.add_constructor([]) @@ -5714,7 +5983,7 @@ def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): return def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6TclassTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag() [constructor] cls.add_constructor([]) @@ -5760,7 +6029,7 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): return def register_Ns3SocketPriorityTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor] cls.add_constructor([]) @@ -5806,7 +6075,7 @@ def register_Ns3SocketPriorityTag_methods(root_module, cls): return def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor] cls.add_constructor([]) @@ -5856,22 +6125,22 @@ def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -6054,7 +6323,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -6084,7 +6353,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -6309,7 +6578,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3Application_methods(root_module, cls): - ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [copy constructor] + ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [constructor] cls.add_constructor([param('ns3::Application const &', 'arg0')]) ## application.h (module 'network'): ns3::Application::Application() [constructor] cls.add_constructor([]) @@ -6358,7 +6627,7 @@ def register_Ns3Application_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -6385,7 +6654,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -6427,7 +6696,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -6436,12 +6705,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6451,13 +6720,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -6468,7 +6737,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6478,7 +6747,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6492,21 +6761,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -6516,10 +6785,75 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -6530,12 +6864,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6547,7 +6881,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -6607,7 +6941,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DataCalculator_methods(root_module, cls): - ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')]) ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator() [constructor] cls.add_constructor([]) @@ -6670,7 +7004,7 @@ def register_Ns3DataCalculator_methods(root_module, cls): return def register_Ns3DataCollectionObject_methods(root_module, cls): - ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject(ns3::DataCollectionObject const & arg0) [copy constructor] + ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject(ns3::DataCollectionObject const & arg0) [constructor] cls.add_constructor([param('ns3::DataCollectionObject const &', 'arg0')]) ## data-collection-object.h (module 'stats'): ns3::DataCollectionObject::DataCollectionObject() [constructor] cls.add_constructor([]) @@ -6704,7 +7038,7 @@ def register_Ns3DataCollectionObject_methods(root_module, cls): return def register_Ns3DataOutputInterface_methods(root_module, cls): - ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')]) ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface() [constructor] cls.add_constructor([]) @@ -6737,23 +7071,23 @@ def register_Ns3DataOutputInterface_methods(root_module, cls): def register_Ns3DataRateChecker_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')]) return def register_Ns3DataRateValue_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'value')]) + ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::Ptr ns3::DataRateValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6763,7 +7097,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): 'ns3::DataRate', [], is_const=True) - ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6801,16 +7135,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6820,7 +7154,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6832,7 +7166,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): return def register_Ns3DynamicQueueLimits_methods(root_module, cls): - ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits(ns3::DynamicQueueLimits const & arg0) [copy constructor] + ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits(ns3::DynamicQueueLimits const & arg0) [constructor] cls.add_constructor([param('ns3::DynamicQueueLimits const &', 'arg0')]) ## dynamic-queue-limits.h (module 'network'): ns3::DynamicQueueLimits::DynamicQueueLimits() [constructor] cls.add_constructor([]) @@ -6898,7 +7232,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -6925,7 +7259,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -6962,7 +7296,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -6971,12 +7305,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6984,7 +7318,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -7029,7 +7363,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -7040,7 +7374,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7050,7 +7384,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7100,7 +7434,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3ErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel(ns3::ErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ErrorModel::ErrorModel() [constructor] cls.add_constructor([]) @@ -7143,7 +7477,7 @@ def register_Ns3ErrorModel_methods(root_module, cls): return def register_Ns3EthernetHeader_methods(root_module, cls): - ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [copy constructor] + ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(ns3::EthernetHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EthernetHeader const &', 'arg0')]) ## ethernet-header.h (module 'network'): ns3::EthernetHeader::EthernetHeader(bool hasPreamble) [constructor] cls.add_constructor([param('bool', 'hasPreamble')]) @@ -7228,15 +7562,15 @@ def register_Ns3EthernetHeader_methods(root_module, cls): return def register_Ns3EthernetTrailer_methods(root_module, cls): - ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [copy constructor] + ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer(ns3::EthernetTrailer const & arg0) [constructor] cls.add_constructor([param('ns3::EthernetTrailer const &', 'arg0')]) ## ethernet-trailer.h (module 'network'): ns3::EthernetTrailer::EthernetTrailer() [constructor] cls.add_constructor([]) - ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::CalcFcs(ns3::Ptr p) [member function] + ## ethernet-trailer.h (module 'network'): void ns3::EthernetTrailer::CalcFcs(ns3::Ptr p) [member function] cls.add_method('CalcFcs', 'void', [param('ns3::Ptr< ns3::Packet const >', 'p')]) - ## ethernet-trailer.h (module 'network'): bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr p) const [member function] + ## ethernet-trailer.h (module 'network'): bool ns3::EthernetTrailer::CheckFcs(ns3::Ptr p) const [member function] cls.add_method('CheckFcs', 'bool', [param('ns3::Ptr< ns3::Packet const >', 'p')], @@ -7292,7 +7626,7 @@ def register_Ns3EthernetTrailer_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -7394,16 +7728,16 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7413,7 +7747,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7427,23 +7761,23 @@ def register_Ns3IntegerValue_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7453,7 +7787,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7467,23 +7801,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7493,7 +7827,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7507,23 +7841,23 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7533,7 +7867,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7547,23 +7881,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7573,7 +7907,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7585,7 +7919,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): return def register_Ns3ListErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel(ns3::ListErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ListErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ListErrorModel::ListErrorModel() [constructor] cls.add_constructor([]) @@ -7656,23 +7990,23 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): def register_Ns3Mac16AddressChecker_methods(root_module, cls): ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker() [constructor] cls.add_constructor([]) - ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker(ns3::Mac16AddressChecker const & arg0) [copy constructor] + ## mac16-address.h (module 'network'): ns3::Mac16AddressChecker::Mac16AddressChecker(ns3::Mac16AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac16AddressChecker const &', 'arg0')]) return def register_Ns3Mac16AddressValue_methods(root_module, cls): ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue() [constructor] cls.add_constructor([]) - ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac16AddressValue const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16Address const & value) [constructor] cls.add_constructor([param('ns3::Mac16Address const &', 'value')]) + ## mac16-address.h (module 'network'): ns3::Mac16AddressValue::Mac16AddressValue(ns3::Mac16AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac16AddressValue const &', 'arg0')]) ## mac16-address.h (module 'network'): ns3::Ptr ns3::Mac16AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac16-address.h (module 'network'): bool ns3::Mac16AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac16-address.h (module 'network'): bool ns3::Mac16AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7682,7 +8016,7 @@ def register_Ns3Mac16AddressValue_methods(root_module, cls): 'ns3::Mac16Address', [], is_const=True) - ## mac16-address.h (module 'network'): std::string ns3::Mac16AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac16-address.h (module 'network'): std::string ns3::Mac16AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7696,23 +8030,23 @@ def register_Ns3Mac16AddressValue_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7722,7 +8056,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7736,23 +8070,23 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): def register_Ns3Mac64AddressChecker_methods(root_module, cls): ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker() [constructor] cls.add_constructor([]) - ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker(ns3::Mac64AddressChecker const & arg0) [copy constructor] + ## mac64-address.h (module 'network'): ns3::Mac64AddressChecker::Mac64AddressChecker(ns3::Mac64AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac64AddressChecker const &', 'arg0')]) return def register_Ns3Mac64AddressValue_methods(root_module, cls): ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue() [constructor] cls.add_constructor([]) - ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac64AddressValue const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64Address const & value) [constructor] cls.add_constructor([param('ns3::Mac64Address const &', 'value')]) + ## mac64-address.h (module 'network'): ns3::Mac64AddressValue::Mac64AddressValue(ns3::Mac64AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac64AddressValue const &', 'arg0')]) ## mac64-address.h (module 'network'): ns3::Ptr ns3::Mac64AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac64-address.h (module 'network'): bool ns3::Mac64AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac64-address.h (module 'network'): bool ns3::Mac64AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7762,7 +8096,7 @@ def register_Ns3Mac64AddressValue_methods(root_module, cls): 'ns3::Mac64Address', [], is_const=True) - ## mac64-address.h (module 'network'): std::string ns3::Mac64AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac64-address.h (module 'network'): std::string ns3::Mac64AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7774,7 +8108,7 @@ def register_Ns3Mac64AddressValue_methods(root_module, cls): return def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls): - ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [copy constructor] + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')]) ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) @@ -7846,7 +8180,7 @@ def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls) def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -7958,12 +8292,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -7976,7 +8310,7 @@ def register_Ns3NetDevice_methods(root_module, cls): return def register_Ns3NetDeviceQueue_methods(root_module, cls): - ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue(ns3::NetDeviceQueue const & arg0) [copy constructor] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue(ns3::NetDeviceQueue const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceQueue const &', 'arg0')]) ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueue::NetDeviceQueue() [constructor] cls.add_constructor([]) @@ -8005,7 +8339,7 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): cls.add_method('SetQueueLimits', 'void', [param('ns3::Ptr< ns3::QueueLimits >', 'ql')]) - ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::SetWakeCallback(ns3::Callback cb) [member function] + ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueue::SetWakeCallback(ns3::NetDeviceQueue::WakeCallback cb) [member function] cls.add_method('SetWakeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -8028,7 +8362,7 @@ def register_Ns3NetDeviceQueue_methods(root_module, cls): return def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): - ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface(ns3::NetDeviceQueueInterface const & arg0) [copy constructor] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface(ns3::NetDeviceQueueInterface const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceQueueInterface const &', 'arg0')]) ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::NetDeviceQueueInterface() [constructor] cls.add_constructor([]) @@ -8046,9 +8380,9 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): 'uint8_t', [], is_const=True) - ## net-device-queue-interface.h (module 'network'): ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function] + ## net-device-queue-interface.h (module 'network'): ns3::NetDeviceQueueInterface::SelectQueueCallback ns3::NetDeviceQueueInterface::GetSelectQueueCallback() const [member function] cls.add_method('GetSelectQueueCallback', - 'ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', + 'ns3::NetDeviceQueueInterface::SelectQueueCallback', [], is_const=True) ## net-device-queue-interface.h (module 'network'): ns3::Ptr ns3::NetDeviceQueueInterface::GetTxQueue(uint8_t i) const [member function] @@ -8065,7 +8399,7 @@ def register_Ns3NetDeviceQueueInterface_methods(root_module, cls): cls.add_method('SetLateTxQueuesCreation', 'void', [param('bool', 'value')]) - ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetSelectQueueCallback(ns3::Callback, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device-queue-interface.h (module 'network'): void ns3::NetDeviceQueueInterface::SetSelectQueueCallback(ns3::NetDeviceQueueInterface::SelectQueueCallback cb) [member function] cls.add_method('SetSelectQueueCallback', 'void', [param('ns3::Callback< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')]) @@ -8084,7 +8418,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -8125,7 +8459,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -8184,19 +8518,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -8260,23 +8594,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8286,7 +8620,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8298,10 +8632,10 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): return def register_Ns3OutputStreamWrapper_methods(root_module, cls): - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy constructor] + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [constructor] cls.add_constructor([param('ns3::OutputStreamWrapper const &', 'arg0')]) - ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::_Ios_Openmode filemode) [constructor] - cls.add_constructor([param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode')]) + ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::string filename, std::ios_base::openmode filemode) [constructor] + cls.add_constructor([param('std::string', 'filename'), param('std::ios_base::openmode', 'filemode')]) ## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(std::ostream * os) [constructor] cls.add_constructor([param('std::ostream *', 'os')]) ## output-stream-wrapper.h (module 'network'): std::ostream * ns3::OutputStreamWrapper::GetStream() [member function] @@ -8314,7 +8648,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -8322,7 +8656,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size'), param('bool', 'magic')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size) [constructor] cls.add_constructor([param('uint8_t const *', 'buffer'), param('uint32_t', 'size')]) - ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] + ## packet.h (module 'network'): void ns3::Packet::AddAtEnd(ns3::Ptr packet) [member function] cls.add_method('AddAtEnd', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -8496,11 +8830,11 @@ def register_Ns3Packet_methods(root_module, cls): return def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): - ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [copy constructor] + ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator(ns3::PacketSizeMinMaxAvgTotalCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSizeMinMaxAvgTotalCalculator const &', 'arg0')]) ## packet-data-calculators.h (module 'network'): ns3::PacketSizeMinMaxAvgTotalCalculator::PacketSizeMinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) - ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] cls.add_method('FrameUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')]) @@ -8509,7 +8843,7 @@ def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketSizeMinMaxAvgTotalCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] cls.add_method('PacketUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -8521,7 +8855,7 @@ def register_Ns3PacketSizeMinMaxAvgTotalCalculator_methods(root_module, cls): return def register_Ns3PacketSocket_methods(root_module, cls): - ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket(ns3::PacketSocket const & arg0) [copy constructor] + ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket(ns3::PacketSocket const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocket const &', 'arg0')]) ## packet-socket.h (module 'network'): ns3::PacketSocket::PacketSocket() [constructor] cls.add_constructor([]) @@ -8647,7 +8981,7 @@ def register_Ns3PacketSocket_methods(root_module, cls): return def register_Ns3PacketSocketClient_methods(root_module, cls): - ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient(ns3::PacketSocketClient const & arg0) [copy constructor] + ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient(ns3::PacketSocketClient const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketClient const &', 'arg0')]) ## packet-socket-client.h (module 'network'): ns3::PacketSocketClient::PacketSocketClient() [constructor] cls.add_constructor([]) @@ -8683,7 +9017,7 @@ def register_Ns3PacketSocketClient_methods(root_module, cls): return def register_Ns3PacketSocketFactory_methods(root_module, cls): - ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [copy constructor] + ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory(ns3::PacketSocketFactory const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketFactory const &', 'arg0')]) ## packet-socket-factory.h (module 'network'): ns3::PacketSocketFactory::PacketSocketFactory() [constructor] cls.add_constructor([]) @@ -8700,7 +9034,7 @@ def register_Ns3PacketSocketFactory_methods(root_module, cls): return def register_Ns3PacketSocketServer_methods(root_module, cls): - ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer(ns3::PacketSocketServer const & arg0) [copy constructor] + ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer(ns3::PacketSocketServer const & arg0) [constructor] cls.add_constructor([param('ns3::PacketSocketServer const &', 'arg0')]) ## packet-socket-server.h (module 'network'): ns3::PacketSocketServer::PacketSocketServer() [constructor] cls.add_constructor([]) @@ -8742,7 +9076,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -8781,7 +9115,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PbbAddressBlock_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock(ns3::PbbAddressBlock const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock(ns3::PbbAddressBlock const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlock const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PbbAddressBlock() [constructor] cls.add_constructor([]) @@ -8790,13 +9124,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressBegin() [member function] cls.add_method('AddressBegin', - 'std::_List_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::AddressIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::AddressBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstAddressIterator ns3::PbbAddressBlock::AddressBegin() const [member function] cls.add_method('AddressBegin', - 'std::_List_const_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::ConstAddressIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::AddressClear() [member function] @@ -8808,32 +9142,32 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressEnd() [member function] cls.add_method('AddressEnd', - 'std::_List_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::AddressIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::AddressEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstAddressIterator ns3::PbbAddressBlock::AddressEnd() const [member function] cls.add_method('AddressEnd', - 'std::_List_const_iterator< ns3::Address >', + 'ns3::PbbAddressBlock::ConstAddressIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressErase(std::_List_iterator position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressErase(ns3::PbbAddressBlock::AddressIterator position) [member function] cls.add_method('AddressErase', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressErase(std::_List_iterator first, std::_List_iterator last) [member function] + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressErase(ns3::PbbAddressBlock::AddressIterator first, ns3::PbbAddressBlock::AddressIterator last) [member function] cls.add_method('AddressErase', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'first'), param('std::_List_iterator< ns3::Address >', 'last')]) + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'first'), param('std::list< ns3::Address > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Address ns3::PbbAddressBlock::AddressFront() const [member function] cls.add_method('AddressFront', 'ns3::Address', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::AddressInsert(std::_List_iterator position, ns3::Address const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::AddressIterator ns3::PbbAddressBlock::AddressInsert(ns3::PbbAddressBlock::AddressIterator position, ns3::Address const value) [member function] cls.add_method('AddressInsert', - 'std::_List_iterator< ns3::Address >', - [param('std::_List_iterator< ns3::Address >', 'position'), param('ns3::Address const', 'value')]) + 'ns3::PbbAddressBlock::AddressIterator', + [param('std::list< ns3::Address > iterator', 'position'), param('ns3::Address const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::AddressPopBack() [member function] cls.add_method('AddressPopBack', 'void', @@ -8869,13 +9203,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'uint8_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixBegin() [member function] cls.add_method('PrefixBegin', - 'std::_List_iterator< unsigned char >', + 'ns3::PbbAddressBlock::PrefixIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::PrefixBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstPrefixIterator ns3::PbbAddressBlock::PrefixBegin() const [member function] cls.add_method('PrefixBegin', - 'std::_List_const_iterator< unsigned char >', + 'ns3::PbbAddressBlock::ConstPrefixIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixClear() [member function] @@ -8887,32 +9221,32 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixEnd() [member function] cls.add_method('PrefixEnd', - 'std::_List_iterator< unsigned char >', + 'ns3::PbbAddressBlock::PrefixIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator ns3::PbbAddressBlock::PrefixEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstPrefixIterator ns3::PbbAddressBlock::PrefixEnd() const [member function] cls.add_method('PrefixEnd', - 'std::_List_const_iterator< unsigned char >', + 'ns3::PbbAddressBlock::ConstPrefixIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixErase(std::_List_iterator position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixErase(ns3::PbbAddressBlock::PrefixIterator position) [member function] cls.add_method('PrefixErase', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixErase(std::_List_iterator first, std::_List_iterator last) [member function] + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixErase(ns3::PbbAddressBlock::PrefixIterator first, ns3::PbbAddressBlock::PrefixIterator last) [member function] cls.add_method('PrefixErase', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'first'), param('std::_List_iterator< unsigned char >', 'last')]) + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'first'), param('std::list< unsigned char > iterator', 'last')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbAddressBlock::PrefixFront() const [member function] cls.add_method('PrefixFront', 'uint8_t', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator ns3::PbbAddressBlock::PrefixInsert(std::_List_iterator position, uint8_t const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::PrefixIterator ns3::PbbAddressBlock::PrefixInsert(ns3::PbbAddressBlock::PrefixIterator position, uint8_t const value) [member function] cls.add_method('PrefixInsert', - 'std::_List_iterator< unsigned char >', - [param('std::_List_iterator< unsigned char >', 'position'), param('uint8_t const', 'value')]) + 'ns3::PbbAddressBlock::PrefixIterator', + [param('std::list< unsigned char > iterator', 'position'), param('uint8_t const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrefixPopBack() [member function] cls.add_method('PrefixPopBack', 'void', @@ -8958,13 +9292,13 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressBlock::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstTlvIterator ns3::PbbAddressBlock::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::TlvClear() [member function] @@ -8976,23 +9310,23 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbAddressBlock::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::ConstTlvIterator ns3::PbbAddressBlock::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', + 'ns3::PbbAddressBlock::ConstTlvIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvErase(ns3::PbbAddressBlock::TlvIterator position) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvErase(ns3::PbbAddressBlock::TlvIterator first, ns3::PbbAddressBlock::TlvIterator last) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'last')]) + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'first'), param('ns3::PbbAddressTlvBlock::Iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbAddressBlock::TlvFront() [member function] cls.add_method('TlvFront', 'ns3::Ptr< ns3::PbbAddressTlv >', @@ -9002,10 +9336,10 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbAddressBlock::TlvInsert(std::_List_iterator > position, ns3::Ptr const value) [member function] + ## packetbb.h (module 'network'): ns3::PbbAddressBlock::TlvIterator ns3::PbbAddressBlock::TlvInsert(ns3::PbbAddressBlock::TlvIterator position, ns3::Ptr const value) [member function] cls.add_method('TlvInsert', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressTlv > >', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'value')]) + 'ns3::PbbAddressBlock::TlvIterator', + [param('ns3::PbbAddressTlvBlock::Iterator', 'position'), param('ns3::Ptr< ns3::PbbTlv > const', 'value')]) ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::TlvPopBack() [member function] cls.add_method('TlvPopBack', 'void', @@ -9037,20 +9371,20 @@ def register_Ns3PbbAddressBlock_methods(root_module, cls): 'uint8_t', [], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlock::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_pure_virtual=True, is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbAddressBlockIpv4_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4(ns3::PbbAddressBlockIpv4 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4(ns3::PbbAddressBlockIpv4 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlockIpv4 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv4::PbbAddressBlockIpv4() [constructor] cls.add_constructor([]) @@ -9064,20 +9398,20 @@ def register_Ns3PbbAddressBlockIpv4_methods(root_module, cls): 'uint8_t', [], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv4::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbAddressBlockIpv6_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6(ns3::PbbAddressBlockIpv6 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6(ns3::PbbAddressBlockIpv6 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressBlockIpv6 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbAddressBlockIpv6::PbbAddressBlockIpv6() [constructor] cls.add_constructor([]) @@ -9091,22 +9425,22 @@ def register_Ns3PbbAddressBlockIpv6_methods(root_module, cls): 'uint8_t', [], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::PrintAddress(std::ostream & os, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::PrintAddress(std::ostream & os, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('PrintAddress', 'void', - [param('std::ostream &', 'os'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('std::ostream &', 'os'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) - ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::SerializeAddress(uint8_t * buffer, std::_List_const_iterator iter) const [member function] + ## packetbb.h (module 'network'): void ns3::PbbAddressBlockIpv6::SerializeAddress(uint8_t * buffer, ns3::PbbAddressBlock::ConstAddressIterator iter) const [member function] cls.add_method('SerializeAddress', 'void', - [param('uint8_t *', 'buffer'), param('std::_List_const_iterator< ns3::Address >', 'iter')], + [param('uint8_t *', 'buffer'), param('std::list< ns3::Address > const_iterator', 'iter')], is_const=True, visibility='protected', is_virtual=True) return def register_Ns3PbbMessage_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage(ns3::PbbMessage const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage(ns3::PbbMessage const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessage const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessage::PbbMessage() [constructor] cls.add_constructor([]) @@ -9119,13 +9453,13 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'ns3::Ptr< ns3::PbbAddressBlock > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockBegin() [member function] cls.add_method('AddressBlockBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::AddressBlockIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::AddressBlockBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstAddressBlockIterator ns3::PbbMessage::AddressBlockBegin() const [member function] cls.add_method('AddressBlockBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::ConstAddressBlockIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbMessage::AddressBlockClear() [member function] @@ -9137,23 +9471,23 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockEnd() [member function] cls.add_method('AddressBlockEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::AddressBlockIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::AddressBlockEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstAddressBlockIterator ns3::PbbMessage::AddressBlockEnd() const [member function] cls.add_method('AddressBlockEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', + 'ns3::PbbMessage::ConstAddressBlockIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockErase(ns3::PbbMessage::AddressBlockIterator position) [member function] cls.add_method('AddressBlockErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::AddressBlockErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbMessage::AddressBlockIterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbMessage::AddressBlockIterator ns3::PbbMessage::AddressBlockErase(ns3::PbbMessage::AddressBlockIterator first, ns3::PbbMessage::AddressBlockIterator last) [member function] cls.add_method('AddressBlockErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbAddressBlock > >', 'last')]) + 'ns3::PbbMessage::AddressBlockIterator', + [param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbAddressBlock > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::AddressBlockFront() [member function] cls.add_method('AddressBlockFront', 'ns3::Ptr< ns3::PbbAddressBlock >', @@ -9287,13 +9621,13 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstTlvIterator ns3::PbbMessage::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbMessage::TlvClear() [member function] @@ -9305,23 +9639,23 @@ def register_Ns3PbbMessage_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbMessage::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::ConstTlvIterator ns3::PbbMessage::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbMessage::ConstTlvIterator', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvErase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvErase(ns3::PbbMessage::TlvIterator position) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbMessage::TlvErase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbMessage::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbMessage::TlvIterator ns3::PbbMessage::TlvErase(ns3::PbbMessage::TlvIterator first, ns3::PbbMessage::TlvIterator last) [member function] cls.add_method('TlvErase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) + 'ns3::PbbMessage::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbMessage::TlvFront() [member function] cls.add_method('TlvFront', 'ns3::Ptr< ns3::PbbTlv >', @@ -9380,7 +9714,7 @@ def register_Ns3PbbMessage_methods(root_module, cls): return def register_Ns3PbbMessageIpv4_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4(ns3::PbbMessageIpv4 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4(ns3::PbbMessageIpv4 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessageIpv4 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessageIpv4::PbbMessageIpv4() [constructor] cls.add_constructor([]) @@ -9412,7 +9746,7 @@ def register_Ns3PbbMessageIpv4_methods(root_module, cls): return def register_Ns3PbbMessageIpv6_methods(root_module, cls): - ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6(ns3::PbbMessageIpv6 const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6(ns3::PbbMessageIpv6 const & arg0) [constructor] cls.add_constructor([param('ns3::PbbMessageIpv6 const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbMessageIpv6::PbbMessageIpv6() [constructor] cls.add_constructor([]) @@ -9446,7 +9780,7 @@ def register_Ns3PbbMessageIpv6_methods(root_module, cls): def register_Ns3PbbPacket_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket(ns3::PbbPacket const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket(ns3::PbbPacket const & arg0) [constructor] cls.add_constructor([param('ns3::PbbPacket const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbPacket::PbbPacket() [constructor] cls.add_constructor([]) @@ -9455,22 +9789,22 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'uint32_t', [param('ns3::Buffer::Iterator', 'start')], is_virtual=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > position) [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::Erase(ns3::PbbPacket::TlvIterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbPacket::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::Erase(ns3::PbbPacket::TlvIterator first, ns3::PbbPacket::TlvIterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', 'last')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > position) [member function] + 'ns3::PbbPacket::TlvIterator', + [param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbTlv > > iterator', 'last')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::Erase(ns3::PbbPacket::MessageIterator position) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'position')]) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::Erase(std::_List_iterator > first, std::_List_iterator > last) [member function] + 'ns3::PbbPacket::MessageIterator', + [param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'position')]) + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::Erase(ns3::PbbPacket::MessageIterator first, ns3::PbbPacket::MessageIterator last) [member function] cls.add_method('Erase', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', - [param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'first'), param('std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', 'last')]) + 'ns3::PbbPacket::MessageIterator', + [param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'first'), param('std::list< ns3::Ptr< ns3::PbbMessage > > iterator', 'last')]) ## packetbb.h (module 'network'): ns3::TypeId ns3::PbbPacket::GetInstanceTypeId() const [member function] cls.add_method('GetInstanceTypeId', 'ns3::TypeId', @@ -9510,13 +9844,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'ns3::Ptr< ns3::PbbMessage > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::MessageBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::MessageBegin() [member function] cls.add_method('MessageBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::MessageIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::MessageBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstMessageIterator ns3::PbbPacket::MessageBegin() const [member function] cls.add_method('MessageBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::ConstMessageIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbPacket::MessageClear() [member function] @@ -9528,13 +9862,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::MessageEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::MessageIterator ns3::PbbPacket::MessageEnd() [member function] cls.add_method('MessageEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::MessageIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::MessageEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstMessageIterator ns3::PbbPacket::MessageEnd() const [member function] cls.add_method('MessageEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbMessage > >', + 'ns3::PbbPacket::ConstMessageIterator', [], is_const=True) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::MessageFront() [member function] @@ -9590,13 +9924,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'ns3::Ptr< ns3::PbbTlv > const', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::TlvBegin() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::TlvBegin() [member function] cls.add_method('TlvBegin', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::TlvBegin() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstTlvIterator ns3::PbbPacket::TlvBegin() const [member function] cls.add_method('TlvBegin', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): void ns3::PbbPacket::TlvClear() [member function] @@ -9608,13 +9942,13 @@ def register_Ns3PbbPacket_methods(root_module, cls): 'bool', [], is_const=True) - ## packetbb.h (module 'network'): std::_List_iterator > ns3::PbbPacket::TlvEnd() [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::TlvIterator ns3::PbbPacket::TlvEnd() [member function] cls.add_method('TlvEnd', - 'std::_List_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::TlvIterator', []) - ## packetbb.h (module 'network'): std::_List_const_iterator > ns3::PbbPacket::TlvEnd() const [member function] + ## packetbb.h (module 'network'): ns3::PbbPacket::ConstTlvIterator ns3::PbbPacket::TlvEnd() const [member function] cls.add_method('TlvEnd', - 'std::_List_const_iterator< ns3::Ptr< ns3::PbbTlv > >', + 'ns3::PbbPacket::ConstTlvIterator', [], is_const=True) ## packetbb.h (module 'network'): ns3::Ptr ns3::PbbPacket::TlvFront() [member function] @@ -9652,7 +9986,7 @@ def register_Ns3PbbPacket_methods(root_module, cls): def register_Ns3PbbTlv_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv(ns3::PbbTlv const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv(ns3::PbbTlv const & arg0) [constructor] cls.add_constructor([param('ns3::PbbTlv const &', 'arg0')]) ## packetbb.h (module 'network'): ns3::PbbTlv::PbbTlv() [constructor] cls.add_constructor([]) @@ -9764,7 +10098,7 @@ def register_Ns3PbbTlv_methods(root_module, cls): return def register_Ns3Probe_methods(root_module, cls): - ## probe.h (module 'stats'): ns3::Probe::Probe(ns3::Probe const & arg0) [copy constructor] + ## probe.h (module 'stats'): ns3::Probe::Probe(ns3::Probe const & arg0) [constructor] cls.add_constructor([param('ns3::Probe const &', 'arg0')]) ## probe.h (module 'stats'): ns3::Probe::Probe() [constructor] cls.add_constructor([]) @@ -9791,155 +10125,155 @@ def register_Ns3Probe_methods(root_module, cls): return def register_Ns3Queue__Ns3Packet_methods(root_module, cls): - ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Queue< ns3::Packet > const &', 'arg0')]) + ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) ## queue.h (module 'network'): ns3::Queue::Queue() [constructor] cls.add_constructor([]) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] - cls.add_method('Dequeue', - 'ns3::Ptr< ns3::Packet >', - [], - is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): bool ns3::Queue::Enqueue(ns3::Ptr item) [member function] cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::Packet >', 'item')], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] - cls.add_method('Flush', - 'void', - []) - ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', - [], - is_static=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] - cls.add_method('Peek', - 'ns3::Ptr< ns3::Packet const >', + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::Packet >', [], - is_pure_virtual=True, is_const=True, is_virtual=True) + is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] cls.add_method('Remove', 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(std::_List_const_iterator > pos) [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] + cls.add_method('Peek', + 'ns3::Ptr< ns3::Packet const >', + [], + is_pure_virtual=True, is_const=True, is_virtual=True) + ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] + cls.add_method('Flush', + 'void', + []) + ## net-device-queue-interface.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + cls.add_constructor([param('ns3::Queue< ns3::Packet > const &', 'arg0')]) + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] + cls.add_method('Head', + 'ns3::Queue< ns3::Packet > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Tail() const [member function] + cls.add_method('Tail', + 'ns3::Queue< ns3::Packet > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(ns3::Queue::ConstIterator pos, ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos'), param('ns3::Ptr< ns3::Packet >', 'item')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(ns3::Queue::ConstIterator pos) [member function] cls.add_method('DoDequeue', 'ns3::Ptr< ns3::Packet >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(std::_List_const_iterator > pos, ns3::Ptr item) [member function] - cls.add_method('DoEnqueue', - 'bool', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos'), param('ns3::Ptr< ns3::Packet >', 'item')], + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoRemove', + 'ns3::Ptr< ns3::Packet >', + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(std::_List_const_iterator > pos) const [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(ns3::Queue::ConstIterator pos) const [member function] cls.add_method('DoPeek', 'ns3::Ptr< ns3::Packet const >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::Packet > > const_iterator', 'pos')], is_const=True, visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(std::_List_const_iterator > pos) [member function] - cls.add_method('DoRemove', - 'ns3::Ptr< ns3::Packet >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', 'pos')], - visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] - cls.add_method('DropAfterDequeue', + ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] + cls.add_method('DropBeforeEnqueue', 'void', [param('ns3::Ptr< ns3::Packet >', 'item')], visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] - cls.add_method('DropBeforeEnqueue', + ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] + cls.add_method('DropAfterDequeue', 'void', [param('ns3::Ptr< ns3::Packet >', 'item')], visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Head() const [member function] - cls.add_method('Head', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', - [], - is_const=True, visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Tail() const [member function] - cls.add_method('Tail', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', - [], - is_const=True, visibility='protected') return def register_Ns3Queue__Ns3QueueDiscItem_methods(root_module, cls): - ## queue.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Queue< ns3::QueueDiscItem > const &', 'arg0')]) + ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) ## queue.h (module 'network'): ns3::Queue::Queue() [constructor] cls.add_constructor([]) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] - cls.add_method('Dequeue', - 'ns3::Ptr< ns3::QueueDiscItem >', - [], - is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): bool ns3::Queue::Enqueue(ns3::Ptr item) [member function] cls.add_method('Enqueue', 'bool', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] - cls.add_method('Flush', - 'void', - []) - ## queue.h (module 'network'): static ns3::TypeId ns3::Queue::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Dequeue() [member function] + cls.add_method('Dequeue', + 'ns3::Ptr< ns3::QueueDiscItem >', [], - is_static=True) + is_pure_virtual=True, is_virtual=True) + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] + cls.add_method('Remove', + 'ns3::Ptr< ns3::QueueDiscItem >', + [], + is_pure_virtual=True, is_virtual=True) ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Peek() const [member function] cls.add_method('Peek', 'ns3::Ptr< ns3::QueueDiscItem const >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::Remove() [member function] - cls.add_method('Remove', - 'ns3::Ptr< ns3::QueueDiscItem >', + ## queue.h (module 'network'): void ns3::Queue::Flush() [member function] + cls.add_method('Flush', + 'void', + []) + ## net-device-queue-interface.h (module 'network'): ns3::Queue::Queue(ns3::Queue const & arg0) [constructor] + cls.add_constructor([param('ns3::Queue< ns3::QueueDiscItem > const &', 'arg0')]) + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Head() const [member function] + cls.add_method('Head', + 'ns3::Queue< ns3::QueueDiscItem > ConstIterator', [], - is_pure_virtual=True, is_virtual=True) - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(std::_List_const_iterator > pos) [member function] + is_const=True, visibility='protected') + ## queue.h (module 'network'): ns3::Queue::ConstIterator ns3::Queue::Tail() const [member function] + cls.add_method('Tail', + 'ns3::Queue< ns3::QueueDiscItem > ConstIterator', + [], + is_const=True, visibility='protected') + ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(ns3::Queue::ConstIterator pos, ns3::Ptr item) [member function] + cls.add_method('DoEnqueue', + 'bool', + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos'), param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + visibility='protected') + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoDequeue(ns3::Queue::ConstIterator pos) [member function] cls.add_method('DoDequeue', 'ns3::Ptr< ns3::QueueDiscItem >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): bool ns3::Queue::DoEnqueue(std::_List_const_iterator > pos, ns3::Ptr item) [member function] - cls.add_method('DoEnqueue', - 'bool', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos'), param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(ns3::Queue::ConstIterator pos) [member function] + cls.add_method('DoRemove', + 'ns3::Ptr< ns3::QueueDiscItem >', + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(std::_List_const_iterator > pos) const [member function] + ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoPeek(ns3::Queue::ConstIterator pos) const [member function] cls.add_method('DoPeek', 'ns3::Ptr< ns3::QueueDiscItem const >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], + [param('std::list< ns3::Ptr< ns3::QueueDiscItem > > const_iterator', 'pos')], is_const=True, visibility='protected') - ## queue.h (module 'network'): ns3::Ptr ns3::Queue::DoRemove(std::_List_const_iterator > pos) [member function] - cls.add_method('DoRemove', - 'ns3::Ptr< ns3::QueueDiscItem >', - [param('std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', 'pos')], - visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] - cls.add_method('DropAfterDequeue', + ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] + cls.add_method('DropBeforeEnqueue', 'void', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], visibility='protected') - ## queue.h (module 'network'): void ns3::Queue::DropBeforeEnqueue(ns3::Ptr item) [member function] - cls.add_method('DropBeforeEnqueue', + ## queue.h (module 'network'): void ns3::Queue::DropAfterDequeue(ns3::Ptr item) [member function] + cls.add_method('DropAfterDequeue', 'void', [param('ns3::Ptr< ns3::QueueDiscItem >', 'item')], visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Head() const [member function] - cls.add_method('Head', - 'std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', - [], - is_const=True, visibility='protected') - ## queue.h (module 'network'): std::_List_const_iterator > ns3::Queue::Tail() const [member function] - cls.add_method('Tail', - 'std::_List_const_iterator< ns3::Ptr< ns3::QueueDiscItem > >', - [], - is_const=True, visibility='protected') return def register_Ns3QueueItem_methods(root_module, cls): @@ -9969,7 +10303,7 @@ def register_Ns3QueueItem_methods(root_module, cls): return def register_Ns3RateErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel(ns3::RateErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::RateErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::RateErrorModel::RateErrorModel() [constructor] cls.add_constructor([]) @@ -10032,7 +10366,7 @@ def register_Ns3RateErrorModel_methods(root_module, cls): return def register_Ns3ReceiveListErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel(ns3::ReceiveListErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel(ns3::ReceiveListErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::ReceiveListErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::ReceiveListErrorModel::ReceiveListErrorModel() [constructor] cls.add_constructor([]) @@ -10063,7 +10397,7 @@ def register_Ns3ReceiveListErrorModel_methods(root_module, cls): return def register_Ns3SimpleChannel_methods(root_module, cls): - ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [copy constructor] + ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel(ns3::SimpleChannel const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleChannel const &', 'arg0')]) ## simple-channel.h (module 'network'): ns3::SimpleChannel::SimpleChannel() [constructor] cls.add_constructor([]) @@ -10105,7 +10439,7 @@ def register_Ns3SimpleChannel_methods(root_module, cls): return def register_Ns3SimpleNetDevice_methods(root_module, cls): - ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [copy constructor] + ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice(ns3::SimpleNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleNetDevice const &', 'arg0')]) ## simple-net-device.h (module 'network'): ns3::SimpleNetDevice::SimpleNetDevice() [constructor] cls.add_constructor([]) @@ -10232,7 +10566,7 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) - ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -10241,7 +10575,7 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): cls.add_method('SetQueue', 'void', [param('ns3::Ptr< ns3::Queue< ns3::Packet > >', 'queue')]) - ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## simple-net-device.h (module 'network'): void ns3::SimpleNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -10275,16 +10609,16 @@ def register_Ns3SimpleNetDevice_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10294,7 +10628,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10308,23 +10642,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10334,7 +10668,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10348,16 +10682,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10367,7 +10701,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10381,23 +10715,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10407,7 +10741,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -10419,7 +10753,7 @@ def register_Ns3AddressValue_methods(root_module, cls): return def register_Ns3BinaryErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel(ns3::BinaryErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel(ns3::BinaryErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::BinaryErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::BinaryErrorModel::BinaryErrorModel() [constructor] cls.add_constructor([]) @@ -10441,7 +10775,7 @@ def register_Ns3BinaryErrorModel_methods(root_module, cls): return def register_Ns3BurstErrorModel_methods(root_module, cls): - ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel(ns3::BurstErrorModel const & arg0) [copy constructor] + ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel(ns3::BurstErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::BurstErrorModel const &', 'arg0')]) ## error-model.h (module 'network'): ns3::BurstErrorModel::BurstErrorModel() [constructor] cls.add_constructor([]) @@ -10483,8 +10817,338 @@ def register_Ns3BurstErrorModel_methods(root_module, cls): visibility='private', is_virtual=True) return +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Unsigned_char_Ns3Ptr__lt__ns3QueueItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< unsigned char, ns3::Ptr< ns3::QueueItem >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): unsigned char ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'unsigned char', + [param('ns3::Ptr< ns3::QueueItem >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3QueueDiscItem__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::QueueDiscItem const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::QueueDiscItem const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned int arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned int', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls): - ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator(ns3::CounterCalculator const & arg0) [copy constructor] + ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator(ns3::CounterCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::CounterCalculator< unsigned int > const &', 'arg0')]) ## basic-data-calculators.h (module 'stats'): ns3::CounterCalculator::CounterCalculator() [constructor] cls.add_constructor([]) @@ -10519,7 +11183,7 @@ def register_Ns3CounterCalculator__Unsigned_int_methods(root_module, cls): return def register_Ns3ErrorChannel_methods(root_module, cls): - ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel(ns3::ErrorChannel const & arg0) [copy constructor] + ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel(ns3::ErrorChannel const & arg0) [constructor] cls.add_constructor([param('ns3::ErrorChannel const &', 'arg0')]) ## error-channel.h (module 'network'): ns3::ErrorChannel::ErrorChannel() [constructor] cls.add_constructor([]) @@ -10567,11 +11231,11 @@ def register_Ns3ErrorChannel_methods(root_module, cls): return def register_Ns3PacketCounterCalculator_methods(root_module, cls): - ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [copy constructor] + ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator(ns3::PacketCounterCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketCounterCalculator const &', 'arg0')]) ## packet-data-calculators.h (module 'network'): ns3::PacketCounterCalculator::PacketCounterCalculator() [constructor] cls.add_constructor([]) - ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::FrameUpdate(std::string path, ns3::Ptr packet, ns3::Mac48Address realto) [member function] cls.add_method('FrameUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Mac48Address', 'realto')]) @@ -10580,7 +11244,7 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] + ## packet-data-calculators.h (module 'network'): void ns3::PacketCounterCalculator::PacketUpdate(std::string path, ns3::Ptr packet) [member function] cls.add_method('PacketUpdate', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')]) @@ -10592,7 +11256,7 @@ def register_Ns3PacketCounterCalculator_methods(root_module, cls): return def register_Ns3PacketProbe_methods(root_module, cls): - ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe(ns3::PacketProbe const & arg0) [copy constructor] + ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe(ns3::PacketProbe const & arg0) [constructor] cls.add_constructor([param('ns3::PacketProbe const &', 'arg0')]) ## packet-probe.h (module 'network'): ns3::PacketProbe::PacketProbe() [constructor] cls.add_constructor([]) @@ -10611,11 +11275,11 @@ def register_Ns3PacketProbe_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## packet-probe.h (module 'network'): void ns3::PacketProbe::SetValue(ns3::Ptr packet) [member function] + ## packet-probe.h (module 'network'): void ns3::PacketProbe::SetValue(ns3::Ptr packet) [member function] cls.add_method('SetValue', 'void', [param('ns3::Ptr< ns3::Packet const >', 'packet')]) - ## packet-probe.h (module 'network'): static void ns3::PacketProbe::SetValueByPath(std::string path, ns3::Ptr packet) [member function] + ## packet-probe.h (module 'network'): static void ns3::PacketProbe::SetValueByPath(std::string path, ns3::Ptr packet) [member function] cls.add_method('SetValueByPath', 'void', [param('std::string', 'path'), param('ns3::Ptr< ns3::Packet const >', 'packet')], @@ -10625,7 +11289,7 @@ def register_Ns3PacketProbe_methods(root_module, cls): def register_Ns3PbbAddressTlv_methods(root_module, cls): ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv() [constructor] cls.add_constructor([]) - ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv(ns3::PbbAddressTlv const & arg0) [copy constructor] + ## packetbb.h (module 'network'): ns3::PbbAddressTlv::PbbAddressTlv(ns3::PbbAddressTlv const & arg0) [constructor] cls.add_constructor([param('ns3::PbbAddressTlv const &', 'arg0')]) ## packetbb.h (module 'network'): uint8_t ns3::PbbAddressTlv::GetIndexStart() const [member function] cls.add_method('GetIndexStart', @@ -10706,7 +11370,7 @@ def register_Ns3QueueDiscItem_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -10728,7 +11392,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -10750,7 +11414,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -10767,7 +11431,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -10789,7 +11453,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -10812,91 +11476,91 @@ def register_Ns3HashFunctionMurmur3_methods(root_module, cls): def register_functions(root_module): module = root_module - ## crc32.h (module 'network'): extern uint32_t ns3::CRC32Calculate(uint8_t const * data, int length) [free function] + ## crc32.h (module 'network'): uint32_t ns3::CRC32Calculate(uint8_t const * data, int length) [free function] module.add_function('CRC32Calculate', 'uint32_t', [param('uint8_t const *', 'data'), param('int', 'length')]) - ## address.h (module 'network'): extern ns3::Ptr ns3::MakeAddressChecker() [free function] + ## address.h (module 'network'): ns3::Ptr ns3::MakeAddressChecker() [free function] module.add_function('MakeAddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## data-rate.h (module 'network'): extern ns3::Ptr ns3::MakeDataRateChecker() [free function] + ## data-rate.h (module 'network'): ns3::Ptr ns3::MakeDataRateChecker() [free function] module.add_function('MakeDataRateChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv4-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv4AddressChecker() [free function] + ## ipv4-address.h (module 'network'): ns3::Ptr ns3::MakeIpv4AddressChecker() [free function] module.add_function('MakeIpv4AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv4-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv4MaskChecker() [free function] + ## ipv4-address.h (module 'network'): ns3::Ptr ns3::MakeIpv4MaskChecker() [free function] module.add_function('MakeIpv4MaskChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv6-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv6AddressChecker() [free function] + ## ipv6-address.h (module 'network'): ns3::Ptr ns3::MakeIpv6AddressChecker() [free function] module.add_function('MakeIpv6AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## ipv6-address.h (module 'network'): extern ns3::Ptr ns3::MakeIpv6PrefixChecker() [free function] + ## ipv6-address.h (module 'network'): ns3::Ptr ns3::MakeIpv6PrefixChecker() [free function] module.add_function('MakeIpv6PrefixChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac16-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac16AddressChecker() [free function] + ## mac16-address.h (module 'network'): ns3::Ptr ns3::MakeMac16AddressChecker() [free function] module.add_function('MakeMac16AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac48-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac48AddressChecker() [free function] + ## mac48-address.h (module 'network'): ns3::Ptr ns3::MakeMac48AddressChecker() [free function] module.add_function('MakeMac48AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## mac64-address.h (module 'network'): extern ns3::Ptr ns3::MakeMac64AddressChecker() [free function] + ## mac64-address.h (module 'network'): ns3::Ptr ns3::MakeMac64AddressChecker() [free function] module.add_function('MakeMac64AddressChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Address & ad, uint32_t len) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address &', 'ad'), param('uint32_t', 'len')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv4Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv6Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Ipv6Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac16Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac16Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac16Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac48Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac64Address & ad) [free function] + ## address-utils.h (module 'network'): void ns3::ReadFrom(ns3::Buffer::Iterator & i, ns3::Mac64Address & ad) [free function] module.add_function('ReadFrom', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac64Address &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Address const & ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Address const &', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv4Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv4Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv6Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Ipv6Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Ipv6Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac16Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac16Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac16Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac48Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac48Address', 'ad')]) - ## address-utils.h (module 'network'): extern void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac64Address ad) [free function] + ## address-utils.h (module 'network'): void ns3::WriteTo(ns3::Buffer::Iterator & i, ns3::Mac64Address ad) [free function] module.add_function('WriteTo', 'void', [param('ns3::Buffer::Iterator &', 'i'), param('ns3::Mac64Address', 'ad')]) @@ -10921,7 +11585,7 @@ def register_functions_ns3_TracedValueCallback(module, root_module): return def register_functions_ns3_addressUtils(module, root_module): - ## address-utils.h (module 'network'): extern bool ns3::addressUtils::IsMulticast(ns3::Address const & ad) [free function] + ## address-utils.h (module 'network'): bool ns3::addressUtils::IsMulticast(ns3::Address const & ad) [free function] module.add_function('IsMulticast', 'bool', [param('ns3::Address const &', 'ad')]) From c919daec15c995b9bfdd0bef70dcaf21261b664c Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 8 Aug 2017 13:41:55 -0700 Subject: [PATCH 205/551] lte: Update ILP32 bindings --- src/lte/bindings/modulegen__gcc_ILP32.py | 4200 +++++++++++++++------- 1 file changed, 2857 insertions(+), 1343 deletions(-) diff --git a/src/lte/bindings/modulegen__gcc_ILP32.py b/src/lte/bindings/modulegen__gcc_ILP32.py index b849d432113..be0e7d91c4b 100644 --- a/src/lte/bindings/modulegen__gcc_ILP32.py +++ b/src/lte/bindings/modulegen__gcc_ILP32.py @@ -22,10 +22,10 @@ def register_types(module): ## log.h (module 'core'): ns3::LogLevel [enumeration] module.add_enum('LogLevel', ['LOG_NONE', 'LOG_ERROR', 'LOG_LEVEL_ERROR', 'LOG_WARN', 'LOG_LEVEL_WARN', 'LOG_DEBUG', 'LOG_LEVEL_DEBUG', 'LOG_INFO', 'LOG_LEVEL_INFO', 'LOG_FUNCTION', 'LOG_LEVEL_FUNCTION', 'LOG_LOGIC', 'LOG_LEVEL_LOGIC', 'LOG_ALL', 'LOG_LEVEL_ALL', 'LOG_PREFIX_FUNC', 'LOG_PREFIX_TIME', 'LOG_PREFIX_NODE', 'LOG_PREFIX_LEVEL', 'LOG_PREFIX_ALL'], import_from_module='ns.core') - ## ff-mac-common.h (module 'lte'): ns3::SetupRelease_e [enumeration] - module.add_enum('SetupRelease_e', ['setup', 'release']) ## ff-mac-common.h (module 'lte'): ns3::Result_e [enumeration] module.add_enum('Result_e', ['SUCCESS', 'FAILURE']) + ## ff-mac-common.h (module 'lte'): ns3::SetupRelease_e [enumeration] + module.add_enum('SetupRelease_e', ['setup', 'release']) ## ff-mac-common.h (module 'lte'): ns3::CeBitmap_e [enumeration] module.add_enum('CeBitmap_e', ['TA', 'DRX', 'CR']) ## ff-mac-common.h (module 'lte'): ns3::NormalExtended_e [enumeration] @@ -82,6 +82,42 @@ def register_types(module): module.add_class('DataOutputCallback', allow_subclassing=True, import_from_module='ns.stats') ## data-rate.h (module 'network'): ns3::DataRate [class] module.add_class('DataRate', import_from_module='ns.network') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::EpcTft']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteChunkProcessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteControlMessage']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::LteHarqPhy']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumModel']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::SpectrumValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::VendorSpecificValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::X2CellInfo']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', template_parameters=['ns3::X2IfaceInfo']) ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s [struct] module.add_class('DlDciListElement_s') ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::Format_e [enumeration] @@ -460,10 +496,10 @@ def register_types(module): module.add_class('MeasConfig', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [struct] module.add_class('MeasGapConfig', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig [enumeration] - module.add_enum('', ['GP0', 'GP1'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gap [enumeration] + module.add_enum('gap', ['GP0', 'GP1'], outer_class=root_module['ns3::LteRrcSap::MeasGapConfig']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod [struct] module.add_class('MeasIdToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra [struct] @@ -494,8 +530,8 @@ def register_types(module): module.add_class('PdschConfigCommon', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated [struct] module.add_class('PdschConfigDedicated', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated [enumeration] - module.add_enum('', ['dB_6', 'dB_4dot77', 'dB_3', 'dB_1dot77', 'dB0', 'dB1', 'dB2', 'dB3'], outer_class=root_module['ns3::LteRrcSap::PdschConfigDedicated']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::db [enumeration] + module.add_enum('db', ['dB_6', 'dB_4dot77', 'dB_3', 'dB_1dot77', 'dB0', 'dB1', 'dB2', 'dB3'], outer_class=root_module['ns3::LteRrcSap::PdschConfigDedicated']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange [struct] module.add_class('PhysCellIdRange', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated [struct] @@ -536,8 +572,8 @@ def register_types(module): module.add_enum('', ['EVENT', 'PERIODICAL'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] module.add_enum('', ['EVENT_A1', 'EVENT_A2', 'EVENT_A3', 'EVENT_A4', 'EVENT_A5'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] - module.add_enum('', ['REPORT_STRONGEST_CELLS', 'REPORT_CGI'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::report [enumeration] + module.add_enum('report', ['REPORT_STRONGEST_CELLS', 'REPORT_CGI'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] module.add_enum('', ['RSRP', 'RSRQ'], outer_class=root_module['ns3::LteRrcSap::ReportConfigEutra']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra [enumeration] @@ -548,8 +584,8 @@ def register_types(module): module.add_class('ReportConfigToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig [struct] module.add_class('RlcConfig', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig [enumeration] - module.add_enum('', ['AM', 'UM_BI_DIRECTIONAL', 'UM_UNI_DIRECTIONAL_UL', 'UM_UNI_DIRECTIONAL_DL'], outer_class=root_module['ns3::LteRrcSap::RlcConfig']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::direction [enumeration] + module.add_enum('direction', ['AM', 'UM_BI_DIRECTIONAL', 'UM_UNI_DIRECTIONAL_UL', 'UM_UNI_DIRECTIONAL_DL'], outer_class=root_module['ns3::LteRrcSap::RlcConfig']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration [struct] module.add_class('RrcConnectionReconfiguration', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted [struct] @@ -576,16 +612,16 @@ def register_types(module): module.add_class('SCellToAddMod', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon [struct] module.add_class('SoundingRsUlConfigCommon', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigCommon']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigCommon']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated [struct] module.add_class('SoundingRsUlConfigDedicated', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigDedicated']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SoundingRsUlConfigDedicated']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars [struct] module.add_class('SpeedStatePars', outer_class=root_module['ns3::LteRrcSap']) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars [enumeration] - module.add_enum('', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SpeedStatePars']) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::action [enumeration] + module.add_enum('action', ['SETUP', 'RESET'], outer_class=root_module['ns3::LteRrcSap::SpeedStatePars']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors [struct] module.add_class('SpeedStateScaleFactors', outer_class=root_module['ns3::LteRrcSap']) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod [struct] @@ -672,8 +708,8 @@ def register_types(module): module.add_class('PacketMetadata', import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) ## packet.h (module 'network'): ns3::PacketTagIterator [class] @@ -778,9 +814,9 @@ def register_types(module): module.add_class('fdbetsFlowPerf_t') ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t [struct] module.add_class('fdtbfqsFlowPerf_t') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t [struct] module.add_class('pfsFlowPerf_t') @@ -818,8 +854,8 @@ def register_types(module): module.add_class('SetupUeParameters', outer_class=root_module['ns3::LteEnbRrcSapUser']) ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader [class] module.add_class('LtePdcpHeader', parent=root_module['ns3::Header']) - ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::DcBit_t [enumeration] - module.add_enum('DcBit_t', ['CONTROL_PDU', 'DATA_PDU'], outer_class=root_module['ns3::LtePdcpHeader']) + ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader [enumeration] + module.add_enum('', ['CONTROL_PDU', 'DATA_PDU'], outer_class=root_module['ns3::LtePdcpHeader']) ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag [class] module.add_class('LtePhyTag', parent=root_module['ns3::Tag']) ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag [class] @@ -1230,6 +1266,10 @@ def register_types(module): module.add_class('MacStatsCalculator', parent=root_module['ns3::LteStatsCalculator']) ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage [class] module.add_class('MibLteControlMessage', parent=root_module['ns3::LteControlMessage']) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator [class] + module.add_class('MinMaxAvgTotalCalculator', import_from_module='ns.stats', template_parameters=['unsigned int'], parent=[root_module['ns3::DataCalculator'], root_module['ns3::StatisticalSummary']]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator [class] + module.add_class('MinMaxAvgTotalCalculator', import_from_module='ns.stats', template_parameters=['unsigned long long'], parent=[root_module['ns3::DataCalculator'], root_module['ns3::StatisticalSummary']]) ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class] module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object']) ## net-device.h (module 'network'): ns3::NetDevice [class] @@ -1344,6 +1384,78 @@ def register_types(module): module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage [class] module.add_class('BsrLteControlMessage', parent=root_module['ns3::LteControlMessage']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'const ns3::Address &', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'const ns3::SpectrumValue &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::DlSchedulingCallbackInfo', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::EpcUeNas::State', 'ns3::EpcUeNas::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::PhyReceptionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::PhyTransmissionStatParameters', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned int', 'unsigned int', 'unsigned short', 'unsigned char', 'unsigned short', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long long', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long long', 'unsigned short', 'unsigned short', 'ns3::LteRrcSap::MeasurementReport', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long long', 'unsigned short', 'unsigned short', 'ns3::LteUeRrc::State', 'ns3::LteUeRrc::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned long long', 'unsigned short', 'unsigned short', 'ns3::UeManager::State', 'ns3::UeManager::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long long', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned long long', 'unsigned short', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned char', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned char', 'unsigned int', 'unsigned long long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'double', 'bool', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'double', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', template_parameters=['void', 'unsigned short', 'unsigned short', 'ns3::LteUePhy::State', 'ns3::LteUePhy::State', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'unsigned short', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler [class] module.add_class('CqaFfMacScheduler', parent=root_module['ns3::FfMacScheduler']) ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage [class] @@ -1412,9 +1524,9 @@ def register_types(module): module.add_container('std::list< ns3::EpcS1apSapMme::ErabToBeReleasedIndication >', 'ns3::EpcS1apSapMme::ErabToBeReleasedIndication', container_type=u'list') module.add_container('std::list< ns3::EpcS1apSapMme::ErabSetupItem >', 'ns3::EpcS1apSapMme::ErabSetupItem', container_type=u'list') module.add_container('std::list< ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem >', 'ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem', container_type=u'list') + module.add_container('std::vector< bool >', 'bool', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::UlInterferenceOverloadIndicationItem >', 'ns3::EpcX2Sap::UlInterferenceOverloadIndicationItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::UlHighInterferenceInformationItem >', 'ns3::EpcX2Sap::UlHighInterferenceInformationItem', container_type=u'vector') - module.add_container('std::vector< bool >', 'bool', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', 'ns3::EpcX2Sap::ErabToBeSetupItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabAdmittedItem >', 'ns3::EpcX2Sap::ErabAdmittedItem', container_type=u'vector') module.add_container('std::vector< ns3::EpcX2Sap::ErabNotAdmittedItem >', 'ns3::EpcX2Sap::ErabNotAdmittedItem', container_type=u'vector') @@ -1465,127 +1577,127 @@ def register_types(module): module.add_container('ns3::Bands', 'ns3::BandInfo', container_type=u'vector') module.add_container('std::map< unsigned char, ns3::ComponentCarrier >', ('unsigned char', 'ns3::ComponentCarrier'), container_type=u'map') module.add_container('std::map< unsigned int, unsigned int >', ('unsigned int', 'unsigned int'), container_type=u'map') + module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierEnb >'), container_type=u'map') module.add_container('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'ns3::Ptr< ns3::LteControlMessage >', container_type=u'list') module.add_container('std::list< ns3::UlDciLteControlMessage >', 'ns3::UlDciLteControlMessage', container_type=u'list') module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierUe >'), container_type=u'map') - module.add_container('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', ('unsigned char', 'ns3::Ptr< ns3::ComponentCarrierEnb >'), container_type=u'map') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesStatus_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesStatus_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesStatus_t&') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesTimer_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesTimer_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesTimer_t&') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >', u'ns3::DlHarqProcessesDciBuffer_t') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >*', u'ns3::DlHarqProcessesDciBuffer_t*') + typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >&', u'ns3::DlHarqProcessesDciBuffer_t&') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >', u'ns3::RlcPduList_t') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >*', u'ns3::RlcPduList_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >&', u'ns3::RlcPduList_t&') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >', u'ns3::DlHarqRlcPduListBuffer_t') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >*', u'ns3::DlHarqRlcPduListBuffer_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >&', u'ns3::DlHarqRlcPduListBuffer_t&') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >', u'ns3::UlHarqProcessesDciBuffer_t') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >*', u'ns3::UlHarqProcessesDciBuffer_t*') + typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >&', u'ns3::UlHarqProcessesDciBuffer_t&') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::UlHarqProcessesStatus_t') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::UlHarqProcessesStatus_t*') + typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::UlHarqProcessesStatus_t&') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >', u'ns3::Uint32Map') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >*', u'ns3::Uint32Map*') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned int, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned int > > >&', u'ns3::Uint32Map&') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long long > > >', u'ns3::Uint64Map') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long long > > >*', u'ns3::Uint64Map*') typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, unsigned long long, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, unsigned long long > > >&', u'ns3::Uint64Map&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >', u'ns3::DlHarqRlcPduListBuffer_t') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >*', u'ns3::DlHarqRlcPduListBuffer_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >, std::allocator< std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > > > >&', u'ns3::DlHarqRlcPduListBuffer_t&') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >', u'ns3::HarqProcessInfoList_t') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >*', u'ns3::HarqProcessInfoList_t*') - typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >&', u'ns3::HarqProcessInfoList_t&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >', u'ns3::Uint32StatsMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >*', u'ns3::Uint32StatsMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >&', u'ns3::Uint32StatsMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >', u'ns3::Uint64StatsMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >*', u'ns3::Uint64StatsMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >&', u'ns3::Uint64StatsMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >', u'ns3::DoubleMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >*', u'ns3::DoubleMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >&', u'ns3::DoubleMap&') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >', u'ns3::FlowIdMap') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >*', u'ns3::FlowIdMap*') + typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >&', u'ns3::FlowIdMap&') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >', u'ns3::DlHarqProcessesBuffer_t') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >*', u'ns3::DlHarqProcessesBuffer_t*') + typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >&', u'ns3::DlHarqProcessesBuffer_t&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LteChunkProcessorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LteChunkProcessorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LteChunkProcessorCallback&') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >', u'ns3::expectedTbs_t') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >*', u'ns3::expectedTbs_t*') + typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >&', u'ns3::expectedTbs_t&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyTxEndCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyTxEndCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyTxEndCallback&') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogNodePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogNodePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogNodePrinter&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndOkCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndErrorCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndErrorCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndErrorCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxDataEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxDataEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxDataEndOkCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndOkCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndErrorCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndErrorCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndErrorCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >', u'ns3::Values') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >*', u'ns3::Values*') - typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >&', u'ns3::Values&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesStatus_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesStatus_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesStatus_t&') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', u'ns3::Bands') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', u'ns3::Bands*') - typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', u'ns3::Bands&') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxPssCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxPssCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxPssCallback&') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyDlHarqFeedbackCallback') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyDlHarqFeedbackCallback*') typehandlers.add_type_alias(u'ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyDlHarqFeedbackCallback&') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >', u'ns3::expectedTbs_t') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >*', u'ns3::expectedTbs_t*') - typehandlers.add_type_alias(u'std::map< ns3::TbId_t, ns3::tbInfo_t, std::less< ns3::TbId_t >, std::allocator< std::pair< ns3::TbId_t const, ns3::tbInfo_t > > >&', u'ns3::expectedTbs_t&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyUlHarqFeedbackCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyUlHarqFeedbackCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyUlHarqFeedbackCallback&') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >', u'ns3::HarqProcessInfoList_t') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >*', u'ns3::HarqProcessInfoList_t*') + typehandlers.add_type_alias(u'std::vector< ns3::HarqProcessInfoElement_t, std::allocator< ns3::HarqProcessInfoElement_t > >&', u'ns3::HarqProcessInfoList_t&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogTimePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogTimePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogTimePrinter&') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )', u'ns3::LogNodePrinter') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )*', u'ns3::LogNodePrinter*') + typehandlers.add_type_alias(u'void ( * ) ( std::ostream & )&', u'ns3::LogNodePrinter&') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxEndCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxEndCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxEndCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxStartCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxStartCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxStartCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndErrorCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndErrorCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndErrorCallback&') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') + typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') module.add_typedef(root_module['ns3::Vector3D'], 'Vector') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyTxStartCallback') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyTxStartCallback*') - typehandlers.add_type_alias(u'ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyTxStartCallback&') typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >', u'ns3::UlHarqProcessesDciBuffer_t') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >*', u'ns3::UlHarqProcessesDciBuffer_t*') - typehandlers.add_type_alias(u'std::vector< ns3::UlDciListElement_s, std::allocator< ns3::UlDciListElement_s > >&', u'ns3::UlHarqProcessesDciBuffer_t&') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxCtrlEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxCtrlEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage >, std::allocator< ns3::Ptr< ns3::LteControlMessage > > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxCtrlEndOkCallback&') - typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') - typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') - typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >', u'ns3::DoubleMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >*', u'ns3::DoubleMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, double, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, double > > >&', u'ns3::DoubleMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyUlHarqFeedbackCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyUlHarqFeedbackCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyUlHarqFeedbackCallback&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >', u'ns3::Uint64StatsMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >*', u'ns3::Uint64StatsMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned long long > > > > >&', u'ns3::Uint64StatsMap&') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >', u'ns3::RlcPduList_t') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >*', u'ns3::RlcPduList_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > >, std::allocator< std::vector< ns3::RlcPduListElement_s, std::allocator< ns3::RlcPduListElement_s > > > >&', u'ns3::RlcPduList_t&') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >', u'ns3::DlHarqProcessesDciBuffer_t') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >*', u'ns3::DlHarqProcessesDciBuffer_t*') - typehandlers.add_type_alias(u'std::vector< ns3::DlDciListElement_s, std::allocator< ns3::DlDciListElement_s > >&', u'ns3::DlHarqProcessesDciBuffer_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >', u'ns3::FlowIdMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >*', u'ns3::FlowIdMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::LteFlowId_t, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::LteFlowId_t > > >&', u'ns3::FlowIdMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LteChunkProcessorCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LteChunkProcessorCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LteChunkProcessorCallback&') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *', u'ns3::LogTimePrinter') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) **', u'ns3::LogTimePrinter*') - typehandlers.add_type_alias(u'void ( * ) ( std::ostream & ) *&', u'ns3::LogTimePrinter&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::DlHarqProcessesTimer_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::DlHarqProcessesTimer_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::DlHarqProcessesTimer_t&') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >', u'ns3::Uint32StatsMap') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >*', u'ns3::Uint32StatsMap*') - typehandlers.add_type_alias(u'std::map< ns3::ImsiLcidPair_t, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > >, std::less< ns3::ImsiLcidPair_t >, std::allocator< std::pair< ns3::ImsiLcidPair_t const, ns3::Ptr< ns3::MinMaxAvgTotalCalculator< unsigned int > > > > >&', u'ns3::Uint32StatsMap&') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::LtePhyRxPssCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::LtePhyRxPssCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::LtePhyRxPssCallback&') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', u'ns3::GenericPhyRxEndOkCallback') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', u'ns3::GenericPhyRxEndOkCallback*') - typehandlers.add_type_alias(u'ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', u'ns3::GenericPhyRxEndOkCallback&') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >', u'ns3::DlHarqProcessesBuffer_t') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >*', u'ns3::DlHarqProcessesBuffer_t*') - typehandlers.add_type_alias(u'std::vector< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > >, std::allocator< std::vector< ns3::Ptr< ns3::PacketBurst >, std::allocator< ns3::Ptr< ns3::PacketBurst > > > > >&', u'ns3::DlHarqProcessesBuffer_t&') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >', u'ns3::UlHarqProcessesStatus_t') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >*', u'ns3::UlHarqProcessesStatus_t*') - typehandlers.add_type_alias(u'std::vector< unsigned char, std::allocator< unsigned char > >&', u'ns3::UlHarqProcessesStatus_t&') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >', u'ns3::Values') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >*', u'ns3::Values*') + typehandlers.add_type_alias(u'std::vector< double, std::allocator< double > >&', u'ns3::Values&') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', u'ns3::Bands') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', u'ns3::Bands*') + typehandlers.add_type_alias(u'std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', u'ns3::Bands&') + typehandlers.add_type_alias(u'uint32_t', u'ns3::SpectrumModelUid_t') + typehandlers.add_type_alias(u'uint32_t*', u'ns3::SpectrumModelUid_t*') + typehandlers.add_type_alias(u'uint32_t&', u'ns3::SpectrumModelUid_t&') ## Register a nested module for the namespace Config @@ -1634,12 +1746,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -1662,36 +1774,36 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -1721,6 +1833,24 @@ def register_methods(root_module): register_Ns3CqiListElement_s_methods(root_module, root_module['ns3::CqiListElement_s']) register_Ns3DataOutputCallback_methods(root_module, root_module['ns3::DataOutputCallback']) register_Ns3DataRate_methods(root_module, root_module['ns3::DataRate']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EpcTft_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EpcTft >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3LteChunkProcessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteChunkProcessor >']) + register_Ns3DefaultDeleter__Ns3LteControlMessage_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteControlMessage >']) + register_Ns3DefaultDeleter__Ns3LteHarqPhy_methods(root_module, root_module['ns3::DefaultDeleter< ns3::LteHarqPhy >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumModel >']) + register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::SpectrumValue >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) + register_Ns3DefaultDeleter__Ns3VendorSpecificValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::VendorSpecificValue >']) + register_Ns3DefaultDeleter__Ns3X2CellInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2CellInfo >']) + register_Ns3DefaultDeleter__Ns3X2IfaceInfo_methods(root_module, root_module['ns3::DefaultDeleter< ns3::X2IfaceInfo >']) register_Ns3DlDciListElement_s_methods(root_module, root_module['ns3::DlDciListElement_s']) register_Ns3DlInfoListElement_s_methods(root_module, root_module['ns3::DlInfoListElement_s']) register_Ns3DlSchedulingCallbackInfo_methods(root_module, root_module['ns3::DlSchedulingCallbackInfo']) @@ -2213,6 +2343,8 @@ def register_methods(root_module): register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue']) register_Ns3MacStatsCalculator_methods(root_module, root_module['ns3::MacStatsCalculator']) register_Ns3MibLteControlMessage_methods(root_module, root_module['ns3::MibLteControlMessage']) + register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned int >']) + register_Ns3MinMaxAvgTotalCalculator__Unsigned_long_methods(root_module, root_module['ns3::MinMaxAvgTotalCalculator< unsigned long long >']) register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel']) register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice']) register_Ns3NixVector_methods(root_module, root_module['ns3::NixVector']) @@ -2269,6 +2401,42 @@ def register_methods(root_module): register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) register_Ns3BsrLteControlMessage_methods(root_module, root_module['ns3::BsrLteControlMessage']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Packet__gt___Const_ns3Address___amp___Const_ns3Address___amp___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Const_ns3SpectrumValue___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, const ns3::SpectrumValue &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3DlSchedulingCallbackInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::DlSchedulingCallbackInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3EpcUeNasState_Ns3EpcUeNasState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::EpcUeNas::State, ns3::EpcUeNas::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3PhyReceptionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyReceptionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3PhyTransmissionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::PhyTransmissionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3PacketBurst__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, unsigned short, unsigned char, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteRrcSapMeasurementReport_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::LteRrcSap::MeasurementReport, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteUeRrcState_Ns3LteUeRrcState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::LteUeRrc::State, ns3::LteUeRrc::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3UeManagerState_Ns3UeManagerState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::UeManager::State, ns3::UeManager::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Ns3Ptr__lt__ns3SpectrumValue__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, unsigned long long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Bool_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, bool, unsigned char, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3LteUePhyState_Ns3LteUePhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::LteUePhy::State, ns3::LteUePhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3CqaFfMacScheduler_methods(root_module, root_module['ns3::CqaFfMacScheduler']) register_Ns3DlCqiLteControlMessage_methods(root_module, root_module['ns3::DlCqiLteControlMessage']) register_Ns3DlDciLteControlMessage_methods(root_module, root_module['ns3::DlDciLteControlMessage']) @@ -2304,15 +2472,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -2374,7 +2542,7 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3AllocationRetentionPriority_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority(ns3::AllocationRetentionPriority const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority(ns3::AllocationRetentionPriority const & arg0) [constructor] cls.add_constructor([param('ns3::AllocationRetentionPriority const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::AllocationRetentionPriority::AllocationRetentionPriority() [constructor] cls.add_constructor([]) @@ -2387,25 +2555,25 @@ def register_Ns3AllocationRetentionPriority_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -2415,7 +2583,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -2428,7 +2596,7 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): def register_Ns3BandInfo_methods(root_module, cls): ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo() [constructor] cls.add_constructor([]) - ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [constructor] cls.add_constructor([param('ns3::BandInfo const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::BandInfo::fc [variable] cls.add_instance_attribute('fc', 'double', is_const=False) @@ -2439,14 +2607,14 @@ def register_Ns3BandInfo_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', @@ -2519,7 +2687,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -2681,7 +2849,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): def register_Ns3BufferSizeLevelBsr_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr(ns3::BufferSizeLevelBsr const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::BufferSizeLevelBsr::BufferSizeLevelBsr(ns3::BufferSizeLevelBsr const & arg0) [constructor] cls.add_constructor([param('ns3::BufferSizeLevelBsr const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint32_t ns3::BufferSizeLevelBsr::BsrId2BufferSize(uint8_t val) [member function] cls.add_method('BsrId2BufferSize', @@ -2700,7 +2868,7 @@ def register_Ns3BufferSizeLevelBsr_methods(root_module, cls): def register_Ns3BuildBroadcastListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s(ns3::BuildBroadcastListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::BuildBroadcastListElement_s(ns3::BuildBroadcastListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildBroadcastListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildBroadcastListElement_s::m_dci [variable] cls.add_instance_attribute('m_dci', 'ns3::DlDciListElement_s', is_const=False) @@ -2713,7 +2881,7 @@ def register_Ns3BuildBroadcastListElement_s_methods(root_module, cls): def register_Ns3BuildDataListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s(ns3::BuildDataListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::BuildDataListElement_s(ns3::BuildDataListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildDataListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildDataListElement_s::m_ceBitmap [variable] cls.add_instance_attribute('m_ceBitmap', 'std::vector< ns3::CeBitmap_e >', is_const=False) @@ -2728,7 +2896,7 @@ def register_Ns3BuildDataListElement_s_methods(root_module, cls): def register_Ns3BuildRarListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s(ns3::BuildRarListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::BuildRarListElement_s(ns3::BuildRarListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::BuildRarListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BuildRarListElement_s::m_dci [variable] cls.add_instance_attribute('m_dci', 'ns3::DlDciListElement_s', is_const=False) @@ -2741,7 +2909,7 @@ def register_Ns3BuildRarListElement_s_methods(root_module, cls): def register_Ns3BwPart_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s(ns3::BwPart_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::BwPart_s(ns3::BwPart_s const & arg0) [constructor] cls.add_constructor([param('ns3::BwPart_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::BwPart_s::m_bwPartIndex [variable] cls.add_instance_attribute('m_bwPartIndex', 'uint8_t', is_const=False) @@ -2752,7 +2920,7 @@ def register_Ns3BwPart_s_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2766,7 +2934,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -2793,7 +2961,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -2827,7 +2995,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -2846,7 +3014,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -2863,7 +3031,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -2880,7 +3048,7 @@ def register_Ns3CallbackBase_methods(root_module, cls): def register_Ns3CqasFlowPerf_t_methods(root_module, cls): ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t() [constructor] cls.add_constructor([]) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t(ns3::CqasFlowPerf_t const & arg0) [copy constructor] + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::CqasFlowPerf_t(ns3::CqasFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::CqasFlowPerf_t const &', 'arg0')]) ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqasFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -2899,7 +3067,7 @@ def register_Ns3CqasFlowPerf_t_methods(root_module, cls): def register_Ns3CqiConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s(ns3::CqiConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::CqiConfig_s(ns3::CqiConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::CqiConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::CqiConfig_s::m_action [variable] cls.add_instance_attribute('m_action', 'ns3::SetupRelease_e', is_const=False) @@ -2912,7 +3080,7 @@ def register_Ns3CqiConfig_s_methods(root_module, cls): def register_Ns3CqiListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s(ns3::CqiListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::CqiListElement_s(ns3::CqiListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::CqiListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::CqiListElement_s::m_cqiType [variable] cls.add_instance_attribute('m_cqiType', 'ns3::CqiListElement_s::CqiType_e', is_const=False) @@ -2931,7 +3099,7 @@ def register_Ns3CqiListElement_s_methods(root_module, cls): def register_Ns3DataOutputCallback_methods(root_module, cls): ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback() [constructor] cls.add_constructor([]) - ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputCallback::DataOutputCallback(ns3::DataOutputCallback const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputCallback const &', 'arg0')]) ## data-output-interface.h (module 'stats'): void ns3::DataOutputCallback::OutputSingleton(std::string key, std::string variable, int val) [member function] cls.add_method('OutputSingleton', @@ -2973,7 +3141,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('>') cls.add_binary_comparison_operator('>=') - ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRate::DataRate(ns3::DataRate const & arg0) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRate::DataRate() [constructor] cls.add_constructor([]) @@ -2995,7 +3163,7 @@ def register_Ns3DataRate_methods(root_module, cls): cls.add_method('CalculateTxTime', 'double', [param('uint32_t', 'bytes')], - deprecated=True, is_const=True) + is_const=True) ## data-rate.h (module 'network'): uint64_t ns3::DataRate::GetBitRate() const [member function] cls.add_method('GetBitRate', 'uint64_t', @@ -3003,90 +3171,306 @@ def register_Ns3DataRate_methods(root_module, cls): is_const=True) return -def register_Ns3DlDciListElement_s_methods(root_module, cls): - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s(ns3::DlDciListElement_s const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlDciListElement_s const &', 'arg0')]) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_aggrLevel [variable] - cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_cceIndex [variable] - cls.add_instance_attribute('m_cceIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dai [variable] - cls.add_instance_attribute('m_dai', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dlPowerOffset [variable] - cls.add_instance_attribute('m_dlPowerOffset', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_format [variable] - cls.add_instance_attribute('m_format', 'ns3::DlDciListElement_s::Format_e', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_harqProcess [variable] - cls.add_instance_attribute('m_harqProcess', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_mcs [variable] - cls.add_instance_attribute('m_mcs', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_nGap [variable] - cls.add_instance_attribute('m_nGap', 'ns3::DlDciListElement_s::Ngap_e', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_ndi [variable] - cls.add_instance_attribute('m_ndi', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchOrder [variable] - cls.add_instance_attribute('m_pdcchOrder', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchPowerOffset [variable] - cls.add_instance_attribute('m_pdcchPowerOffset', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_prachMaskIndex [variable] - cls.add_instance_attribute('m_prachMaskIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_preambleIndex [variable] - cls.add_instance_attribute('m_preambleIndex', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_precodingInfo [variable] - cls.add_instance_attribute('m_precodingInfo', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbBitmap [variable] - cls.add_instance_attribute('m_rbBitmap', 'uint32_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbShift [variable] - cls.add_instance_attribute('m_rbShift', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_resAlloc [variable] - cls.add_instance_attribute('m_resAlloc', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rnti [variable] - cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rv [variable] - cls.add_instance_attribute('m_rv', 'std::vector< unsigned char >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_spsRelease [variable] - cls.add_instance_attribute('m_spsRelease', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbSwap [variable] - cls.add_instance_attribute('m_tbSwap', 'bool', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsIdx [variable] - cls.add_instance_attribute('m_tbsIdx', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsSize [variable] - cls.add_instance_attribute('m_tbsSize', 'std::vector< unsigned short >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tpc [variable] - cls.add_instance_attribute('m_tpc', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_vrbFormat [variable] - cls.add_instance_attribute('m_vrbFormat', 'ns3::DlDciListElement_s::VrbFormat_e', is_const=False) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) return -def register_Ns3DlInfoListElement_s_methods(root_module, cls): - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s(ns3::DlInfoListElement_s const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlInfoListElement_s const &', 'arg0')]) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqProcessId [variable] - cls.add_instance_attribute('m_harqProcessId', 'uint8_t', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqStatus [variable] - cls.add_instance_attribute('m_harqStatus', 'std::vector< ns3::DlInfoListElement_s::HarqStatus_e >', is_const=False) - ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_rnti [variable] - cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) return -def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo() [constructor] +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo(ns3::DlSchedulingCallbackInfo const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlSchedulingCallbackInfo const &', 'arg0')]) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::componentCarrierId [variable] - cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::frameNo [variable] - cls.add_instance_attribute('frameNo', 'uint32_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb1 [variable] - cls.add_instance_attribute('mcsTb1', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb2 [variable] - cls.add_instance_attribute('mcsTb2', 'uint8_t', is_const=False) - ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::rnti [variable] + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EpcTft_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EpcTft > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EpcTft * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EpcTft *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteChunkProcessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteChunkProcessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteChunkProcessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteChunkProcessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteControlMessage_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteControlMessage > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteControlMessage * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteControlMessage *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3LteHarqPhy_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::LteHarqPhy > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::LteHarqPhy * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::LteHarqPhy *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumModel_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumModel > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumModel * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SpectrumModel *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3SpectrumValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::SpectrumValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::SpectrumValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::SpectrumValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3VendorSpecificValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::VendorSpecificValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::VendorSpecificValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::VendorSpecificValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3X2CellInfo_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::X2CellInfo > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::X2CellInfo * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::X2CellInfo *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3X2IfaceInfo_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::X2IfaceInfo > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::X2IfaceInfo * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::X2IfaceInfo *', 'object')], + is_static=True) + return + +def register_Ns3DlDciListElement_s_methods(root_module, cls): + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s() [constructor] + cls.add_constructor([]) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::DlDciListElement_s(ns3::DlDciListElement_s const & arg0) [constructor] + cls.add_constructor([param('ns3::DlDciListElement_s const &', 'arg0')]) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_aggrLevel [variable] + cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_cceIndex [variable] + cls.add_instance_attribute('m_cceIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dai [variable] + cls.add_instance_attribute('m_dai', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_dlPowerOffset [variable] + cls.add_instance_attribute('m_dlPowerOffset', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_format [variable] + cls.add_instance_attribute('m_format', 'ns3::DlDciListElement_s::Format_e', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_harqProcess [variable] + cls.add_instance_attribute('m_harqProcess', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_mcs [variable] + cls.add_instance_attribute('m_mcs', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_nGap [variable] + cls.add_instance_attribute('m_nGap', 'ns3::DlDciListElement_s::Ngap_e', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_ndi [variable] + cls.add_instance_attribute('m_ndi', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchOrder [variable] + cls.add_instance_attribute('m_pdcchOrder', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_pdcchPowerOffset [variable] + cls.add_instance_attribute('m_pdcchPowerOffset', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_prachMaskIndex [variable] + cls.add_instance_attribute('m_prachMaskIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_preambleIndex [variable] + cls.add_instance_attribute('m_preambleIndex', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_precodingInfo [variable] + cls.add_instance_attribute('m_precodingInfo', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbBitmap [variable] + cls.add_instance_attribute('m_rbBitmap', 'uint32_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rbShift [variable] + cls.add_instance_attribute('m_rbShift', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_resAlloc [variable] + cls.add_instance_attribute('m_resAlloc', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rnti [variable] + cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_rv [variable] + cls.add_instance_attribute('m_rv', 'std::vector< unsigned char >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_spsRelease [variable] + cls.add_instance_attribute('m_spsRelease', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbSwap [variable] + cls.add_instance_attribute('m_tbSwap', 'bool', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsIdx [variable] + cls.add_instance_attribute('m_tbsIdx', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tbsSize [variable] + cls.add_instance_attribute('m_tbsSize', 'std::vector< unsigned short >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_tpc [variable] + cls.add_instance_attribute('m_tpc', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlDciListElement_s::m_vrbFormat [variable] + cls.add_instance_attribute('m_vrbFormat', 'ns3::DlDciListElement_s::VrbFormat_e', is_const=False) + return + +def register_Ns3DlInfoListElement_s_methods(root_module, cls): + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s() [constructor] + cls.add_constructor([]) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::DlInfoListElement_s(ns3::DlInfoListElement_s const & arg0) [constructor] + cls.add_constructor([param('ns3::DlInfoListElement_s const &', 'arg0')]) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqProcessId [variable] + cls.add_instance_attribute('m_harqProcessId', 'uint8_t', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_harqStatus [variable] + cls.add_instance_attribute('m_harqStatus', 'std::vector< ns3::DlInfoListElement_s::HarqStatus_e >', is_const=False) + ## ff-mac-common.h (module 'lte'): ns3::DlInfoListElement_s::m_rnti [variable] + cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) + return + +def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo() [constructor] + cls.add_constructor([]) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::DlSchedulingCallbackInfo(ns3::DlSchedulingCallbackInfo const & arg0) [constructor] + cls.add_constructor([param('ns3::DlSchedulingCallbackInfo const &', 'arg0')]) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::componentCarrierId [variable] + cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::frameNo [variable] + cls.add_instance_attribute('frameNo', 'uint32_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb1 [variable] + cls.add_instance_attribute('mcsTb1', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::mcsTb2 [variable] + cls.add_instance_attribute('mcsTb2', 'uint8_t', is_const=False) + ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::rnti [variable] cls.add_instance_attribute('rnti', 'uint16_t', is_const=False) ## lte-common.h (module 'lte'): ns3::DlSchedulingCallbackInfo::sizeTb1 [variable] cls.add_instance_attribute('sizeTb1', 'uint16_t', is_const=False) @@ -3099,7 +3483,7 @@ def register_Ns3DlSchedulingCallbackInfo_methods(root_module, cls): def register_Ns3DrxConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s(ns3::DrxConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::DrxConfig_s(ns3::DrxConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::DrxConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::DrxConfig_s::m_drxInactivityTimer [variable] cls.add_instance_attribute('m_drxInactivityTimer', 'uint16_t', is_const=False) @@ -3120,7 +3504,7 @@ def register_Ns3DrxConfig_s_methods(root_module, cls): def register_Ns3EpcEnbS1SapProvider_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider(ns3::EpcEnbS1SapProvider const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::EpcEnbS1SapProvider(ns3::EpcEnbS1SapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): void ns3::EpcEnbS1SapProvider::DoSendReleaseIndication(uint64_t imsi, uint16_t rnti, uint8_t bearerId) [member function] cls.add_method('DoSendReleaseIndication', @@ -3147,7 +3531,7 @@ def register_Ns3EpcEnbS1SapProvider_methods(root_module, cls): def register_Ns3EpcEnbS1SapProviderBearerToBeSwitched_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched(ns3::EpcEnbS1SapProvider::BearerToBeSwitched const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::BearerToBeSwitched(ns3::EpcEnbS1SapProvider::BearerToBeSwitched const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider::BearerToBeSwitched const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::BearerToBeSwitched::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3158,7 +3542,7 @@ def register_Ns3EpcEnbS1SapProviderBearerToBeSwitched_methods(root_module, cls): def register_Ns3EpcEnbS1SapProviderPathSwitchRequestParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters(ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::PathSwitchRequestParameters(ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapProvider::PathSwitchRequestParameters::bearersToBeSwitched [variable] cls.add_instance_attribute('bearersToBeSwitched', 'std::list< ns3::EpcEnbS1SapProvider::BearerToBeSwitched >', is_const=False) @@ -3173,7 +3557,7 @@ def register_Ns3EpcEnbS1SapProviderPathSwitchRequestParameters_methods(root_modu def register_Ns3EpcEnbS1SapUser_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser(ns3::EpcEnbS1SapUser const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::EpcEnbS1SapUser(ns3::EpcEnbS1SapUser const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): void ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequest(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters params) [member function] cls.add_method('DataRadioBearerSetupRequest', @@ -3190,7 +3574,7 @@ def register_Ns3EpcEnbS1SapUser_methods(root_module, cls): def register_Ns3EpcEnbS1SapUserDataRadioBearerSetupRequestParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::DataRadioBearerSetupRequestParameters(ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::bearer [variable] cls.add_instance_attribute('bearer', 'ns3::EpsBearer', is_const=False) @@ -3207,7 +3591,7 @@ def register_Ns3EpcEnbS1SapUserDataRadioBearerSetupRequestParameters_methods(roo def register_Ns3EpcEnbS1SapUserPathSwitchRequestAcknowledgeParameters_methods(root_module, cls): ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters() [constructor] cls.add_constructor([]) - ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters(ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const & arg0) [copy constructor] + ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::PathSwitchRequestAcknowledgeParameters(ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters const &', 'arg0')]) ## epc-enb-s1-sap.h (module 'lte'): ns3::EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters::rnti [variable] cls.add_instance_attribute('rnti', 'uint16_t', is_const=False) @@ -3216,14 +3600,14 @@ def register_Ns3EpcEnbS1SapUserPathSwitchRequestAcknowledgeParameters_methods(ro def register_Ns3EpcS11Sap_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap(ns3::EpcS11Sap const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::EpcS11Sap(ns3::EpcS11Sap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap const &', 'arg0')]) return def register_Ns3EpcS11SapFteid_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid(ns3::EpcS11Sap::Fteid const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::Fteid(ns3::EpcS11Sap::Fteid const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::Fteid const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Fteid::address [variable] cls.add_instance_attribute('address', 'ns3::Ipv4Address', is_const=False) @@ -3234,7 +3618,7 @@ def register_Ns3EpcS11SapFteid_methods(root_module, cls): def register_Ns3EpcS11SapGtpcMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage(ns3::EpcS11Sap::GtpcMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::GtpcMessage(ns3::EpcS11Sap::GtpcMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::GtpcMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::GtpcMessage::teid [variable] cls.add_instance_attribute('teid', 'uint32_t', is_const=False) @@ -3243,7 +3627,7 @@ def register_Ns3EpcS11SapGtpcMessage_methods(root_module, cls): def register_Ns3EpcS11SapUli_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli(ns3::EpcS11Sap::Uli const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::Uli(ns3::EpcS11Sap::Uli const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11Sap::Uli const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11Sap::Uli::gci [variable] cls.add_instance_attribute('gci', 'uint16_t', is_const=False) @@ -3252,7 +3636,7 @@ def register_Ns3EpcS11SapUli_methods(root_module, cls): def register_Ns3EpcS11SapMme_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme(ns3::EpcS11SapMme const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::EpcS11SapMme(ns3::EpcS11SapMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): void ns3::EpcS11SapMme::CreateSessionResponse(ns3::EpcS11SapMme::CreateSessionResponseMessage msg) [member function] cls.add_method('CreateSessionResponse', @@ -3274,7 +3658,7 @@ def register_Ns3EpcS11SapMme_methods(root_module, cls): def register_Ns3EpcS11SapMmeBearerContextCreated_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated(ns3::EpcS11SapMme::BearerContextCreated const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::BearerContextCreated(ns3::EpcS11SapMme::BearerContextCreated const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::BearerContextCreated const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextCreated::bearerLevelQos [variable] cls.add_instance_attribute('bearerLevelQos', 'ns3::EpsBearer', is_const=False) @@ -3289,7 +3673,7 @@ def register_Ns3EpcS11SapMmeBearerContextCreated_methods(root_module, cls): def register_Ns3EpcS11SapMmeBearerContextRemoved_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved(ns3::EpcS11SapMme::BearerContextRemoved const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::BearerContextRemoved(ns3::EpcS11SapMme::BearerContextRemoved const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::BearerContextRemoved const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::BearerContextRemoved::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3298,7 +3682,7 @@ def register_Ns3EpcS11SapMmeBearerContextRemoved_methods(root_module, cls): def register_Ns3EpcS11SapMmeCreateSessionResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage(ns3::EpcS11SapMme::CreateSessionResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::CreateSessionResponseMessage(ns3::EpcS11SapMme::CreateSessionResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::CreateSessionResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::CreateSessionResponseMessage::bearerContextsCreated [variable] cls.add_instance_attribute('bearerContextsCreated', 'std::list< ns3::EpcS11SapMme::BearerContextCreated >', is_const=False) @@ -3307,7 +3691,7 @@ def register_Ns3EpcS11SapMmeCreateSessionResponseMessage_methods(root_module, cl def register_Ns3EpcS11SapMmeDeleteBearerRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage(ns3::EpcS11SapMme::DeleteBearerRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::DeleteBearerRequestMessage(ns3::EpcS11SapMme::DeleteBearerRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::DeleteBearerRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::DeleteBearerRequestMessage::bearerContextsRemoved [variable] cls.add_instance_attribute('bearerContextsRemoved', 'std::list< ns3::EpcS11SapMme::BearerContextRemoved >', is_const=False) @@ -3316,7 +3700,7 @@ def register_Ns3EpcS11SapMmeDeleteBearerRequestMessage_methods(root_module, cls) def register_Ns3EpcS11SapMmeModifyBearerResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage(ns3::EpcS11SapMme::ModifyBearerResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::ModifyBearerResponseMessage(ns3::EpcS11SapMme::ModifyBearerResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapMme::ModifyBearerResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapMme::ModifyBearerResponseMessage::cause [variable] cls.add_instance_attribute('cause', 'ns3::EpcS11SapMme::ModifyBearerResponseMessage::Cause', is_const=False) @@ -3325,7 +3709,7 @@ def register_Ns3EpcS11SapMmeModifyBearerResponseMessage_methods(root_module, cls def register_Ns3EpcS11SapSgw_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw(ns3::EpcS11SapSgw const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::EpcS11SapSgw(ns3::EpcS11SapSgw const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): void ns3::EpcS11SapSgw::CreateSessionRequest(ns3::EpcS11SapSgw::CreateSessionRequestMessage msg) [member function] cls.add_method('CreateSessionRequest', @@ -3352,7 +3736,7 @@ def register_Ns3EpcS11SapSgw_methods(root_module, cls): def register_Ns3EpcS11SapSgwBearerContextRemovedSgwPgw_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw(ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::BearerContextRemovedSgwPgw(ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3361,7 +3745,7 @@ def register_Ns3EpcS11SapSgwBearerContextRemovedSgwPgw_methods(root_module, cls) def register_Ns3EpcS11SapSgwBearerContextToBeCreated_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated(ns3::EpcS11SapSgw::BearerContextToBeCreated const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::BearerContextToBeCreated(ns3::EpcS11SapSgw::BearerContextToBeCreated const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextToBeCreated const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeCreated::bearerLevelQos [variable] cls.add_instance_attribute('bearerLevelQos', 'ns3::EpsBearer', is_const=False) @@ -3376,7 +3760,7 @@ def register_Ns3EpcS11SapSgwBearerContextToBeCreated_methods(root_module, cls): def register_Ns3EpcS11SapSgwBearerContextToBeRemoved_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved(ns3::EpcS11SapSgw::BearerContextToBeRemoved const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::BearerContextToBeRemoved(ns3::EpcS11SapSgw::BearerContextToBeRemoved const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::BearerContextToBeRemoved const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::BearerContextToBeRemoved::epsBearerId [variable] cls.add_instance_attribute('epsBearerId', 'uint8_t', is_const=False) @@ -3385,7 +3769,7 @@ def register_Ns3EpcS11SapSgwBearerContextToBeRemoved_methods(root_module, cls): def register_Ns3EpcS11SapSgwCreateSessionRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage(ns3::EpcS11SapSgw::CreateSessionRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::CreateSessionRequestMessage(ns3::EpcS11SapSgw::CreateSessionRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::CreateSessionRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::CreateSessionRequestMessage::bearerContextsToBeCreated [variable] cls.add_instance_attribute('bearerContextsToBeCreated', 'std::list< ns3::EpcS11SapSgw::BearerContextToBeCreated >', is_const=False) @@ -3398,7 +3782,7 @@ def register_Ns3EpcS11SapSgwCreateSessionRequestMessage_methods(root_module, cls def register_Ns3EpcS11SapSgwDeleteBearerCommandMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage(ns3::EpcS11SapSgw::DeleteBearerCommandMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::DeleteBearerCommandMessage(ns3::EpcS11SapSgw::DeleteBearerCommandMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::DeleteBearerCommandMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerCommandMessage::bearerContextsToBeRemoved [variable] cls.add_instance_attribute('bearerContextsToBeRemoved', 'std::list< ns3::EpcS11SapSgw::BearerContextToBeRemoved >', is_const=False) @@ -3407,7 +3791,7 @@ def register_Ns3EpcS11SapSgwDeleteBearerCommandMessage_methods(root_module, cls) def register_Ns3EpcS11SapSgwDeleteBearerResponseMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage(ns3::EpcS11SapSgw::DeleteBearerResponseMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::DeleteBearerResponseMessage(ns3::EpcS11SapSgw::DeleteBearerResponseMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::DeleteBearerResponseMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::DeleteBearerResponseMessage::bearerContextsRemoved [variable] cls.add_instance_attribute('bearerContextsRemoved', 'std::list< ns3::EpcS11SapSgw::BearerContextRemovedSgwPgw >', is_const=False) @@ -3416,7 +3800,7 @@ def register_Ns3EpcS11SapSgwDeleteBearerResponseMessage_methods(root_module, cls def register_Ns3EpcS11SapSgwModifyBearerRequestMessage_methods(root_module, cls): ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage() [constructor] cls.add_constructor([]) - ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage(ns3::EpcS11SapSgw::ModifyBearerRequestMessage const & arg0) [copy constructor] + ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::ModifyBearerRequestMessage(ns3::EpcS11SapSgw::ModifyBearerRequestMessage const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS11SapSgw::ModifyBearerRequestMessage const &', 'arg0')]) ## epc-s11-sap.h (module 'lte'): ns3::EpcS11SapSgw::ModifyBearerRequestMessage::uli [variable] cls.add_instance_attribute('uli', 'ns3::EpcS11Sap::Uli', is_const=False) @@ -3425,14 +3809,14 @@ def register_Ns3EpcS11SapSgwModifyBearerRequestMessage_methods(root_module, cls) def register_Ns3EpcS1apSap_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap(ns3::EpcS1apSap const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSap::EpcS1apSap(ns3::EpcS1apSap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSap const &', 'arg0')]) return def register_Ns3EpcS1apSapEnb_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb(ns3::EpcS1apSapEnb const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::EpcS1apSapEnb(ns3::EpcS1apSapEnb const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): void ns3::EpcS1apSapEnb::InitialContextSetupRequest(uint64_t mmeUeS1Id, uint16_t enbUeS1Id, std::list > erabToBeSetupList) [member function] cls.add_method('InitialContextSetupRequest', @@ -3449,7 +3833,7 @@ def register_Ns3EpcS1apSapEnb_methods(root_module, cls): def register_Ns3EpcS1apSapEnbErabSwitchedInUplinkItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem(ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::ErabSwitchedInUplinkItem(ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabSwitchedInUplinkItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3462,7 +3846,7 @@ def register_Ns3EpcS1apSapEnbErabSwitchedInUplinkItem_methods(root_module, cls): def register_Ns3EpcS1apSapEnbErabToBeSetupItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcS1apSapEnb::ErabToBeSetupItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcS1apSapEnb::ErabToBeSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapEnb::ErabToBeSetupItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapEnb::ErabToBeSetupItem::erabId [variable] cls.add_instance_attribute('erabId', 'uint8_t', is_const=False) @@ -3477,7 +3861,7 @@ def register_Ns3EpcS1apSapEnbErabToBeSetupItem_methods(root_module, cls): def register_Ns3EpcS1apSapMme_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme(ns3::EpcS1apSapMme const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::EpcS1apSapMme(ns3::EpcS1apSapMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): void ns3::EpcS1apSapMme::ErabReleaseIndication(uint64_t mmeUeS1Id, uint16_t enbUeS1Id, std::list > erabToBeReleaseIndication) [member function] cls.add_method('ErabReleaseIndication', @@ -3504,7 +3888,7 @@ def register_Ns3EpcS1apSapMme_methods(root_module, cls): def register_Ns3EpcS1apSapMmeErabSetupItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem(ns3::EpcS1apSapMme::ErabSetupItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::ErabSetupItem(ns3::EpcS1apSapMme::ErabSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabSetupItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSetupItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3517,7 +3901,7 @@ def register_Ns3EpcS1apSapMmeErabSetupItem_methods(root_module, cls): def register_Ns3EpcS1apSapMmeErabSwitchedInDownlinkItem_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem(ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::ErabSwitchedInDownlinkItem(ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabSwitchedInDownlinkItem::enbTeid [variable] cls.add_instance_attribute('enbTeid', 'uint32_t', is_const=False) @@ -3530,7 +3914,7 @@ def register_Ns3EpcS1apSapMmeErabSwitchedInDownlinkItem_methods(root_module, cls def register_Ns3EpcS1apSapMmeErabToBeReleasedIndication_methods(root_module, cls): ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication() [constructor] cls.add_constructor([]) - ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication(ns3::EpcS1apSapMme::ErabToBeReleasedIndication const & arg0) [copy constructor] + ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::ErabToBeReleasedIndication(ns3::EpcS1apSapMme::ErabToBeReleasedIndication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcS1apSapMme::ErabToBeReleasedIndication const &', 'arg0')]) ## epc-s1ap-sap.h (module 'lte'): ns3::EpcS1apSapMme::ErabToBeReleasedIndication::erabId [variable] cls.add_instance_attribute('erabId', 'uint8_t', is_const=False) @@ -3539,7 +3923,7 @@ def register_Ns3EpcS1apSapMmeErabToBeReleasedIndication_methods(root_module, cls def register_Ns3EpcX2Sap_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap(ns3::EpcX2Sap const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::EpcX2Sap(ns3::EpcX2Sap const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::m_maxPdcpSn [variable] cls.add_static_attribute('m_maxPdcpSn', 'uint16_t const', is_const=True) @@ -3548,7 +3932,7 @@ def register_Ns3EpcX2Sap_methods(root_module, cls): def register_Ns3EpcX2SapCellInformationItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem(ns3::EpcX2Sap::CellInformationItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::CellInformationItem(ns3::EpcX2Sap::CellInformationItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CellInformationItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellInformationItem::relativeNarrowbandTxBand [variable] cls.add_instance_attribute('relativeNarrowbandTxBand', 'ns3::EpcX2Sap::RelativeNarrowbandTxBand', is_const=False) @@ -3563,7 +3947,7 @@ def register_Ns3EpcX2SapCellInformationItem_methods(root_module, cls): def register_Ns3EpcX2SapCellMeasurementResultItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem(ns3::EpcX2Sap::CellMeasurementResultItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::CellMeasurementResultItem(ns3::EpcX2Sap::CellMeasurementResultItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CellMeasurementResultItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CellMeasurementResultItem::dlCompositeAvailableCapacity [variable] cls.add_instance_attribute('dlCompositeAvailableCapacity', 'ns3::EpcX2Sap::CompositeAvailCapacity', is_const=False) @@ -3596,7 +3980,7 @@ def register_Ns3EpcX2SapCellMeasurementResultItem_methods(root_module, cls): def register_Ns3EpcX2SapCompositeAvailCapacity_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity(ns3::EpcX2Sap::CompositeAvailCapacity const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::CompositeAvailCapacity(ns3::EpcX2Sap::CompositeAvailCapacity const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::CompositeAvailCapacity const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::CompositeAvailCapacity::capacityValue [variable] cls.add_instance_attribute('capacityValue', 'uint16_t', is_const=False) @@ -3607,7 +3991,7 @@ def register_Ns3EpcX2SapCompositeAvailCapacity_methods(root_module, cls): def register_Ns3EpcX2SapErabAdmittedItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem(ns3::EpcX2Sap::ErabAdmittedItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::ErabAdmittedItem(ns3::EpcX2Sap::ErabAdmittedItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabAdmittedItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabAdmittedItem::dlGtpTeid [variable] cls.add_instance_attribute('dlGtpTeid', 'uint32_t', is_const=False) @@ -3620,7 +4004,7 @@ def register_Ns3EpcX2SapErabAdmittedItem_methods(root_module, cls): def register_Ns3EpcX2SapErabNotAdmittedItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem(ns3::EpcX2Sap::ErabNotAdmittedItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::ErabNotAdmittedItem(ns3::EpcX2Sap::ErabNotAdmittedItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabNotAdmittedItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabNotAdmittedItem::cause [variable] cls.add_instance_attribute('cause', 'uint16_t', is_const=False) @@ -3629,7 +4013,7 @@ def register_Ns3EpcX2SapErabNotAdmittedItem_methods(root_module, cls): return def register_Ns3EpcX2SapErabToBeSetupItem_methods(root_module, cls): - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcX2Sap::ErabToBeSetupItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem(ns3::EpcX2Sap::ErabToBeSetupItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabToBeSetupItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabToBeSetupItem::ErabToBeSetupItem() [constructor] cls.add_constructor([]) @@ -3648,7 +4032,7 @@ def register_Ns3EpcX2SapErabToBeSetupItem_methods(root_module, cls): def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem(ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ErabsSubjectToStatusTransferItem(ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::dlHfn [variable] cls.add_instance_attribute('dlHfn', 'uint32_t', is_const=False) @@ -3657,7 +4041,7 @@ def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cl ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::erabId [variable] cls.add_instance_attribute('erabId', 'uint16_t', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::receiveStatusOfUlPdcpSdus [variable] - cls.add_instance_attribute('receiveStatusOfUlPdcpSdus', 'std::bitset< 4096u >', is_const=False) + cls.add_instance_attribute('receiveStatusOfUlPdcpSdus', 'std::bitset< 4096 >', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ulHfn [variable] cls.add_instance_attribute('ulHfn', 'uint32_t', is_const=False) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem::ulPdcpSn [variable] @@ -3667,7 +4051,7 @@ def register_Ns3EpcX2SapErabsSubjectToStatusTransferItem_methods(root_module, cl def register_Ns3EpcX2SapHandoverPreparationFailureParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams(ns3::EpcX2Sap::HandoverPreparationFailureParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::HandoverPreparationFailureParams(ns3::EpcX2Sap::HandoverPreparationFailureParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverPreparationFailureParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverPreparationFailureParams::cause [variable] cls.add_instance_attribute('cause', 'uint16_t', is_const=False) @@ -3684,7 +4068,7 @@ def register_Ns3EpcX2SapHandoverPreparationFailureParams_methods(root_module, cl def register_Ns3EpcX2SapHandoverRequestAckParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams(ns3::EpcX2Sap::HandoverRequestAckParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::HandoverRequestAckParams(ns3::EpcX2Sap::HandoverRequestAckParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverRequestAckParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestAckParams::admittedBearers [variable] cls.add_instance_attribute('admittedBearers', 'std::vector< ns3::EpcX2Sap::ErabAdmittedItem >', is_const=False) @@ -3705,7 +4089,7 @@ def register_Ns3EpcX2SapHandoverRequestAckParams_methods(root_module, cls): def register_Ns3EpcX2SapHandoverRequestParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams(ns3::EpcX2Sap::HandoverRequestParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::HandoverRequestParams(ns3::EpcX2Sap::HandoverRequestParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::HandoverRequestParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::HandoverRequestParams::bearers [variable] cls.add_instance_attribute('bearers', 'std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', is_const=False) @@ -3730,7 +4114,7 @@ def register_Ns3EpcX2SapHandoverRequestParams_methods(root_module, cls): def register_Ns3EpcX2SapLoadInformationParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams(ns3::EpcX2Sap::LoadInformationParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::LoadInformationParams(ns3::EpcX2Sap::LoadInformationParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::LoadInformationParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::LoadInformationParams::cellInformationList [variable] cls.add_instance_attribute('cellInformationList', 'std::vector< ns3::EpcX2Sap::CellInformationItem >', is_const=False) @@ -3741,7 +4125,7 @@ def register_Ns3EpcX2SapLoadInformationParams_methods(root_module, cls): def register_Ns3EpcX2SapRelativeNarrowbandTxBand_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand(ns3::EpcX2Sap::RelativeNarrowbandTxBand const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::RelativeNarrowbandTxBand(ns3::EpcX2Sap::RelativeNarrowbandTxBand const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::RelativeNarrowbandTxBand const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::RelativeNarrowbandTxBand::antennaPorts [variable] cls.add_instance_attribute('antennaPorts', 'uint16_t', is_const=False) @@ -3758,7 +4142,7 @@ def register_Ns3EpcX2SapRelativeNarrowbandTxBand_methods(root_module, cls): def register_Ns3EpcX2SapResourceStatusUpdateParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams(ns3::EpcX2Sap::ResourceStatusUpdateParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::ResourceStatusUpdateParams(ns3::EpcX2Sap::ResourceStatusUpdateParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::ResourceStatusUpdateParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::ResourceStatusUpdateParams::cellMeasurementResultList [variable] cls.add_instance_attribute('cellMeasurementResultList', 'std::vector< ns3::EpcX2Sap::CellMeasurementResultItem >', is_const=False) @@ -3773,7 +4157,7 @@ def register_Ns3EpcX2SapResourceStatusUpdateParams_methods(root_module, cls): def register_Ns3EpcX2SapSnStatusTransferParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams(ns3::EpcX2Sap::SnStatusTransferParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::SnStatusTransferParams(ns3::EpcX2Sap::SnStatusTransferParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::SnStatusTransferParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::SnStatusTransferParams::erabsSubjectToStatusTransferList [variable] cls.add_instance_attribute('erabsSubjectToStatusTransferList', 'std::vector< ns3::EpcX2Sap::ErabsSubjectToStatusTransferItem >', is_const=False) @@ -3790,7 +4174,7 @@ def register_Ns3EpcX2SapSnStatusTransferParams_methods(root_module, cls): def register_Ns3EpcX2SapUeContextReleaseParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams(ns3::EpcX2Sap::UeContextReleaseParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::UeContextReleaseParams(ns3::EpcX2Sap::UeContextReleaseParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UeContextReleaseParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeContextReleaseParams::newEnbUeX2apId [variable] cls.add_instance_attribute('newEnbUeX2apId', 'uint16_t', is_const=False) @@ -3805,7 +4189,7 @@ def register_Ns3EpcX2SapUeContextReleaseParams_methods(root_module, cls): def register_Ns3EpcX2SapUeDataParams_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams(ns3::EpcX2Sap::UeDataParams const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::UeDataParams(ns3::EpcX2Sap::UeDataParams const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UeDataParams const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UeDataParams::gtpTeid [variable] cls.add_instance_attribute('gtpTeid', 'uint32_t', is_const=False) @@ -3820,7 +4204,7 @@ def register_Ns3EpcX2SapUeDataParams_methods(root_module, cls): def register_Ns3EpcX2SapUlHighInterferenceInformationItem_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem(ns3::EpcX2Sap::UlHighInterferenceInformationItem const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::UlHighInterferenceInformationItem(ns3::EpcX2Sap::UlHighInterferenceInformationItem const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Sap::UlHighInterferenceInformationItem const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): ns3::EpcX2Sap::UlHighInterferenceInformationItem::targetCellId [variable] cls.add_instance_attribute('targetCellId', 'uint16_t', is_const=False) @@ -3831,7 +4215,7 @@ def register_Ns3EpcX2SapUlHighInterferenceInformationItem_methods(root_module, c def register_Ns3EpcX2SapProvider_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider(ns3::EpcX2SapProvider const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapProvider::EpcX2SapProvider(ns3::EpcX2SapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SapProvider const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): void ns3::EpcX2SapProvider::SendHandoverPreparationFailure(ns3::EpcX2Sap::HandoverPreparationFailureParams params) [member function] cls.add_method('SendHandoverPreparationFailure', @@ -3878,7 +4262,7 @@ def register_Ns3EpcX2SapProvider_methods(root_module, cls): def register_Ns3EpcX2SapUser_methods(root_module, cls): ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser() [constructor] cls.add_constructor([]) - ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser(ns3::EpcX2SapUser const & arg0) [copy constructor] + ## epc-x2-sap.h (module 'lte'): ns3::EpcX2SapUser::EpcX2SapUser(ns3::EpcX2SapUser const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SapUser const &', 'arg0')]) ## epc-x2-sap.h (module 'lte'): void ns3::EpcX2SapUser::RecvHandoverPreparationFailure(ns3::EpcX2Sap::HandoverPreparationFailureParams params) [member function] cls.add_method('RecvHandoverPreparationFailure', @@ -3923,7 +4307,7 @@ def register_Ns3EpcX2SapUser_methods(root_module, cls): return def register_Ns3EpsBearer_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer(ns3::EpsBearer const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer(ns3::EpsBearer const & arg0) [constructor] cls.add_constructor([param('ns3::EpsBearer const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::EpsBearer::EpsBearer() [constructor] cls.add_constructor([]) @@ -3962,7 +4346,7 @@ def register_Ns3EpsBearer_methods(root_module, cls): def register_Ns3EutranMeasurementMapping_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping(ns3::EutranMeasurementMapping const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::EutranMeasurementMapping::EutranMeasurementMapping(ns3::EutranMeasurementMapping const & arg0) [constructor] cls.add_constructor([param('ns3::EutranMeasurementMapping const &', 'arg0')]) ## lte-common.h (module 'lte'): static int8_t ns3::EutranMeasurementMapping::ActualA3Offset2IeValue(double a3OffsetDb) [member function] cls.add_method('ActualA3Offset2IeValue', @@ -4027,9 +4411,9 @@ def register_Ns3EutranMeasurementMapping_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -4074,7 +4458,7 @@ def register_Ns3EventId_methods(root_module, cls): def register_Ns3FfMacCschedSapProvider_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider(ns3::FfMacCschedSapProvider const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::FfMacCschedSapProvider(ns3::FfMacCschedSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): void ns3::FfMacCschedSapProvider::CschedCellConfigReq(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & params) [member function] cls.add_method('CschedCellConfigReq', @@ -4106,7 +4490,7 @@ def register_Ns3FfMacCschedSapProvider_methods(root_module, cls): def register_Ns3FfMacCschedSapProviderCschedCellConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::CschedCellConfigReqParameters(ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedCellConfigReqParameters::m_antennaPortsCount [variable] cls.add_instance_attribute('m_antennaPortsCount', 'uint8_t', is_const=False) @@ -4179,7 +4563,7 @@ def register_Ns3FfMacCschedSapProviderCschedCellConfigReqParameters_methods(root def register_Ns3FfMacCschedSapProviderCschedLcConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters(ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::CschedLcConfigReqParameters(ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcConfigReqParameters::m_logicalChannelConfigList [variable] cls.add_instance_attribute('m_logicalChannelConfigList', 'std::vector< ns3::LogicalChannelConfigListElement_s >', is_const=False) @@ -4194,7 +4578,7 @@ def register_Ns3FfMacCschedSapProviderCschedLcConfigReqParameters_methods(root_m def register_Ns3FfMacCschedSapProviderCschedLcReleaseReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::CschedLcReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedLcReleaseReqParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4207,7 +4591,7 @@ def register_Ns3FfMacCschedSapProviderCschedLcReleaseReqParameters_methods(root_ def register_Ns3FfMacCschedSapProviderCschedUeConfigReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters(ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::CschedUeConfigReqParameters(ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeConfigReqParameters::m_ackNackRepetitionFactor [variable] cls.add_instance_attribute('m_ackNackRepetitionFactor', 'uint8_t', is_const=False) @@ -4272,7 +4656,7 @@ def register_Ns3FfMacCschedSapProviderCschedUeConfigReqParameters_methods(root_m def register_Ns3FfMacCschedSapProviderCschedUeReleaseReqParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::CschedUeReleaseReqParameters(ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapProvider::CschedUeReleaseReqParameters::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -4283,7 +4667,7 @@ def register_Ns3FfMacCschedSapProviderCschedUeReleaseReqParameters_methods(root_ def register_Ns3FfMacCschedSapUser_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser(ns3::FfMacCschedSapUser const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::FfMacCschedSapUser(ns3::FfMacCschedSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): void ns3::FfMacCschedSapUser::CschedCellConfigCnf(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & params) [member function] cls.add_method('CschedCellConfigCnf', @@ -4325,7 +4709,7 @@ def register_Ns3FfMacCschedSapUser_methods(root_module, cls): def register_Ns3FfMacCschedSapUserCschedCellConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::CschedCellConfigCnfParameters(ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4336,7 +4720,7 @@ def register_Ns3FfMacCschedSapUserCschedCellConfigCnfParameters_methods(root_mod def register_Ns3FfMacCschedSapUserCschedCellConfigUpdateIndParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::CschedCellConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedCellConfigUpdateIndParameters::m_prbUtilizationDl [variable] cls.add_instance_attribute('m_prbUtilizationDl', 'uint8_t', is_const=False) @@ -4349,7 +4733,7 @@ def register_Ns3FfMacCschedSapUserCschedCellConfigUpdateIndParameters_methods(ro def register_Ns3FfMacCschedSapUserCschedLcConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters(ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::CschedLcConfigCnfParameters(ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcConfigCnfParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4364,7 +4748,7 @@ def register_Ns3FfMacCschedSapUserCschedLcConfigCnfParameters_methods(root_modul def register_Ns3FfMacCschedSapUserCschedLcReleaseCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::CschedLcReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedLcReleaseCnfParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'std::vector< unsigned char >', is_const=False) @@ -4379,7 +4763,7 @@ def register_Ns3FfMacCschedSapUserCschedLcReleaseCnfParameters_methods(root_modu def register_Ns3FfMacCschedSapUserCschedUeConfigCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters(ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::CschedUeConfigCnfParameters(ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4392,7 +4776,7 @@ def register_Ns3FfMacCschedSapUserCschedUeConfigCnfParameters_methods(root_modul def register_Ns3FfMacCschedSapUserCschedUeConfigUpdateIndParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::CschedUeConfigUpdateIndParameters(ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeConfigUpdateIndParameters::m_cqiConfig [variable] cls.add_instance_attribute('m_cqiConfig', 'ns3::CqiConfig_s', is_const=False) @@ -4417,7 +4801,7 @@ def register_Ns3FfMacCschedSapUserCschedUeConfigUpdateIndParameters_methods(root def register_Ns3FfMacCschedSapUserCschedUeReleaseCnfParameters_methods(root_module, cls): ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters() [constructor] cls.add_constructor([]) - ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const & arg0) [copy constructor] + ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::CschedUeReleaseCnfParameters(ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters const &', 'arg0')]) ## ff-mac-csched-sap.h (module 'lte'): ns3::FfMacCschedSapUser::CschedUeReleaseCnfParameters::m_result [variable] cls.add_instance_attribute('m_result', 'ns3::Result_e', is_const=False) @@ -4430,7 +4814,7 @@ def register_Ns3FfMacCschedSapUserCschedUeReleaseCnfParameters_methods(root_modu def register_Ns3FfMacSchedSapProvider_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider(ns3::FfMacSchedSapProvider const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::FfMacSchedSapProvider(ns3::FfMacSchedSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): void ns3::FfMacSchedSapProvider::SchedDlCqiInfoReq(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & params) [member function] cls.add_method('SchedDlCqiInfoReq', @@ -4492,7 +4876,7 @@ def register_Ns3FfMacSchedSapProvider_methods(root_module, cls): def register_Ns3FfMacSchedSapProviderSchedDlCqiInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::SchedDlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlCqiInfoReqParameters::m_cqiList [variable] cls.add_instance_attribute('m_cqiList', 'std::vector< ns3::CqiListElement_s >', is_const=False) @@ -4505,7 +4889,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlCqiInfoReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedDlMacBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::SchedDlMacBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlMacBufferReqParameters::m_ceBitmap [variable] cls.add_instance_attribute('m_ceBitmap', 'ns3::CeBitmap_e', is_const=False) @@ -4518,7 +4902,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlMacBufferReqParameters_methods(root_ def register_Ns3FfMacSchedSapProviderSchedDlPagingBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::SchedDlPagingBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlPagingBufferReqParameters::m_pagingInfoList [variable] cls.add_instance_attribute('m_pagingInfoList', 'std::vector< ns3::PagingInfoListElement_s >', is_const=False) @@ -4531,7 +4915,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlPagingBufferReqParameters_methods(ro def register_Ns3FfMacSchedSapProviderSchedDlRachInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::SchedDlRachInfoReqParameters(ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRachInfoReqParameters::m_rachList [variable] cls.add_instance_attribute('m_rachList', 'std::vector< ns3::RachListElement_s >', is_const=False) @@ -4544,7 +4928,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlRachInfoReqParameters_methods(root_m def register_Ns3FfMacSchedSapProviderSchedDlRlcBufferReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::SchedDlRlcBufferReqParameters(ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlRlcBufferReqParameters::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'uint8_t', is_const=False) @@ -4567,7 +4951,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlRlcBufferReqParameters_methods(root_ def register_Ns3FfMacSchedSapProviderSchedDlTriggerReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::SchedDlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedDlTriggerReqParameters::m_dlInfoList [variable] cls.add_instance_attribute('m_dlInfoList', 'std::vector< ns3::DlInfoListElement_s >', is_const=False) @@ -4580,7 +4964,7 @@ def register_Ns3FfMacSchedSapProviderSchedDlTriggerReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedUlCqiInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::SchedUlCqiInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4593,7 +4977,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlCqiInfoReqParameters_methods(root_mo def register_Ns3FfMacSchedSapProviderSchedUlMacCtrlInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::SchedUlMacCtrlInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlMacCtrlInfoReqParameters::m_macCeList [variable] cls.add_instance_attribute('m_macCeList', 'std::vector< ns3::MacCeListElement_s >', is_const=False) @@ -4606,7 +4990,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlMacCtrlInfoReqParameters_methods(roo def register_Ns3FfMacSchedSapProviderSchedUlNoiseInterferenceReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters(ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::SchedUlNoiseInterferenceReqParameters(ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters::m_rip [variable] cls.add_instance_attribute('m_rip', 'uint16_t', is_const=False) @@ -4621,7 +5005,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlNoiseInterferenceReqParameters_metho def register_Ns3FfMacSchedSapProviderSchedUlSrInfoReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::SchedUlSrInfoReqParameters(ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlSrInfoReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4634,7 +5018,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlSrInfoReqParameters_methods(root_mod def register_Ns3FfMacSchedSapProviderSchedUlTriggerReqParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::SchedUlTriggerReqParameters(ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapProvider::SchedUlTriggerReqParameters::m_sfnSf [variable] cls.add_instance_attribute('m_sfnSf', 'uint16_t', is_const=False) @@ -4647,7 +5031,7 @@ def register_Ns3FfMacSchedSapProviderSchedUlTriggerReqParameters_methods(root_mo def register_Ns3FfMacSchedSapUser_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser(ns3::FfMacSchedSapUser const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::FfMacSchedSapUser(ns3::FfMacSchedSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): void ns3::FfMacSchedSapUser::SchedDlConfigInd(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & params) [member function] cls.add_method('SchedDlConfigInd', @@ -4664,7 +5048,7 @@ def register_Ns3FfMacSchedSapUser_methods(root_module, cls): def register_Ns3FfMacSchedSapUserSchedDlConfigIndParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::SchedDlConfigIndParameters(ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser::SchedDlConfigIndParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedDlConfigIndParameters::m_buildBroadcastList [variable] cls.add_instance_attribute('m_buildBroadcastList', 'std::vector< ns3::BuildBroadcastListElement_s >', is_const=False) @@ -4681,7 +5065,7 @@ def register_Ns3FfMacSchedSapUserSchedDlConfigIndParameters_methods(root_module, def register_Ns3FfMacSchedSapUserSchedUlConfigIndParameters_methods(root_module, cls): ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters() [constructor] cls.add_constructor([]) - ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters(ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const & arg0) [copy constructor] + ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::SchedUlConfigIndParameters(ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacSchedSapUser::SchedUlConfigIndParameters const &', 'arg0')]) ## ff-mac-sched-sap.h (module 'lte'): ns3::FfMacSchedSapUser::SchedUlConfigIndParameters::m_dciList [variable] cls.add_instance_attribute('m_dciList', 'std::vector< ns3::UlDciListElement_s >', is_const=False) @@ -4692,7 +5076,7 @@ def register_Ns3FfMacSchedSapUserSchedUlConfigIndParameters_methods(root_module, return def register_Ns3GbrQosInformation_methods(root_module, cls): - ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation(ns3::GbrQosInformation const & arg0) [copy constructor] + ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation(ns3::GbrQosInformation const & arg0) [constructor] cls.add_constructor([param('ns3::GbrQosInformation const &', 'arg0')]) ## eps-bearer.h (module 'lte'): ns3::GbrQosInformation::GbrQosInformation() [constructor] cls.add_constructor([]) @@ -4709,7 +5093,7 @@ def register_Ns3GbrQosInformation_methods(root_module, cls): def register_Ns3HarqProcessInfoElement_t_methods(root_module, cls): ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t() [constructor] cls.add_constructor([]) - ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t(ns3::HarqProcessInfoElement_t const & arg0) [copy constructor] + ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::HarqProcessInfoElement_t(ns3::HarqProcessInfoElement_t const & arg0) [constructor] cls.add_constructor([param('ns3::HarqProcessInfoElement_t const &', 'arg0')]) ## lte-harq-phy.h (module 'lte'): ns3::HarqProcessInfoElement_t::m_codeBits [variable] cls.add_instance_attribute('m_codeBits', 'uint16_t', is_const=False) @@ -4722,7 +5106,7 @@ def register_Ns3HarqProcessInfoElement_t_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -4753,7 +5137,7 @@ def register_Ns3Hasher_methods(root_module, cls): def register_Ns3HigherLayerSelected_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s(ns3::HigherLayerSelected_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::HigherLayerSelected_s(ns3::HigherLayerSelected_s const & arg0) [constructor] cls.add_constructor([param('ns3::HigherLayerSelected_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::HigherLayerSelected_s::m_sbCqi [variable] cls.add_instance_attribute('m_sbCqi', 'std::vector< unsigned char >', is_const=False) @@ -4764,7 +5148,7 @@ def register_Ns3HigherLayerSelected_s_methods(root_module, cls): def register_Ns3ImsiLcidPair_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t(ns3::ImsiLcidPair_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t(ns3::ImsiLcidPair_t const & arg0) [constructor] cls.add_constructor([param('ns3::ImsiLcidPair_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::ImsiLcidPair_t::ImsiLcidPair_t() [constructor] cls.add_constructor([]) @@ -4777,7 +5161,7 @@ def register_Ns3ImsiLcidPair_t_methods(root_module, cls): return def register_Ns3Inet6SocketAddress_methods(root_module, cls): - ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor] + ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::Inet6SocketAddress const &', 'arg0')]) ## inet6-socket-address.h (module 'network'): ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')]) @@ -4820,7 +5204,7 @@ def register_Ns3Inet6SocketAddress_methods(root_module, cls): return def register_Ns3InetSocketAddress_methods(root_module, cls): - ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [copy constructor] + ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::InetSocketAddress const & arg0) [constructor] cls.add_constructor([param('ns3::InetSocketAddress const &', 'arg0')]) ## inet-socket-address.h (module 'network'): ns3::InetSocketAddress::InetSocketAddress(ns3::Ipv4Address ipv4, uint16_t port) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'ipv4'), param('uint16_t', 'port')]) @@ -4872,11 +5256,11 @@ def register_Ns3InetSocketAddress_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -4990,7 +5374,7 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4AddressHelper_methods(root_module, cls): - ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper(ns3::Ipv4AddressHelper const & arg0) [copy constructor] + ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper(ns3::Ipv4AddressHelper const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressHelper const &', 'arg0')]) ## ipv4-address-helper.h (module 'internet'): ns3::Ipv4AddressHelper::Ipv4AddressHelper() [constructor] cls.add_constructor([]) @@ -5015,14 +5399,14 @@ def register_Ns3Ipv4AddressHelper_methods(root_module, cls): return def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress() [constructor] cls.add_constructor([]) ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4Address local, ns3::Ipv4Mask mask) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'local'), param('ns3::Ipv4Mask', 'mask')]) - ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [copy constructor] + ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4InterfaceAddress::Ipv4InterfaceAddress(ns3::Ipv4InterfaceAddress const & o) [constructor] cls.add_constructor([param('ns3::Ipv4InterfaceAddress const &', 'o')]) ## ipv4-interface-address.h (module 'internet'): ns3::Ipv4Address ns3::Ipv4InterfaceAddress::GetBroadcast() const [member function] cls.add_method('GetBroadcast', @@ -5076,7 +5460,7 @@ def register_Ns3Ipv4InterfaceAddress_methods(root_module, cls): return def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): - ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer(ns3::Ipv4InterfaceContainer const & arg0) [copy constructor] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer(ns3::Ipv4InterfaceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4InterfaceContainer const &', 'arg0')]) ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Ipv4InterfaceContainer() [constructor] cls.add_constructor([]) @@ -5088,7 +5472,7 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('ns3::Ptr< ns3::Ipv4 >', 'ipv4'), param('uint32_t', 'interface')]) - ## ipv4-interface-container.h (module 'internet'): void ns3::Ipv4InterfaceContainer::Add(std::pair,unsigned int> ipInterfacePair) [member function] + ## ipv4-interface-container.h (module 'internet'): void ns3::Ipv4InterfaceContainer::Add(std::pair, unsigned int> ipInterfacePair) [member function] cls.add_method('Add', 'void', [param('std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', 'ipInterfacePair')]) @@ -5096,17 +5480,17 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'ipv4Name'), param('uint32_t', 'interface')]) - ## ipv4-interface-container.h (module 'internet'): __gnu_cxx::__normal_iterator, unsigned int>*,std::vector, unsigned int>, std::allocator, unsigned int> > > > ns3::Ipv4InterfaceContainer::Begin() const [member function] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Iterator ns3::Ipv4InterfaceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > > >', + 'ns3::Ipv4InterfaceContainer::Iterator', [], is_const=True) - ## ipv4-interface-container.h (module 'internet'): __gnu_cxx::__normal_iterator, unsigned int>*,std::vector, unsigned int>, std::allocator, unsigned int> > > > ns3::Ipv4InterfaceContainer::End() const [member function] + ## ipv4-interface-container.h (module 'internet'): ns3::Ipv4InterfaceContainer::Iterator ns3::Ipv4InterfaceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > const, std::vector< std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int > > >', + 'ns3::Ipv4InterfaceContainer::Iterator', [], is_const=True) - ## ipv4-interface-container.h (module 'internet'): std::pair,unsigned int> ns3::Ipv4InterfaceContainer::Get(uint32_t i) const [member function] + ## ipv4-interface-container.h (module 'internet'): std::pair, unsigned int> ns3::Ipv4InterfaceContainer::Get(uint32_t i) const [member function] cls.add_method('Get', 'std::pair< ns3::Ptr< ns3::Ipv4 >, unsigned int >', [param('uint32_t', 'i')], @@ -5128,10 +5512,10 @@ def register_Ns3Ipv4InterfaceContainer_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -5191,17 +5575,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -5268,7 +5652,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -5390,9 +5774,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -5401,7 +5785,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -5448,10 +5832,10 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3LogComponent_methods(root_module, cls): - ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [constructor] cls.add_constructor([param('ns3::LogComponent const &', 'arg0')]) - ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LOG_NONE) [constructor] - cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LOG_NONE')]) + ## log.h (module 'core'): ns3::LogComponent::LogComponent(std::string const & name, std::string const & file, ns3::LogLevel const mask=::ns3::LogLevel::LOG_NONE) [constructor] + cls.add_constructor([param('std::string const &', 'name'), param('std::string const &', 'file'), param('ns3::LogLevel const', 'mask', default_value='::ns3::LogLevel::LOG_NONE')]) ## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel const level) [member function] cls.add_method('Disable', 'void', @@ -5465,9 +5849,9 @@ def register_Ns3LogComponent_methods(root_module, cls): 'std::string', [], is_const=True) - ## log.h (module 'core'): static std::map, std::allocator >,ns3::LogComponent*,std::less, std::allocator > >,std::allocator, std::allocator >, ns3::LogComponent*> > > * ns3::LogComponent::GetComponentList() [member function] + ## log.h (module 'core'): static ns3::LogComponent::ComponentList * ns3::LogComponent::GetComponentList() [member function] cls.add_method('GetComponentList', - 'std::map< std::string, ns3::LogComponent * > *', + 'ns3::LogComponent::ComponentList *', [], is_static=True) ## log.h (module 'core'): static std::string ns3::LogComponent::GetLevelLabel(ns3::LogLevel const level) [member function] @@ -5499,7 +5883,7 @@ def register_Ns3LogComponent_methods(root_module, cls): def register_Ns3LogicalChannelConfigListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s(ns3::LogicalChannelConfigListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::LogicalChannelConfigListElement_s(ns3::LogicalChannelConfigListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::LogicalChannelConfigListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::LogicalChannelConfigListElement_s::m_direction [variable] cls.add_instance_attribute('m_direction', 'ns3::LogicalChannelConfigListElement_s::Direction_e', is_const=False) @@ -5524,7 +5908,7 @@ def register_Ns3LogicalChannelConfigListElement_s_methods(root_module, cls): def register_Ns3LteAnrSapProvider_methods(root_module, cls): ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider() [constructor] cls.add_constructor([]) - ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider(ns3::LteAnrSapProvider const & arg0) [copy constructor] + ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapProvider::LteAnrSapProvider(ns3::LteAnrSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnrSapProvider const &', 'arg0')]) ## lte-anr-sap.h (module 'lte'): void ns3::LteAnrSapProvider::AddNeighbourRelation(uint16_t cellId) [member function] cls.add_method('AddNeighbourRelation', @@ -5556,7 +5940,7 @@ def register_Ns3LteAnrSapProvider_methods(root_module, cls): def register_Ns3LteAnrSapUser_methods(root_module, cls): ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser() [constructor] cls.add_constructor([]) - ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser(ns3::LteAnrSapUser const & arg0) [copy constructor] + ## lte-anr-sap.h (module 'lte'): ns3::LteAnrSapUser::LteAnrSapUser(ns3::LteAnrSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnrSapUser const &', 'arg0')]) ## lte-anr-sap.h (module 'lte'): uint8_t ns3::LteAnrSapUser::AddUeMeasReportConfigForAnr(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForAnr', @@ -5568,7 +5952,7 @@ def register_Ns3LteAnrSapUser_methods(root_module, cls): def register_Ns3LteAsSapProvider_methods(root_module, cls): ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider() [constructor] cls.add_constructor([]) - ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider(ns3::LteAsSapProvider const & arg0) [copy constructor] + ## lte-as-sap.h (module 'lte'): ns3::LteAsSapProvider::LteAsSapProvider(ns3::LteAsSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteAsSapProvider const &', 'arg0')]) ## lte-as-sap.h (module 'lte'): void ns3::LteAsSapProvider::Connect() [member function] cls.add_method('Connect', @@ -5605,7 +5989,7 @@ def register_Ns3LteAsSapProvider_methods(root_module, cls): def register_Ns3LteAsSapUser_methods(root_module, cls): ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser() [constructor] cls.add_constructor([]) - ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser(ns3::LteAsSapUser const & arg0) [copy constructor] + ## lte-as-sap.h (module 'lte'): ns3::LteAsSapUser::LteAsSapUser(ns3::LteAsSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteAsSapUser const &', 'arg0')]) ## lte-as-sap.h (module 'lte'): void ns3::LteAsSapUser::NotifyConnectionFailed() [member function] cls.add_method('NotifyConnectionFailed', @@ -5632,7 +6016,7 @@ def register_Ns3LteAsSapUser_methods(root_module, cls): def register_Ns3LteCcmMacSapProvider_methods(root_module, cls): ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider() [constructor] cls.add_constructor([]) - ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider(ns3::LteCcmMacSapProvider const & arg0) [copy constructor] + ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapProvider::LteCcmMacSapProvider(ns3::LteCcmMacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmMacSapProvider const &', 'arg0')]) ## lte-ccm-mac-sap.h (module 'lte'): void ns3::LteCcmMacSapProvider::ReportMacCeToScheduler(ns3::MacCeListElement_s bsr) [member function] cls.add_method('ReportMacCeToScheduler', @@ -5644,7 +6028,7 @@ def register_Ns3LteCcmMacSapProvider_methods(root_module, cls): def register_Ns3LteCcmRrcSapProvider_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider(ns3::LteCcmRrcSapProvider const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LteCcmRrcSapProvider(ns3::LteCcmRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapProvider const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapProvider::AddLc(ns3::LteEnbCmacSapProvider::LcInfo lcInfo, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -5686,7 +6070,7 @@ def register_Ns3LteCcmRrcSapProvider_methods(root_module, cls): def register_Ns3LteCcmRrcSapProviderLcsConfig_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteCcmRrcSapProvider::LcsConfig const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteCcmRrcSapProvider::LcsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapProvider::LcsConfig const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapProvider::LcsConfig::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint16_t', is_const=False) @@ -5699,7 +6083,7 @@ def register_Ns3LteCcmRrcSapProviderLcsConfig_methods(root_module, cls): def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser(ns3::LteCcmRrcSapUser const & arg0) [copy constructor] + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::LteCcmRrcSapUser::LteCcmRrcSapUser(ns3::LteCcmRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmRrcSapUser const &', 'arg0')]) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapUser::AddLcs(std::vector > lcConfig) [member function] cls.add_method('AddLcs', @@ -5711,6 +6095,11 @@ def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): 'uint8_t', [param('ns3::LteRrcSap::ReportConfigEutra', 'reportConfig')], is_pure_virtual=True, is_virtual=True) + ## lte-ccm-rrc-sap.h (module 'lte'): ns3::Ptr ns3::LteCcmRrcSapUser::GetUeManager(uint16_t rnti) [member function] + cls.add_method('GetUeManager', + 'ns3::Ptr< ns3::UeManager >', + [param('uint16_t', 'rnti')], + is_pure_virtual=True, is_virtual=True) ## lte-ccm-rrc-sap.h (module 'lte'): void ns3::LteCcmRrcSapUser::ReleaseLcs(uint16_t rnti, uint8_t lcid) [member function] cls.add_method('ReleaseLcs', 'void', @@ -5726,7 +6115,7 @@ def register_Ns3LteCcmRrcSapUser_methods(root_module, cls): def register_Ns3LteEnbCmacSapProvider_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider(ns3::LteEnbCmacSapProvider const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LteEnbCmacSapProvider(ns3::LteEnbCmacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): void ns3::LteEnbCmacSapProvider::AddLc(ns3::LteEnbCmacSapProvider::LcInfo lcinfo, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -5778,7 +6167,7 @@ def register_Ns3LteEnbCmacSapProvider_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderAllocateNcRaPreambleReturnValue_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue(ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::AllocateNcRaPreambleReturnValue(ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::AllocateNcRaPreambleReturnValue::raPrachMaskIndex [variable] cls.add_instance_attribute('raPrachMaskIndex', 'uint8_t', is_const=False) @@ -5791,7 +6180,7 @@ def register_Ns3LteEnbCmacSapProviderAllocateNcRaPreambleReturnValue_methods(roo def register_Ns3LteEnbCmacSapProviderLcInfo_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo(ns3::LteEnbCmacSapProvider::LcInfo const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::LcInfo(ns3::LteEnbCmacSapProvider::LcInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::LcInfo const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::LcInfo::gbrDl [variable] cls.add_instance_attribute('gbrDl', 'uint64_t', is_const=False) @@ -5816,7 +6205,7 @@ def register_Ns3LteEnbCmacSapProviderLcInfo_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderRachConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig(ns3::LteEnbCmacSapProvider::RachConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::RachConfig(ns3::LteEnbCmacSapProvider::RachConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::RachConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::RachConfig::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -5829,7 +6218,7 @@ def register_Ns3LteEnbCmacSapProviderRachConfig_methods(root_module, cls): def register_Ns3LteEnbCmacSapProviderUeConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig(ns3::LteEnbCmacSapProvider::UeConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::UeConfig(ns3::LteEnbCmacSapProvider::UeConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapProvider::UeConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapProvider::UeConfig::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -5840,7 +6229,7 @@ def register_Ns3LteEnbCmacSapProviderUeConfig_methods(root_module, cls): def register_Ns3LteEnbCmacSapUser_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser(ns3::LteEnbCmacSapUser const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::LteEnbCmacSapUser(ns3::LteEnbCmacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapUser const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): uint16_t ns3::LteEnbCmacSapUser::AllocateTemporaryCellRnti() [member function] cls.add_method('AllocateTemporaryCellRnti', @@ -5862,7 +6251,7 @@ def register_Ns3LteEnbCmacSapUser_methods(root_module, cls): def register_Ns3LteEnbCmacSapUserUeConfig_methods(root_module, cls): ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig() [constructor] cls.add_constructor([]) - ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig(ns3::LteEnbCmacSapUser::UeConfig const & arg0) [copy constructor] + ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::UeConfig(ns3::LteEnbCmacSapUser::UeConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCmacSapUser::UeConfig const &', 'arg0')]) ## lte-enb-cmac-sap.h (module 'lte'): ns3::LteEnbCmacSapUser::UeConfig::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -5873,7 +6262,7 @@ def register_Ns3LteEnbCmacSapUserUeConfig_methods(root_module, cls): def register_Ns3LteEnbCphySapProvider_methods(root_module, cls): ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider(ns3::LteEnbCphySapProvider const & arg0) [copy constructor] + ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapProvider::LteEnbCphySapProvider(ns3::LteEnbCphySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCphySapProvider const &', 'arg0')]) ## lte-enb-cphy-sap.h (module 'lte'): void ns3::LteEnbCphySapProvider::AddUe(uint16_t rnti) [member function] cls.add_method('AddUe', @@ -5935,14 +6324,14 @@ def register_Ns3LteEnbCphySapProvider_methods(root_module, cls): def register_Ns3LteEnbCphySapUser_methods(root_module, cls): ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser() [constructor] cls.add_constructor([]) - ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser(ns3::LteEnbCphySapUser const & arg0) [copy constructor] + ## lte-enb-cphy-sap.h (module 'lte'): ns3::LteEnbCphySapUser::LteEnbCphySapUser(ns3::LteEnbCphySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbCphySapUser const &', 'arg0')]) return def register_Ns3LteEnbPhySapProvider_methods(root_module, cls): ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider() [constructor] cls.add_constructor([]) - ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider(ns3::LteEnbPhySapProvider const & arg0) [copy constructor] + ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapProvider::LteEnbPhySapProvider(ns3::LteEnbPhySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhySapProvider const &', 'arg0')]) ## lte-enb-phy-sap.h (module 'lte'): uint8_t ns3::LteEnbPhySapProvider::GetMacChTtiDelay() [member function] cls.add_method('GetMacChTtiDelay', @@ -5964,7 +6353,7 @@ def register_Ns3LteEnbPhySapProvider_methods(root_module, cls): def register_Ns3LteEnbPhySapUser_methods(root_module, cls): ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser() [constructor] cls.add_constructor([]) - ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser(ns3::LteEnbPhySapUser const & arg0) [copy constructor] + ## lte-enb-phy-sap.h (module 'lte'): ns3::LteEnbPhySapUser::LteEnbPhySapUser(ns3::LteEnbPhySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhySapUser const &', 'arg0')]) ## lte-enb-phy-sap.h (module 'lte'): void ns3::LteEnbPhySapUser::DlInfoListElementHarqFeeback(ns3::DlInfoListElement_s params) [member function] cls.add_method('DlInfoListElementHarqFeeback', @@ -6006,7 +6395,7 @@ def register_Ns3LteEnbPhySapUser_methods(root_module, cls): def register_Ns3LteFfConverter_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter(ns3::LteFfConverter const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteFfConverter::LteFfConverter(ns3::LteFfConverter const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfConverter const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint16_t ns3::LteFfConverter::double2fpS11dot3(double val) [member function] cls.add_method('double2fpS11dot3', @@ -6028,7 +6417,7 @@ def register_Ns3LteFfConverter_methods(root_module, cls): def register_Ns3LteFfrRrcSapProvider_methods(root_module, cls): ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider(ns3::LteFfrRrcSapProvider const & arg0) [copy constructor] + ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapProvider::LteFfrRrcSapProvider(ns3::LteFfrRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrRrcSapProvider const &', 'arg0')]) ## lte-ffr-rrc-sap.h (module 'lte'): void ns3::LteFfrRrcSapProvider::RecvLoadInformation(ns3::EpcX2Sap::LoadInformationParams params) [member function] cls.add_method('RecvLoadInformation', @@ -6055,7 +6444,7 @@ def register_Ns3LteFfrRrcSapProvider_methods(root_module, cls): def register_Ns3LteFfrRrcSapUser_methods(root_module, cls): ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser(ns3::LteFfrRrcSapUser const & arg0) [copy constructor] + ## lte-ffr-rrc-sap.h (module 'lte'): ns3::LteFfrRrcSapUser::LteFfrRrcSapUser(ns3::LteFfrRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrRrcSapUser const &', 'arg0')]) ## lte-ffr-rrc-sap.h (module 'lte'): uint8_t ns3::LteFfrRrcSapUser::AddUeMeasReportConfigForFfr(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForFfr', @@ -6077,7 +6466,7 @@ def register_Ns3LteFfrRrcSapUser_methods(root_module, cls): def register_Ns3LteFfrSapProvider_methods(root_module, cls): ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider() [constructor] cls.add_constructor([]) - ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider(ns3::LteFfrSapProvider const & arg0) [copy constructor] + ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapProvider::LteFfrSapProvider(ns3::LteFfrSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSapProvider const &', 'arg0')]) ## lte-ffr-sap.h (module 'lte'): std::vector > ns3::LteFfrSapProvider::GetAvailableDlRbg() [member function] cls.add_method('GetAvailableDlRbg', @@ -6119,7 +6508,7 @@ def register_Ns3LteFfrSapProvider_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], is_pure_virtual=True, is_virtual=True) - ## lte-ffr-sap.h (module 'lte'): void ns3::LteFfrSapProvider::ReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-sap.h (module 'lte'): void ns3::LteFfrSapProvider::ReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('ReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -6129,14 +6518,14 @@ def register_Ns3LteFfrSapProvider_methods(root_module, cls): def register_Ns3LteFfrSapUser_methods(root_module, cls): ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser() [constructor] cls.add_constructor([]) - ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser(ns3::LteFfrSapUser const & arg0) [copy constructor] + ## lte-ffr-sap.h (module 'lte'): ns3::LteFfrSapUser::LteFfrSapUser(ns3::LteFfrSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSapUser const &', 'arg0')]) return def register_Ns3LteFlowId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t(ns3::LteFlowId_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t(ns3::LteFlowId_t const & arg0) [constructor] cls.add_constructor([param('ns3::LteFlowId_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::LteFlowId_t::LteFlowId_t() [constructor] cls.add_constructor([]) @@ -6151,7 +6540,7 @@ def register_Ns3LteFlowId_t_methods(root_module, cls): def register_Ns3LteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase(ns3::LteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::LteGlobalPathlossDatabase::LteGlobalPathlossDatabase(ns3::LteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::LteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): double ns3::LteGlobalPathlossDatabase::GetPathloss(uint16_t cellId, uint64_t imsi) [member function] cls.add_method('GetPathloss', @@ -6171,7 +6560,7 @@ def register_Ns3LteGlobalPathlossDatabase_methods(root_module, cls): def register_Ns3LteHandoverManagementSapProvider_methods(root_module, cls): ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider() [constructor] cls.add_constructor([]) - ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider(ns3::LteHandoverManagementSapProvider const & arg0) [copy constructor] + ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapProvider::LteHandoverManagementSapProvider(ns3::LteHandoverManagementSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverManagementSapProvider const &', 'arg0')]) ## lte-handover-management-sap.h (module 'lte'): void ns3::LteHandoverManagementSapProvider::ReportUeMeas(uint16_t rnti, ns3::LteRrcSap::MeasResults measResults) [member function] cls.add_method('ReportUeMeas', @@ -6183,7 +6572,7 @@ def register_Ns3LteHandoverManagementSapProvider_methods(root_module, cls): def register_Ns3LteHandoverManagementSapUser_methods(root_module, cls): ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser() [constructor] cls.add_constructor([]) - ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser(ns3::LteHandoverManagementSapUser const & arg0) [copy constructor] + ## lte-handover-management-sap.h (module 'lte'): ns3::LteHandoverManagementSapUser::LteHandoverManagementSapUser(ns3::LteHandoverManagementSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverManagementSapUser const &', 'arg0')]) ## lte-handover-management-sap.h (module 'lte'): uint8_t ns3::LteHandoverManagementSapUser::AddUeMeasReportConfigForHandover(ns3::LteRrcSap::ReportConfigEutra reportConfig) [member function] cls.add_method('AddUeMeasReportConfigForHandover', @@ -6200,7 +6589,7 @@ def register_Ns3LteHandoverManagementSapUser_methods(root_module, cls): def register_Ns3LteMacSapProvider_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider(ns3::LteMacSapProvider const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::LteMacSapProvider(ns3::LteMacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): void ns3::LteMacSapProvider::ReportBufferStatus(ns3::LteMacSapProvider::ReportBufferStatusParameters params) [member function] cls.add_method('ReportBufferStatus', @@ -6217,7 +6606,7 @@ def register_Ns3LteMacSapProvider_methods(root_module, cls): def register_Ns3LteMacSapProviderReportBufferStatusParameters_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters(ns3::LteMacSapProvider::ReportBufferStatusParameters const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::ReportBufferStatusParameters(ns3::LteMacSapProvider::ReportBufferStatusParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider::ReportBufferStatusParameters const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::ReportBufferStatusParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6238,7 +6627,7 @@ def register_Ns3LteMacSapProviderReportBufferStatusParameters_methods(root_modul def register_Ns3LteMacSapProviderTransmitPduParameters_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters(ns3::LteMacSapProvider::TransmitPduParameters const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::TransmitPduParameters(ns3::LteMacSapProvider::TransmitPduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapProvider::TransmitPduParameters const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapProvider::TransmitPduParameters::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) @@ -6257,7 +6646,7 @@ def register_Ns3LteMacSapProviderTransmitPduParameters_methods(root_module, cls) def register_Ns3LteMacSapUser_methods(root_module, cls): ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser() [constructor] cls.add_constructor([]) - ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser(ns3::LteMacSapUser const & arg0) [copy constructor] + ## lte-mac-sap.h (module 'lte'): ns3::LteMacSapUser::LteMacSapUser(ns3::LteMacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteMacSapUser const &', 'arg0')]) ## lte-mac-sap.h (module 'lte'): void ns3::LteMacSapUser::NotifyHarqDeliveryFailure() [member function] cls.add_method('NotifyHarqDeliveryFailure', @@ -6279,7 +6668,7 @@ def register_Ns3LteMacSapUser_methods(root_module, cls): def register_Ns3LteMiErrorModel_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel() [constructor] cls.add_constructor([]) - ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel(ns3::LteMiErrorModel const & arg0) [copy constructor] + ## lte-mi-error-model.h (module 'lte'): ns3::LteMiErrorModel::LteMiErrorModel(ns3::LteMiErrorModel const & arg0) [constructor] cls.add_constructor([param('ns3::LteMiErrorModel const &', 'arg0')]) ## lte-mi-error-model.h (module 'lte'): static double ns3::LteMiErrorModel::GetPcfichPdcchError(ns3::SpectrumValue const & sinr) [member function] cls.add_method('GetPcfichPdcchError', @@ -6289,7 +6678,7 @@ def register_Ns3LteMiErrorModel_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): static ns3::TbStats_t ns3::LteMiErrorModel::GetTbDecodificationStats(ns3::SpectrumValue const & sinr, std::vector > const & map, uint16_t size, uint8_t mcs, ns3::HarqProcessInfoList_t miHistory) [member function] cls.add_method('GetTbDecodificationStats', 'ns3::TbStats_t', - [param('ns3::SpectrumValue const &', 'sinr'), param('std::vector< int > const &', 'map'), param('uint16_t', 'size'), param('uint8_t', 'mcs'), param('ns3::HarqProcessInfoList_t', 'miHistory')], + [param('ns3::SpectrumValue const &', 'sinr'), param('std::vector< int > const &', 'map'), param('uint16_t', 'size'), param('uint8_t', 'mcs'), param('std::vector< ns3::HarqProcessInfoElement_t >', 'miHistory')], is_static=True) ## lte-mi-error-model.h (module 'lte'): static double ns3::LteMiErrorModel::MappingMiBler(double mib, uint8_t ecrId, uint16_t cbSize) [member function] cls.add_method('MappingMiBler', @@ -6306,7 +6695,7 @@ def register_Ns3LteMiErrorModel_methods(root_module, cls): def register_Ns3LtePdcpSapProvider_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider(ns3::LtePdcpSapProvider const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::LtePdcpSapProvider(ns3::LtePdcpSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapProvider const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): void ns3::LtePdcpSapProvider::TransmitPdcpSdu(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters params) [member function] cls.add_method('TransmitPdcpSdu', @@ -6318,7 +6707,7 @@ def register_Ns3LtePdcpSapProvider_methods(root_module, cls): def register_Ns3LtePdcpSapProviderTransmitPdcpSduParameters_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::TransmitPdcpSduParameters(ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapProvider::TransmitPdcpSduParameters const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapProvider::TransmitPdcpSduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6331,7 +6720,7 @@ def register_Ns3LtePdcpSapProviderTransmitPdcpSduParameters_methods(root_module, def register_Ns3LtePdcpSapUser_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser(ns3::LtePdcpSapUser const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::LtePdcpSapUser(ns3::LtePdcpSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapUser const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): void ns3::LtePdcpSapUser::ReceivePdcpSdu(ns3::LtePdcpSapUser::ReceivePdcpSduParameters params) [member function] cls.add_method('ReceivePdcpSdu', @@ -6343,7 +6732,7 @@ def register_Ns3LtePdcpSapUser_methods(root_module, cls): def register_Ns3LtePdcpSapUserReceivePdcpSduParameters_methods(root_module, cls): ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters() [constructor] cls.add_constructor([]) - ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters(ns3::LtePdcpSapUser::ReceivePdcpSduParameters const & arg0) [copy constructor] + ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::ReceivePdcpSduParameters(ns3::LtePdcpSapUser::ReceivePdcpSduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpSapUser::ReceivePdcpSduParameters const &', 'arg0')]) ## lte-pdcp-sap.h (module 'lte'): ns3::LtePdcpSapUser::ReceivePdcpSduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6356,7 +6745,7 @@ def register_Ns3LtePdcpSapUserReceivePdcpSduParameters_methods(root_module, cls) def register_Ns3LteRlcSapProvider_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider(ns3::LteRlcSapProvider const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::LteRlcSapProvider(ns3::LteRlcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapProvider const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): void ns3::LteRlcSapProvider::TransmitPdcpPdu(ns3::LteRlcSapProvider::TransmitPdcpPduParameters params) [member function] cls.add_method('TransmitPdcpPdu', @@ -6368,7 +6757,7 @@ def register_Ns3LteRlcSapProvider_methods(root_module, cls): def register_Ns3LteRlcSapProviderTransmitPdcpPduParameters_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters(ns3::LteRlcSapProvider::TransmitPdcpPduParameters const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::TransmitPdcpPduParameters(ns3::LteRlcSapProvider::TransmitPdcpPduParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapProvider::TransmitPdcpPduParameters const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapProvider::TransmitPdcpPduParameters::lcid [variable] cls.add_instance_attribute('lcid', 'uint8_t', is_const=False) @@ -6381,7 +6770,7 @@ def register_Ns3LteRlcSapProviderTransmitPdcpPduParameters_methods(root_module, def register_Ns3LteRlcSapUser_methods(root_module, cls): ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser() [constructor] cls.add_constructor([]) - ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser(ns3::LteRlcSapUser const & arg0) [copy constructor] + ## lte-rlc-sap.h (module 'lte'): ns3::LteRlcSapUser::LteRlcSapUser(ns3::LteRlcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSapUser const &', 'arg0')]) ## lte-rlc-sap.h (module 'lte'): void ns3::LteRlcSapUser::ReceivePdcpPdu(ns3::Ptr p) [member function] cls.add_method('ReceivePdcpPdu', @@ -6393,7 +6782,7 @@ def register_Ns3LteRlcSapUser_methods(root_module, cls): def register_Ns3LteRrcSap_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap(ns3::LteRrcSap const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LteRrcSap(ns3::LteRrcSap const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): static double ns3::LteRrcSap::ConvertPdschConfigDedicated2Double(ns3::LteRrcSap::PdschConfigDedicated pdschConfigDedicated) [member function] cls.add_method('ConvertPdschConfigDedicated2Double', @@ -6407,7 +6796,7 @@ def register_Ns3LteRrcSap_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon(ns3::LteRrcSap::AntennaInfoCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::AntennaInfoCommon(ns3::LteRrcSap::AntennaInfoCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoCommon::antennaPortsCount [variable] cls.add_instance_attribute('antennaPortsCount', 'uint16_t', is_const=False) @@ -6416,7 +6805,7 @@ def register_Ns3LteRrcSapAntennaInfoCommon_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated(ns3::LteRrcSap::AntennaInfoDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::AntennaInfoDedicated(ns3::LteRrcSap::AntennaInfoDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoDedicated::transmissionMode [variable] cls.add_instance_attribute('transmissionMode', 'uint8_t', is_const=False) @@ -6425,7 +6814,7 @@ def register_Ns3LteRrcSapAntennaInfoDedicated_methods(root_module, cls): def register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl(ns3::LteRrcSap::AntennaInfoUl const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::AntennaInfoUl(ns3::LteRrcSap::AntennaInfoUl const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AntennaInfoUl const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AntennaInfoUl::transmissionMode [variable] cls.add_instance_attribute('transmissionMode', 'uint8_t', is_const=False) @@ -6434,7 +6823,7 @@ def register_Ns3LteRrcSapAntennaInfoUl_methods(root_module, cls): def register_Ns3LteRrcSapAsConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig(ns3::LteRrcSap::AsConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::AsConfig(ns3::LteRrcSap::AsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::AsConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::AsConfig::sourceDlCarrierFreq [variable] cls.add_instance_attribute('sourceDlCarrierFreq', 'uint32_t', is_const=False) @@ -6455,7 +6844,7 @@ def register_Ns3LteRrcSapAsConfig_methods(root_module, cls): def register_Ns3LteRrcSapBlackCellsToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod(ns3::LteRrcSap::BlackCellsToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::BlackCellsToAddMod(ns3::LteRrcSap::BlackCellsToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::BlackCellsToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::BlackCellsToAddMod::cellIndex [variable] cls.add_instance_attribute('cellIndex', 'uint8_t', is_const=False) @@ -6466,7 +6855,7 @@ def register_Ns3LteRrcSapBlackCellsToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapCarrierBandwidthEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra(ns3::LteRrcSap::CarrierBandwidthEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::CarrierBandwidthEutra(ns3::LteRrcSap::CarrierBandwidthEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CarrierBandwidthEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierBandwidthEutra::dlBandwidth [variable] cls.add_instance_attribute('dlBandwidth', 'uint8_t', is_const=False) @@ -6477,7 +6866,7 @@ def register_Ns3LteRrcSapCarrierBandwidthEutra_methods(root_module, cls): def register_Ns3LteRrcSapCarrierFreqEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra(ns3::LteRrcSap::CarrierFreqEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::CarrierFreqEutra(ns3::LteRrcSap::CarrierFreqEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CarrierFreqEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CarrierFreqEutra::dlCarrierFreq [variable] cls.add_instance_attribute('dlCarrierFreq', 'uint32_t', is_const=False) @@ -6488,7 +6877,7 @@ def register_Ns3LteRrcSapCarrierFreqEutra_methods(root_module, cls): def register_Ns3LteRrcSapCellAccessRelatedInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo(ns3::LteRrcSap::CellAccessRelatedInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::CellAccessRelatedInfo(ns3::LteRrcSap::CellAccessRelatedInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellAccessRelatedInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellAccessRelatedInfo::cellIdentity [variable] cls.add_instance_attribute('cellIdentity', 'uint32_t', is_const=False) @@ -6503,7 +6892,7 @@ def register_Ns3LteRrcSapCellAccessRelatedInfo_methods(root_module, cls): def register_Ns3LteRrcSapCellIdentification_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification(ns3::LteRrcSap::CellIdentification const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::CellIdentification(ns3::LteRrcSap::CellIdentification const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellIdentification const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellIdentification::dlCarrierFreq [variable] cls.add_instance_attribute('dlCarrierFreq', 'uint32_t', is_const=False) @@ -6514,7 +6903,7 @@ def register_Ns3LteRrcSapCellIdentification_methods(root_module, cls): def register_Ns3LteRrcSapCellSelectionInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo(ns3::LteRrcSap::CellSelectionInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::CellSelectionInfo(ns3::LteRrcSap::CellSelectionInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellSelectionInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellSelectionInfo::qQualMin [variable] cls.add_instance_attribute('qQualMin', 'int8_t', is_const=False) @@ -6525,7 +6914,7 @@ def register_Ns3LteRrcSapCellSelectionInfo_methods(root_module, cls): def register_Ns3LteRrcSapCellsToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod(ns3::LteRrcSap::CellsToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::CellsToAddMod(ns3::LteRrcSap::CellsToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CellsToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CellsToAddMod::cellIndex [variable] cls.add_instance_attribute('cellIndex', 'uint8_t', is_const=False) @@ -6538,7 +6927,7 @@ def register_Ns3LteRrcSapCellsToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapCgiInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo(ns3::LteRrcSap::CgiInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::CgiInfo(ns3::LteRrcSap::CgiInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::CgiInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::CgiInfo::cellIdentity [variable] cls.add_instance_attribute('cellIdentity', 'uint32_t', is_const=False) @@ -6553,7 +6942,7 @@ def register_Ns3LteRrcSapCgiInfo_methods(root_module, cls): def register_Ns3LteRrcSapDrbToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod(ns3::LteRrcSap::DrbToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::DrbToAddMod(ns3::LteRrcSap::DrbToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::DrbToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::DrbToAddMod::drbIdentity [variable] cls.add_instance_attribute('drbIdentity', 'uint8_t', is_const=False) @@ -6570,7 +6959,7 @@ def register_Ns3LteRrcSapDrbToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapFreqInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo(ns3::LteRrcSap::FreqInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::FreqInfo(ns3::LteRrcSap::FreqInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::FreqInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::FreqInfo::ulBandwidth [variable] cls.add_instance_attribute('ulBandwidth', 'uint8_t', is_const=False) @@ -6581,7 +6970,7 @@ def register_Ns3LteRrcSapFreqInfo_methods(root_module, cls): def register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo(ns3::LteRrcSap::HandoverPreparationInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::HandoverPreparationInfo(ns3::LteRrcSap::HandoverPreparationInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::HandoverPreparationInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::HandoverPreparationInfo::asConfig [variable] cls.add_instance_attribute('asConfig', 'ns3::LteRrcSap::AsConfig', is_const=False) @@ -6590,7 +6979,7 @@ def register_Ns3LteRrcSapHandoverPreparationInfo_methods(root_module, cls): def register_Ns3LteRrcSapLogicalChannelConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig(ns3::LteRrcSap::LogicalChannelConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::LogicalChannelConfig(ns3::LteRrcSap::LogicalChannelConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::LogicalChannelConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::LogicalChannelConfig::bucketSizeDurationMs [variable] cls.add_instance_attribute('bucketSizeDurationMs', 'uint16_t', is_const=False) @@ -6605,7 +6994,7 @@ def register_Ns3LteRrcSapLogicalChannelConfig_methods(root_module, cls): def register_Ns3LteRrcSapMasterInformationBlock_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock(ns3::LteRrcSap::MasterInformationBlock const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::MasterInformationBlock(ns3::LteRrcSap::MasterInformationBlock const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MasterInformationBlock const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MasterInformationBlock::dlBandwidth [variable] cls.add_instance_attribute('dlBandwidth', 'uint8_t', is_const=False) @@ -6616,7 +7005,7 @@ def register_Ns3LteRrcSapMasterInformationBlock_methods(root_module, cls): def register_Ns3LteRrcSapMeasConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig(ns3::LteRrcSap::MeasConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::MeasConfig(ns3::LteRrcSap::MeasConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasConfig::haveMeasGapConfig [variable] cls.add_instance_attribute('haveMeasGapConfig', 'bool', is_const=False) @@ -6651,16 +7040,20 @@ def register_Ns3LteRrcSapMeasConfig_methods(root_module, cls): def register_Ns3LteRrcSapMeasGapConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig(ns3::LteRrcSap::MeasGapConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::MeasGapConfig(ns3::LteRrcSap::MeasGapConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasGapConfig const &', 'arg0')]) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gapOffsetChoice [variable] + cls.add_instance_attribute('gapOffsetChoice', 'ns3::LteRrcSap::MeasGapConfig::gap', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::gapOffsetValue [variable] cls.add_instance_attribute('gapOffsetValue', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasGapConfig::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::MeasGapConfig::action', is_const=False) return def register_Ns3LteRrcSapMeasIdToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod(ns3::LteRrcSap::MeasIdToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::MeasIdToAddMod(ns3::LteRrcSap::MeasIdToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasIdToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasIdToAddMod::measId [variable] cls.add_instance_attribute('measId', 'uint8_t', is_const=False) @@ -6673,7 +7066,7 @@ def register_Ns3LteRrcSapMeasIdToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapMeasObjectEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra(ns3::LteRrcSap::MeasObjectEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::MeasObjectEutra(ns3::LteRrcSap::MeasObjectEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasObjectEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectEutra::allowedMeasBandwidth [variable] cls.add_instance_attribute('allowedMeasBandwidth', 'uint8_t', is_const=False) @@ -6702,7 +7095,7 @@ def register_Ns3LteRrcSapMeasObjectEutra_methods(root_module, cls): def register_Ns3LteRrcSapMeasObjectToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod(ns3::LteRrcSap::MeasObjectToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::MeasObjectToAddMod(ns3::LteRrcSap::MeasObjectToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasObjectToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasObjectToAddMod::measObjectEutra [variable] cls.add_instance_attribute('measObjectEutra', 'ns3::LteRrcSap::MeasObjectEutra', is_const=False) @@ -6713,7 +7106,7 @@ def register_Ns3LteRrcSapMeasObjectToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultBestNeighCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell(ns3::LteRrcSap::MeasResultBestNeighCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::MeasResultBestNeighCell(ns3::LteRrcSap::MeasResultBestNeighCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultBestNeighCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultBestNeighCell::haveRsrpResult [variable] cls.add_instance_attribute('haveRsrpResult', 'bool', is_const=False) @@ -6732,7 +7125,7 @@ def register_Ns3LteRrcSapMeasResultBestNeighCell_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra(ns3::LteRrcSap::MeasResultEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::MeasResultEutra(ns3::LteRrcSap::MeasResultEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultEutra::cgiInfo [variable] cls.add_instance_attribute('cgiInfo', 'ns3::LteRrcSap::CgiInfo', is_const=False) @@ -6753,7 +7146,7 @@ def register_Ns3LteRrcSapMeasResultEutra_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultScell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell(ns3::LteRrcSap::MeasResultScell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::MeasResultScell(ns3::LteRrcSap::MeasResultScell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultScell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultScell::haveRsrpResult [variable] cls.add_instance_attribute('haveRsrpResult', 'bool', is_const=False) @@ -6770,7 +7163,7 @@ def register_Ns3LteRrcSapMeasResultScell_methods(root_module, cls): def register_Ns3LteRrcSapMeasResultServFreqList_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList(ns3::LteRrcSap::MeasResultServFreqList const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::MeasResultServFreqList(ns3::LteRrcSap::MeasResultServFreqList const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResultServFreqList const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResultServFreqList::haveMeasurementResultsNeighCell [variable] cls.add_instance_attribute('haveMeasurementResultsNeighCell', 'bool', is_const=False) @@ -6785,7 +7178,7 @@ def register_Ns3LteRrcSapMeasResultServFreqList_methods(root_module, cls): def register_Ns3LteRrcSapMeasResults_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults(ns3::LteRrcSap::MeasResults const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::MeasResults(ns3::LteRrcSap::MeasResults const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasResults const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasResults::haveMeasResultNeighCells [variable] cls.add_instance_attribute('haveMeasResultNeighCells', 'bool', is_const=False) @@ -6806,7 +7199,7 @@ def register_Ns3LteRrcSapMeasResults_methods(root_module, cls): def register_Ns3LteRrcSapMeasurementReport_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport(ns3::LteRrcSap::MeasurementReport const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::MeasurementReport(ns3::LteRrcSap::MeasurementReport const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MeasurementReport const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MeasurementReport::measResults [variable] cls.add_instance_attribute('measResults', 'ns3::LteRrcSap::MeasResults', is_const=False) @@ -6815,7 +7208,7 @@ def register_Ns3LteRrcSapMeasurementReport_methods(root_module, cls): def register_Ns3LteRrcSapMobilityControlInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo(ns3::LteRrcSap::MobilityControlInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::MobilityControlInfo(ns3::LteRrcSap::MobilityControlInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MobilityControlInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityControlInfo::carrierBandwidth [variable] cls.add_instance_attribute('carrierBandwidth', 'ns3::LteRrcSap::CarrierBandwidthEutra', is_const=False) @@ -6840,7 +7233,7 @@ def register_Ns3LteRrcSapMobilityControlInfo_methods(root_module, cls): def register_Ns3LteRrcSapMobilityStateParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters(ns3::LteRrcSap::MobilityStateParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::MobilityStateParameters(ns3::LteRrcSap::MobilityStateParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::MobilityStateParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::MobilityStateParameters::nCellChangeHigh [variable] cls.add_instance_attribute('nCellChangeHigh', 'uint8_t', is_const=False) @@ -6855,7 +7248,7 @@ def register_Ns3LteRrcSapMobilityStateParameters_methods(root_module, cls): def register_Ns3LteRrcSapNonCriticalExtensionConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration(ns3::LteRrcSap::NonCriticalExtensionConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::NonCriticalExtensionConfiguration(ns3::LteRrcSap::NonCriticalExtensionConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::NonCriticalExtensionConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonCriticalExtensionConfiguration::sCellToReleaseList [variable] cls.add_instance_attribute('sCellToReleaseList', 'std::list< unsigned int >', is_const=False) @@ -6866,7 +7259,7 @@ def register_Ns3LteRrcSapNonCriticalExtensionConfiguration_methods(root_module, def register_Ns3LteRrcSapNonUlConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration(ns3::LteRrcSap::NonUlConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::NonUlConfiguration(ns3::LteRrcSap::NonUlConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::NonUlConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::NonUlConfiguration::antennaInfoCommon [variable] cls.add_instance_attribute('antennaInfoCommon', 'ns3::LteRrcSap::AntennaInfoCommon', is_const=False) @@ -6879,7 +7272,7 @@ def register_Ns3LteRrcSapNonUlConfiguration_methods(root_module, cls): def register_Ns3LteRrcSapPdschConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon(ns3::LteRrcSap::PdschConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::PdschConfigCommon(ns3::LteRrcSap::PdschConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PdschConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigCommon::pb [variable] cls.add_instance_attribute('pb', 'int8_t', is_const=False) @@ -6890,7 +7283,7 @@ def register_Ns3LteRrcSapPdschConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapPdschConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated(ns3::LteRrcSap::PdschConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::PdschConfigDedicated(ns3::LteRrcSap::PdschConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PdschConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PdschConfigDedicated::pa [variable] cls.add_instance_attribute('pa', 'uint8_t', is_const=False) @@ -6899,7 +7292,7 @@ def register_Ns3LteRrcSapPdschConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapPhysCellIdRange_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange(ns3::LteRrcSap::PhysCellIdRange const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::PhysCellIdRange(ns3::LteRrcSap::PhysCellIdRange const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysCellIdRange const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysCellIdRange::haveRange [variable] cls.add_instance_attribute('haveRange', 'bool', is_const=False) @@ -6912,7 +7305,7 @@ def register_Ns3LteRrcSapPhysCellIdRange_methods(root_module, cls): def register_Ns3LteRrcSapPhysicalConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated(ns3::LteRrcSap::PhysicalConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::PhysicalConfigDedicated(ns3::LteRrcSap::PhysicalConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysicalConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicated::antennaInfo [variable] cls.add_instance_attribute('antennaInfo', 'ns3::LteRrcSap::AntennaInfoDedicated', is_const=False) @@ -6931,7 +7324,7 @@ def register_Ns3LteRrcSapPhysicalConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapPhysicalConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell(ns3::LteRrcSap::PhysicalConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::PhysicalConfigDedicatedSCell(ns3::LteRrcSap::PhysicalConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PhysicalConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PhysicalConfigDedicatedSCell::antennaInfo [variable] cls.add_instance_attribute('antennaInfo', 'ns3::LteRrcSap::AntennaInfoDedicated', is_const=False) @@ -6964,7 +7357,7 @@ def register_Ns3LteRrcSapPhysicalConfigDedicatedSCell_methods(root_module, cls): def register_Ns3LteRrcSapPlmnIdentityInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo(ns3::LteRrcSap::PlmnIdentityInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::PlmnIdentityInfo(ns3::LteRrcSap::PlmnIdentityInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PlmnIdentityInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PlmnIdentityInfo::plmnIdentity [variable] cls.add_instance_attribute('plmnIdentity', 'uint32_t', is_const=False) @@ -6973,7 +7366,7 @@ def register_Ns3LteRrcSapPlmnIdentityInfo_methods(root_module, cls): def register_Ns3LteRrcSapPrachConfigSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell(ns3::LteRrcSap::PrachConfigSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::PrachConfigSCell(ns3::LteRrcSap::PrachConfigSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PrachConfigSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PrachConfigSCell::index [variable] cls.add_instance_attribute('index', 'uint16_t', is_const=False) @@ -6982,7 +7375,7 @@ def register_Ns3LteRrcSapPrachConfigSCell_methods(root_module, cls): def register_Ns3LteRrcSapPreambleInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo(ns3::LteRrcSap::PreambleInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::PreambleInfo(ns3::LteRrcSap::PreambleInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PreambleInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PreambleInfo::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -6991,7 +7384,7 @@ def register_Ns3LteRrcSapPreambleInfo_methods(root_module, cls): def register_Ns3LteRrcSapPuschConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell(ns3::LteRrcSap::PuschConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::PuschConfigDedicatedSCell(ns3::LteRrcSap::PuschConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::PuschConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::PuschConfigDedicatedSCell::nPuschIdentity [variable] cls.add_instance_attribute('nPuschIdentity', 'uint16_t', is_const=False) @@ -7000,7 +7393,7 @@ def register_Ns3LteRrcSapPuschConfigDedicatedSCell_methods(root_module, cls): def register_Ns3LteRrcSapQuantityConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig(ns3::LteRrcSap::QuantityConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::QuantityConfig(ns3::LteRrcSap::QuantityConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::QuantityConfig const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::QuantityConfig::filterCoefficientRSRP [variable] cls.add_instance_attribute('filterCoefficientRSRP', 'uint8_t', is_const=False) @@ -7011,7 +7404,7 @@ def register_Ns3LteRrcSapQuantityConfig_methods(root_module, cls): def register_Ns3LteRrcSapRaSupervisionInfo_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo(ns3::LteRrcSap::RaSupervisionInfo const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::RaSupervisionInfo(ns3::LteRrcSap::RaSupervisionInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RaSupervisionInfo const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RaSupervisionInfo::preambleTransMax [variable] cls.add_instance_attribute('preambleTransMax', 'uint8_t', is_const=False) @@ -7022,7 +7415,7 @@ def register_Ns3LteRrcSapRaSupervisionInfo_methods(root_module, cls): def register_Ns3LteRrcSapRachConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon(ns3::LteRrcSap::RachConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::RachConfigCommon(ns3::LteRrcSap::RachConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RachConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigCommon::preambleInfo [variable] cls.add_instance_attribute('preambleInfo', 'ns3::LteRrcSap::PreambleInfo', is_const=False) @@ -7033,7 +7426,7 @@ def register_Ns3LteRrcSapRachConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapRachConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated(ns3::LteRrcSap::RachConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::RachConfigDedicated(ns3::LteRrcSap::RachConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RachConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RachConfigDedicated::raPrachMaskIndex [variable] cls.add_instance_attribute('raPrachMaskIndex', 'uint8_t', is_const=False) @@ -7044,7 +7437,7 @@ def register_Ns3LteRrcSapRachConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon(ns3::LteRrcSap::RadioResourceConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::RadioResourceConfigCommon(ns3::LteRrcSap::RadioResourceConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommon::rachConfigCommon [variable] cls.add_instance_attribute('rachConfigCommon', 'ns3::LteRrcSap::RachConfigCommon', is_const=False) @@ -7053,7 +7446,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommon_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigCommonSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell(ns3::LteRrcSap::RadioResourceConfigCommonSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::RadioResourceConfigCommonSCell(ns3::LteRrcSap::RadioResourceConfigCommonSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommonSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSCell::haveNonUlConfiguration [variable] cls.add_instance_attribute('haveNonUlConfiguration', 'bool', is_const=False) @@ -7068,7 +7461,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommonSCell_methods(root_module, cls def register_Ns3LteRrcSapRadioResourceConfigCommonSib_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib(ns3::LteRrcSap::RadioResourceConfigCommonSib const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::RadioResourceConfigCommonSib(ns3::LteRrcSap::RadioResourceConfigCommonSib const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigCommonSib const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigCommonSib::pdschConfigCommon [variable] cls.add_instance_attribute('pdschConfigCommon', 'ns3::LteRrcSap::PdschConfigCommon', is_const=False) @@ -7079,7 +7472,7 @@ def register_Ns3LteRrcSapRadioResourceConfigCommonSib_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated(ns3::LteRrcSap::RadioResourceConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::RadioResourceConfigDedicated(ns3::LteRrcSap::RadioResourceConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicated::drbToAddModList [variable] cls.add_instance_attribute('drbToAddModList', 'std::list< ns3::LteRrcSap::DrbToAddMod >', is_const=False) @@ -7096,7 +7489,7 @@ def register_Ns3LteRrcSapRadioResourceConfigDedicated_methods(root_module, cls): def register_Ns3LteRrcSapRadioResourceConfigDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell(ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::RadioResourceConfigDedicatedSCell(ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RadioResourceConfigDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RadioResourceConfigDedicatedSCell::physicalConfigDedicatedSCell [variable] cls.add_instance_attribute('physicalConfigDedicatedSCell', 'ns3::LteRrcSap::PhysicalConfigDedicatedSCell', is_const=False) @@ -7105,7 +7498,7 @@ def register_Ns3LteRrcSapRadioResourceConfigDedicatedSCell_methods(root_module, def register_Ns3LteRrcSapReestabUeIdentity_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity(ns3::LteRrcSap::ReestabUeIdentity const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::ReestabUeIdentity(ns3::LteRrcSap::ReestabUeIdentity const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReestabUeIdentity const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReestabUeIdentity::cRnti [variable] cls.add_instance_attribute('cRnti', 'uint16_t', is_const=False) @@ -7114,7 +7507,7 @@ def register_Ns3LteRrcSapReestabUeIdentity_methods(root_module, cls): return def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra(ns3::LteRrcSap::ReportConfigEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra(ns3::LteRrcSap::ReportConfigEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReportConfigEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::ReportConfigEutra() [constructor] cls.add_constructor([]) @@ -7124,6 +7517,8 @@ def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): cls.add_instance_attribute('hysteresis', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::maxReportCells [variable] cls.add_instance_attribute('maxReportCells', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::purpose [variable] + cls.add_instance_attribute('purpose', 'ns3::LteRrcSap::ReportConfigEutra::report', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::reportAmount [variable] cls.add_instance_attribute('reportAmount', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigEutra::reportOnLeave [variable] @@ -7139,7 +7534,7 @@ def register_Ns3LteRrcSapReportConfigEutra_methods(root_module, cls): def register_Ns3LteRrcSapReportConfigToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod(ns3::LteRrcSap::ReportConfigToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::ReportConfigToAddMod(ns3::LteRrcSap::ReportConfigToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ReportConfigToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ReportConfigToAddMod::reportConfigEutra [variable] cls.add_instance_attribute('reportConfigEutra', 'ns3::LteRrcSap::ReportConfigEutra', is_const=False) @@ -7150,14 +7545,16 @@ def register_Ns3LteRrcSapReportConfigToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapRlcConfig_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig(ns3::LteRrcSap::RlcConfig const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::RlcConfig(ns3::LteRrcSap::RlcConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RlcConfig const &', 'arg0')]) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RlcConfig::choice [variable] + cls.add_instance_attribute('choice', 'ns3::LteRrcSap::RlcConfig::direction', is_const=False) return def register_Ns3LteRrcSapRrcConnectionReconfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration(ns3::LteRrcSap::RrcConnectionReconfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::RrcConnectionReconfiguration(ns3::LteRrcSap::RrcConnectionReconfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReconfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration::haveMeasConfig [variable] cls.add_instance_attribute('haveMeasConfig', 'bool', is_const=False) @@ -7182,7 +7579,7 @@ def register_Ns3LteRrcSapRrcConnectionReconfiguration_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionReconfigurationCompleted_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted(ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::RrcConnectionReconfigurationCompleted(ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReconfigurationCompleted const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfigurationCompleted::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7191,7 +7588,7 @@ def register_Ns3LteRrcSapRrcConnectionReconfigurationCompleted_methods(root_modu def register_Ns3LteRrcSapRrcConnectionReestablishment_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment(ns3::LteRrcSap::RrcConnectionReestablishment const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::RrcConnectionReestablishment(ns3::LteRrcSap::RrcConnectionReestablishment const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishment const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishment::radioResourceConfigDedicated [variable] cls.add_instance_attribute('radioResourceConfigDedicated', 'ns3::LteRrcSap::RadioResourceConfigDedicated', is_const=False) @@ -7202,7 +7599,7 @@ def register_Ns3LteRrcSapRrcConnectionReestablishment_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionReestablishmentComplete_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete(ns3::LteRrcSap::RrcConnectionReestablishmentComplete const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::RrcConnectionReestablishmentComplete(ns3::LteRrcSap::RrcConnectionReestablishmentComplete const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentComplete const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentComplete::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7211,14 +7608,14 @@ def register_Ns3LteRrcSapRrcConnectionReestablishmentComplete_methods(root_modul def register_Ns3LteRrcSapRrcConnectionReestablishmentReject_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject(ns3::LteRrcSap::RrcConnectionReestablishmentReject const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentReject::RrcConnectionReestablishmentReject(ns3::LteRrcSap::RrcConnectionReestablishmentReject const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentReject const &', 'arg0')]) return def register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest(ns3::LteRrcSap::RrcConnectionReestablishmentRequest const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::RrcConnectionReestablishmentRequest(ns3::LteRrcSap::RrcConnectionReestablishmentRequest const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReestablishmentRequest const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReestablishmentRequest::reestablishmentCause [variable] cls.add_instance_attribute('reestablishmentCause', 'ns3::LteRrcSap::ReestablishmentCause', is_const=False) @@ -7229,7 +7626,7 @@ def register_Ns3LteRrcSapRrcConnectionReestablishmentRequest_methods(root_module def register_Ns3LteRrcSapRrcConnectionReject_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject(ns3::LteRrcSap::RrcConnectionReject const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::RrcConnectionReject(ns3::LteRrcSap::RrcConnectionReject const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionReject const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReject::waitTime [variable] cls.add_instance_attribute('waitTime', 'uint8_t', is_const=False) @@ -7238,7 +7635,7 @@ def register_Ns3LteRrcSapRrcConnectionReject_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionRelease_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease(ns3::LteRrcSap::RrcConnectionRelease const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::RrcConnectionRelease(ns3::LteRrcSap::RrcConnectionRelease const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionRelease const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRelease::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7247,7 +7644,7 @@ def register_Ns3LteRrcSapRrcConnectionRelease_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionRequest_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest(ns3::LteRrcSap::RrcConnectionRequest const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::RrcConnectionRequest(ns3::LteRrcSap::RrcConnectionRequest const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionRequest const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionRequest::ueIdentity [variable] cls.add_instance_attribute('ueIdentity', 'uint64_t', is_const=False) @@ -7256,7 +7653,7 @@ def register_Ns3LteRrcSapRrcConnectionRequest_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionSetup_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup(ns3::LteRrcSap::RrcConnectionSetup const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::RrcConnectionSetup(ns3::LteRrcSap::RrcConnectionSetup const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionSetup const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetup::radioResourceConfigDedicated [variable] cls.add_instance_attribute('radioResourceConfigDedicated', 'ns3::LteRrcSap::RadioResourceConfigDedicated', is_const=False) @@ -7267,7 +7664,7 @@ def register_Ns3LteRrcSapRrcConnectionSetup_methods(root_module, cls): def register_Ns3LteRrcSapRrcConnectionSetupCompleted_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted(ns3::LteRrcSap::RrcConnectionSetupCompleted const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::RrcConnectionSetupCompleted(ns3::LteRrcSap::RrcConnectionSetupCompleted const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::RrcConnectionSetupCompleted const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionSetupCompleted::rrcTransactionIdentifier [variable] cls.add_instance_attribute('rrcTransactionIdentifier', 'uint8_t', is_const=False) @@ -7276,7 +7673,7 @@ def register_Ns3LteRrcSapRrcConnectionSetupCompleted_methods(root_module, cls): def register_Ns3LteRrcSapSCellToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod(ns3::LteRrcSap::SCellToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::SCellToAddMod(ns3::LteRrcSap::SCellToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SCellToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SCellToAddMod::cellIdentification [variable] cls.add_instance_attribute('cellIdentification', 'ns3::LteRrcSap::CellIdentification', is_const=False) @@ -7293,40 +7690,46 @@ def register_Ns3LteRrcSapSCellToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapSoundingRsUlConfigCommon_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon(ns3::LteRrcSap::SoundingRsUlConfigCommon const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::SoundingRsUlConfigCommon(ns3::LteRrcSap::SoundingRsUlConfigCommon const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SoundingRsUlConfigCommon const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::srsBandwidthConfig [variable] cls.add_instance_attribute('srsBandwidthConfig', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::srsSubframeConfig [variable] cls.add_instance_attribute('srsSubframeConfig', 'uint8_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigCommon::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SoundingRsUlConfigCommon::action', is_const=False) return def register_Ns3LteRrcSapSoundingRsUlConfigDedicated_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated(ns3::LteRrcSap::SoundingRsUlConfigDedicated const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated(ns3::LteRrcSap::SoundingRsUlConfigDedicated const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SoundingRsUlConfigDedicated const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::srsBandwidth [variable] cls.add_instance_attribute('srsBandwidth', 'uint8_t', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::srsConfigIndex [variable] cls.add_instance_attribute('srsConfigIndex', 'uint16_t', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SoundingRsUlConfigDedicated::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SoundingRsUlConfigDedicated::action', is_const=False) return def register_Ns3LteRrcSapSpeedStatePars_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars(ns3::LteRrcSap::SpeedStatePars const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::SpeedStatePars(ns3::LteRrcSap::SpeedStatePars const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SpeedStatePars const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::mobilityStateParameters [variable] cls.add_instance_attribute('mobilityStateParameters', 'ns3::LteRrcSap::MobilityStateParameters', is_const=False) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::timeToTriggerSf [variable] cls.add_instance_attribute('timeToTriggerSf', 'ns3::LteRrcSap::SpeedStateScaleFactors', is_const=False) + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStatePars::type [variable] + cls.add_instance_attribute('type', 'ns3::LteRrcSap::SpeedStatePars::action', is_const=False) return def register_Ns3LteRrcSapSpeedStateScaleFactors_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors(ns3::LteRrcSap::SpeedStateScaleFactors const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::SpeedStateScaleFactors(ns3::LteRrcSap::SpeedStateScaleFactors const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SpeedStateScaleFactors const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SpeedStateScaleFactors::sfHigh [variable] cls.add_instance_attribute('sfHigh', 'uint8_t', is_const=False) @@ -7337,7 +7740,7 @@ def register_Ns3LteRrcSapSpeedStateScaleFactors_methods(root_module, cls): def register_Ns3LteRrcSapSrbToAddMod_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod(ns3::LteRrcSap::SrbToAddMod const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::SrbToAddMod(ns3::LteRrcSap::SrbToAddMod const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SrbToAddMod const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SrbToAddMod::logicalChannelConfig [variable] cls.add_instance_attribute('logicalChannelConfig', 'ns3::LteRrcSap::LogicalChannelConfig', is_const=False) @@ -7348,7 +7751,7 @@ def register_Ns3LteRrcSapSrbToAddMod_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformation_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation(ns3::LteRrcSap::SystemInformation const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::SystemInformation(ns3::LteRrcSap::SystemInformation const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformation const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformation::haveSib2 [variable] cls.add_instance_attribute('haveSib2', 'bool', is_const=False) @@ -7359,7 +7762,7 @@ def register_Ns3LteRrcSapSystemInformation_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformationBlockType1_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1(ns3::LteRrcSap::SystemInformationBlockType1 const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::SystemInformationBlockType1(ns3::LteRrcSap::SystemInformationBlockType1 const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformationBlockType1 const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType1::cellAccessRelatedInfo [variable] cls.add_instance_attribute('cellAccessRelatedInfo', 'ns3::LteRrcSap::CellAccessRelatedInfo', is_const=False) @@ -7370,7 +7773,7 @@ def register_Ns3LteRrcSapSystemInformationBlockType1_methods(root_module, cls): def register_Ns3LteRrcSapSystemInformationBlockType2_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2(ns3::LteRrcSap::SystemInformationBlockType2 const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::SystemInformationBlockType2(ns3::LteRrcSap::SystemInformationBlockType2 const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::SystemInformationBlockType2 const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::SystemInformationBlockType2::freqInfo [variable] cls.add_instance_attribute('freqInfo', 'ns3::LteRrcSap::FreqInfo', is_const=False) @@ -7381,7 +7784,7 @@ def register_Ns3LteRrcSapSystemInformationBlockType2_methods(root_module, cls): def register_Ns3LteRrcSapThresholdEutra_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra(ns3::LteRrcSap::ThresholdEutra const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::ThresholdEutra(ns3::LteRrcSap::ThresholdEutra const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::ThresholdEutra const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::ThresholdEutra::range [variable] cls.add_instance_attribute('range', 'uint8_t', is_const=False) @@ -7390,7 +7793,7 @@ def register_Ns3LteRrcSapThresholdEutra_methods(root_module, cls): def register_Ns3LteRrcSapUlConfiguration_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration(ns3::LteRrcSap::UlConfiguration const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::UlConfiguration(ns3::LteRrcSap::UlConfiguration const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlConfiguration const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlConfiguration::prachConfigSCell [variable] cls.add_instance_attribute('prachConfigSCell', 'ns3::LteRrcSap::PrachConfigSCell', is_const=False) @@ -7405,7 +7808,7 @@ def register_Ns3LteRrcSapUlConfiguration_methods(root_module, cls): def register_Ns3LteRrcSapUlPowerControlCommonSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell(ns3::LteRrcSap::UlPowerControlCommonSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::UlPowerControlCommonSCell(ns3::LteRrcSap::UlPowerControlCommonSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlPowerControlCommonSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlCommonSCell::alpha [variable] cls.add_instance_attribute('alpha', 'uint16_t', is_const=False) @@ -7414,7 +7817,7 @@ def register_Ns3LteRrcSapUlPowerControlCommonSCell_methods(root_module, cls): def register_Ns3LteRrcSapUlPowerControlDedicatedSCell_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell(ns3::LteRrcSap::UlPowerControlDedicatedSCell const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::UlPowerControlDedicatedSCell(ns3::LteRrcSap::UlPowerControlDedicatedSCell const & arg0) [constructor] cls.add_constructor([param('ns3::LteRrcSap::UlPowerControlDedicatedSCell const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::UlPowerControlDedicatedSCell::pSrsOffset [variable] cls.add_instance_attribute('pSrsOffset', 'uint16_t', is_const=False) @@ -7423,7 +7826,7 @@ def register_Ns3LteRrcSapUlPowerControlDedicatedSCell_methods(root_module, cls): def register_Ns3LteSpectrumValueCatcher_methods(root_module, cls): ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher() [constructor] cls.add_constructor([]) - ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher(ns3::LteSpectrumValueCatcher const & arg0) [copy constructor] + ## lte-chunk-processor.h (module 'lte'): ns3::LteSpectrumValueCatcher::LteSpectrumValueCatcher(ns3::LteSpectrumValueCatcher const & arg0) [constructor] cls.add_constructor([param('ns3::LteSpectrumValueCatcher const &', 'arg0')]) ## lte-chunk-processor.h (module 'lte'): ns3::Ptr ns3::LteSpectrumValueCatcher::GetValue() [member function] cls.add_method('GetValue', @@ -7438,7 +7841,7 @@ def register_Ns3LteSpectrumValueCatcher_methods(root_module, cls): def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper() [constructor] cls.add_constructor([]) - ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper(ns3::LteSpectrumValueHelper const & arg0) [copy constructor] + ## lte-spectrum-value-helper.h (module 'lte'): ns3::LteSpectrumValueHelper::LteSpectrumValueHelper(ns3::LteSpectrumValueHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteSpectrumValueHelper const &', 'arg0')]) ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateNoisePowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double noiseFigure) [member function] cls.add_method('CreateNoisePowerSpectralDensity', @@ -7455,7 +7858,7 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth'), param('double', 'powerTx'), param('std::vector< int >', 'activeRbs')], is_static=True) - ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateTxPowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double powerTx, std::map, std::allocator > > powerTxMap, std::vector > activeRbs) [member function] + ## lte-spectrum-value-helper.h (module 'lte'): static ns3::Ptr ns3::LteSpectrumValueHelper::CreateTxPowerSpectralDensity(uint32_t earfcn, uint8_t bandwidth, double powerTx, std::map, std::allocator > > powerTxMap, std::vector > activeRbs) [member function] cls.add_method('CreateTxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth'), param('double', 'powerTx'), param('std::map< int, double >', 'powerTxMap'), param('std::vector< int >', 'activeRbs')], @@ -7470,6 +7873,11 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'double', [param('uint8_t', 'txBandwidthConf')], is_static=True) + ## lte-spectrum-value-helper.h (module 'lte'): static uint16_t ns3::LteSpectrumValueHelper::GetDownlinkCarrierBand(uint32_t nDl) [member function] + cls.add_method('GetDownlinkCarrierBand', + 'uint16_t', + [param('uint32_t', 'nDl')], + is_static=True) ## lte-spectrum-value-helper.h (module 'lte'): static double ns3::LteSpectrumValueHelper::GetDownlinkCarrierFrequency(uint32_t earfcn) [member function] cls.add_method('GetDownlinkCarrierFrequency', 'double', @@ -7480,6 +7888,11 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumModel >', [param('uint32_t', 'earfcn'), param('uint8_t', 'bandwidth')], is_static=True) + ## lte-spectrum-value-helper.h (module 'lte'): static uint16_t ns3::LteSpectrumValueHelper::GetUplinkCarrierBand(uint32_t nDl) [member function] + cls.add_method('GetUplinkCarrierBand', + 'uint16_t', + [param('uint32_t', 'nDl')], + is_static=True) ## lte-spectrum-value-helper.h (module 'lte'): static double ns3::LteSpectrumValueHelper::GetUplinkCarrierFrequency(uint32_t earfcn) [member function] cls.add_method('GetUplinkCarrierFrequency', 'double', @@ -7490,7 +7903,7 @@ def register_Ns3LteSpectrumValueHelper_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapProvider_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider(ns3::LteUeCcmRrcSapProvider const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LteUeCcmRrcSapProvider(ns3::LteUeCcmRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapProvider const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): std::vector > ns3::LteUeCcmRrcSapProvider::AddLc(uint8_t lcId, ns3::LteUeCmacSapProvider::LogicalChannelConfig lcConfig, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -7517,7 +7930,7 @@ def register_Ns3LteUeCcmRrcSapProvider_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapProviderLcsConfig_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteUeCcmRrcSapProvider::LcsConfig const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::LcsConfig(ns3::LteUeCcmRrcSapProvider::LcsConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapProvider::LcsConfig const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapProvider::LcsConfig::componentCarrierId [variable] cls.add_instance_attribute('componentCarrierId', 'uint8_t', is_const=False) @@ -7530,7 +7943,7 @@ def register_Ns3LteUeCcmRrcSapProviderLcsConfig_methods(root_module, cls): def register_Ns3LteUeCcmRrcSapUser_methods(root_module, cls): ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser(ns3::LteUeCcmRrcSapUser const & arg0) [copy constructor] + ## lte-ue-ccm-rrc-sap.h (module 'lte'): ns3::LteUeCcmRrcSapUser::LteUeCcmRrcSapUser(ns3::LteUeCcmRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCcmRrcSapUser const &', 'arg0')]) ## lte-ue-ccm-rrc-sap.h (module 'lte'): void ns3::LteUeCcmRrcSapUser::ComponentCarrierEnabling(std::vector > componentCarrierList) [member function] cls.add_method('ComponentCarrierEnabling', @@ -7542,7 +7955,7 @@ def register_Ns3LteUeCcmRrcSapUser_methods(root_module, cls): def register_Ns3LteUeCmacSapProvider_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider(ns3::LteUeCmacSapProvider const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LteUeCmacSapProvider(ns3::LteUeCmacSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): void ns3::LteUeCmacSapProvider::AddLc(uint8_t lcId, ns3::LteUeCmacSapProvider::LogicalChannelConfig lcConfig, ns3::LteMacSapUser * msu) [member function] cls.add_method('AddLc', @@ -7584,7 +7997,7 @@ def register_Ns3LteUeCmacSapProvider_methods(root_module, cls): def register_Ns3LteUeCmacSapProviderLogicalChannelConfig_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig(ns3::LteUeCmacSapProvider::LogicalChannelConfig const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::LogicalChannelConfig(ns3::LteUeCmacSapProvider::LogicalChannelConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider::LogicalChannelConfig const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::LogicalChannelConfig::bucketSizeDurationMs [variable] cls.add_instance_attribute('bucketSizeDurationMs', 'uint16_t', is_const=False) @@ -7599,7 +8012,7 @@ def register_Ns3LteUeCmacSapProviderLogicalChannelConfig_methods(root_module, cl def register_Ns3LteUeCmacSapProviderRachConfig_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig(ns3::LteUeCmacSapProvider::RachConfig const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::RachConfig(ns3::LteUeCmacSapProvider::RachConfig const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapProvider::RachConfig const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapProvider::RachConfig::numberOfRaPreambles [variable] cls.add_instance_attribute('numberOfRaPreambles', 'uint8_t', is_const=False) @@ -7612,7 +8025,7 @@ def register_Ns3LteUeCmacSapProviderRachConfig_methods(root_module, cls): def register_Ns3LteUeCmacSapUser_methods(root_module, cls): ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser() [constructor] cls.add_constructor([]) - ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser(ns3::LteUeCmacSapUser const & arg0) [copy constructor] + ## lte-ue-cmac-sap.h (module 'lte'): ns3::LteUeCmacSapUser::LteUeCmacSapUser(ns3::LteUeCmacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCmacSapUser const &', 'arg0')]) ## lte-ue-cmac-sap.h (module 'lte'): void ns3::LteUeCmacSapUser::NotifyRandomAccessFailed() [member function] cls.add_method('NotifyRandomAccessFailed', @@ -7634,7 +8047,7 @@ def register_Ns3LteUeCmacSapUser_methods(root_module, cls): def register_Ns3LteUeConfig_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t(ns3::LteUeConfig_t const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t(ns3::LteUeConfig_t const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeConfig_t const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::LteUeConfig_t::LteUeConfig_t() [constructor] cls.add_constructor([]) @@ -7651,7 +8064,7 @@ def register_Ns3LteUeConfig_t_methods(root_module, cls): def register_Ns3LteUeCphySapProvider_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider(ns3::LteUeCphySapProvider const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapProvider::LteUeCphySapProvider(ns3::LteUeCphySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapProvider const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): void ns3::LteUeCphySapProvider::ConfigureReferenceSignalPower(int8_t referenceSignalPower) [member function] cls.add_method('ConfigureReferenceSignalPower', @@ -7713,7 +8126,7 @@ def register_Ns3LteUeCphySapProvider_methods(root_module, cls): def register_Ns3LteUeCphySapUser_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser(ns3::LteUeCphySapUser const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::LteUeCphySapUser(ns3::LteUeCphySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): void ns3::LteUeCphySapUser::RecvMasterInformationBlock(uint16_t cellId, ns3::LteRrcSap::MasterInformationBlock mib) [member function] cls.add_method('RecvMasterInformationBlock', @@ -7735,7 +8148,7 @@ def register_Ns3LteUeCphySapUser_methods(root_module, cls): def register_Ns3LteUeCphySapUserUeMeasurementsElement_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement(ns3::LteUeCphySapUser::UeMeasurementsElement const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::UeMeasurementsElement(ns3::LteUeCphySapUser::UeMeasurementsElement const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser::UeMeasurementsElement const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsElement::m_cellId [variable] cls.add_instance_attribute('m_cellId', 'uint16_t', is_const=False) @@ -7748,7 +8161,7 @@ def register_Ns3LteUeCphySapUserUeMeasurementsElement_methods(root_module, cls): def register_Ns3LteUeCphySapUserUeMeasurementsParameters_methods(root_module, cls): ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters() [constructor] cls.add_constructor([]) - ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters(ns3::LteUeCphySapUser::UeMeasurementsParameters const & arg0) [copy constructor] + ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::UeMeasurementsParameters(ns3::LteUeCphySapUser::UeMeasurementsParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeCphySapUser::UeMeasurementsParameters const &', 'arg0')]) ## lte-ue-cphy-sap.h (module 'lte'): ns3::LteUeCphySapUser::UeMeasurementsParameters::m_componentCarrierId [variable] cls.add_instance_attribute('m_componentCarrierId', 'uint8_t', is_const=False) @@ -7759,7 +8172,7 @@ def register_Ns3LteUeCphySapUserUeMeasurementsParameters_methods(root_module, cl def register_Ns3LteUePhySapProvider_methods(root_module, cls): ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider() [constructor] cls.add_constructor([]) - ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider(ns3::LteUePhySapProvider const & arg0) [copy constructor] + ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapProvider::LteUePhySapProvider(ns3::LteUePhySapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhySapProvider const &', 'arg0')]) ## lte-ue-phy-sap.h (module 'lte'): void ns3::LteUePhySapProvider::SendLteControlMessage(ns3::Ptr msg) [member function] cls.add_method('SendLteControlMessage', @@ -7781,7 +8194,7 @@ def register_Ns3LteUePhySapProvider_methods(root_module, cls): def register_Ns3LteUePhySapUser_methods(root_module, cls): ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser() [constructor] cls.add_constructor([]) - ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser(ns3::LteUePhySapUser const & arg0) [copy constructor] + ## lte-ue-phy-sap.h (module 'lte'): ns3::LteUePhySapUser::LteUePhySapUser(ns3::LteUePhySapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhySapUser const &', 'arg0')]) ## lte-ue-phy-sap.h (module 'lte'): void ns3::LteUePhySapUser::ReceiveLteControlMessage(ns3::Ptr msg) [member function] cls.add_method('ReceiveLteControlMessage', @@ -7803,7 +8216,7 @@ def register_Ns3LteUePhySapUser_methods(root_module, cls): def register_Ns3LteUeRrcSapProvider_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider(ns3::LteUeRrcSapProvider const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::LteUeRrcSapProvider(ns3::LteUeRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapProvider const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteUeRrcSapProvider::CompleteSetup(ns3::LteUeRrcSapProvider::CompleteSetupParameters params) [member function] cls.add_method('CompleteSetup', @@ -7850,7 +8263,7 @@ def register_Ns3LteUeRrcSapProvider_methods(root_module, cls): def register_Ns3LteUeRrcSapProviderCompleteSetupParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters(ns3::LteUeRrcSapProvider::CompleteSetupParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::CompleteSetupParameters(ns3::LteUeRrcSapProvider::CompleteSetupParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapProvider::CompleteSetupParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapProvider::CompleteSetupParameters::srb0SapUser [variable] cls.add_instance_attribute('srb0SapUser', 'ns3::LteRlcSapUser *', is_const=False) @@ -7861,7 +8274,7 @@ def register_Ns3LteUeRrcSapProviderCompleteSetupParameters_methods(root_module, def register_Ns3LteUeRrcSapUser_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser(ns3::LteUeRrcSapUser const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::LteUeRrcSapUser(ns3::LteUeRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapUser const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteUeRrcSapUser::SendMeasurementReport(ns3::LteRrcSap::MeasurementReport msg) [member function] cls.add_method('SendMeasurementReport', @@ -7903,7 +8316,7 @@ def register_Ns3LteUeRrcSapUser_methods(root_module, cls): def register_Ns3LteUeRrcSapUserSetupParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters(ns3::LteUeRrcSapUser::SetupParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::SetupParameters(ns3::LteUeRrcSapUser::SetupParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcSapUser::SetupParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteUeRrcSapUser::SetupParameters::srb0SapProvider [variable] cls.add_instance_attribute('srb0SapProvider', 'ns3::LteRlcSapProvider *', is_const=False) @@ -7912,11 +8325,11 @@ def register_Ns3LteUeRrcSapUserSetupParameters_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -7986,7 +8399,7 @@ def register_Ns3Mac48Address_methods(root_module, cls): def register_Ns3MacCeListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s(ns3::MacCeListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::MacCeListElement_s(ns3::MacCeListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::MacCeListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::MacCeListElement_s::m_macCeType [variable] cls.add_instance_attribute('m_macCeType', 'ns3::MacCeListElement_s::MacCeType_e', is_const=False) @@ -7999,7 +8412,7 @@ def register_Ns3MacCeListElement_s_methods(root_module, cls): def register_Ns3MacCeValue_u_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u(ns3::MacCeValue_u const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::MacCeValue_u(ns3::MacCeValue_u const & arg0) [constructor] cls.add_constructor([param('ns3::MacCeValue_u const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::MacCeValue_u::m_bufferStatus [variable] cls.add_instance_attribute('m_bufferStatus', 'std::vector< unsigned char >', is_const=False) @@ -8012,7 +8425,7 @@ def register_Ns3MacCeValue_u_methods(root_module, cls): def register_Ns3Names_methods(root_module, cls): ## names.h (module 'core'): ns3::Names::Names() [constructor] cls.add_constructor([]) - ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [copy constructor] + ## names.h (module 'core'): ns3::Names::Names(ns3::Names const & arg0) [constructor] cls.add_constructor([param('ns3::Names const &', 'arg0')]) ## names.h (module 'core'): static void ns3::Names::Add(std::string name, ns3::Ptr object) [member function] cls.add_method('Add', @@ -8062,7 +8475,7 @@ def register_Ns3Names_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -8084,14 +8497,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -8107,7 +8520,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -8135,9 +8548,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -8148,9 +8561,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -8173,7 +8586,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -8234,7 +8647,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -8245,7 +8658,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -8282,7 +8695,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -8360,7 +8773,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -8374,10 +8787,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -8393,7 +8808,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -8407,7 +8822,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -8424,7 +8839,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -8458,7 +8873,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -8475,7 +8890,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): def register_Ns3PagingInfoListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s(ns3::PagingInfoListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::PagingInfoListElement_s(ns3::PagingInfoListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::PagingInfoListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::PagingInfoListElement_s::m_pagingIndex [variable] cls.add_instance_attribute('m_pagingIndex', 'uint8_t', is_const=False) @@ -8486,7 +8901,7 @@ def register_Ns3PagingInfoListElement_s_methods(root_module, cls): return def register_Ns3ParameterLogger_methods(root_module, cls): - ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [copy constructor] + ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(ns3::ParameterLogger const & arg0) [constructor] cls.add_constructor([param('ns3::ParameterLogger const &', 'arg0')]) ## log.h (module 'core'): ns3::ParameterLogger::ParameterLogger(std::ostream & os) [constructor] cls.add_constructor([param('std::ostream &', 'os')]) @@ -8495,7 +8910,7 @@ def register_Ns3ParameterLogger_methods(root_module, cls): def register_Ns3PhichListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s(ns3::PhichListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::PhichListElement_s(ns3::PhichListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::PhichListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::PhichListElement_s::m_phich [variable] cls.add_instance_attribute('m_phich', 'ns3::PhichListElement_s::Phich_e', is_const=False) @@ -8506,7 +8921,7 @@ def register_Ns3PhichListElement_s_methods(root_module, cls): def register_Ns3PhyReceptionStatParameters_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters(ns3::PhyReceptionStatParameters const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::PhyReceptionStatParameters(ns3::PhyReceptionStatParameters const & arg0) [constructor] cls.add_constructor([param('ns3::PhyReceptionStatParameters const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::PhyReceptionStatParameters::m_ccId [variable] cls.add_instance_attribute('m_ccId', 'uint8_t', is_const=False) @@ -8537,7 +8952,7 @@ def register_Ns3PhyReceptionStatParameters_methods(root_module, cls): def register_Ns3PhyTransmissionStatParameters_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters(ns3::PhyTransmissionStatParameters const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::PhyTransmissionStatParameters(ns3::PhyTransmissionStatParameters const & arg0) [constructor] cls.add_constructor([param('ns3::PhyTransmissionStatParameters const &', 'arg0')]) ## lte-common.h (module 'lte'): ns3::PhyTransmissionStatParameters::m_ccId [variable] cls.add_instance_attribute('m_ccId', 'uint8_t', is_const=False) @@ -8566,7 +8981,7 @@ def register_Ns3PhyTransmissionStatParameters_methods(root_module, cls): def register_Ns3RachListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s(ns3::RachListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::RachListElement_s(ns3::RachListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::RachListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::RachListElement_s::m_estimatedSize [variable] cls.add_instance_attribute('m_estimatedSize', 'uint16_t', is_const=False) @@ -8575,7 +8990,7 @@ def register_Ns3RachListElement_s_methods(root_module, cls): return def register_Ns3RadioBearerStatsConnector_methods(root_module, cls): - ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector(ns3::RadioBearerStatsConnector const & arg0) [copy constructor] + ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector(ns3::RadioBearerStatsConnector const & arg0) [constructor] cls.add_constructor([param('ns3::RadioBearerStatsConnector const &', 'arg0')]) ## radio-bearer-stats-connector.h (module 'lte'): ns3::RadioBearerStatsConnector::RadioBearerStatsConnector() [constructor] cls.add_constructor([]) @@ -8639,7 +9054,7 @@ def register_Ns3RadioBearerStatsConnector_methods(root_module, cls): return def register_Ns3RealProtocolRlcSapUser_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::RealProtocolRlcSapUser const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::RealProtocolRlcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::RealProtocolRlcSapUser const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::RealProtocolRlcSapUser::RealProtocolRlcSapUser(ns3::LteEnbRrcProtocolReal * pdcp, uint16_t rnti) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolReal *', 'pdcp'), param('uint16_t', 'rnti')]) @@ -8653,7 +9068,7 @@ def register_Ns3RealProtocolRlcSapUser_methods(root_module, cls): def register_Ns3RlcPduListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s(ns3::RlcPduListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::RlcPduListElement_s(ns3::RlcPduListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::RlcPduListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::RlcPduListElement_s::m_logicalChannelIdentity [variable] cls.add_instance_attribute('m_logicalChannelIdentity', 'uint8_t', is_const=False) @@ -8664,7 +9079,7 @@ def register_Ns3RlcPduListElement_s_methods(root_module, cls): def register_Ns3SbMeasResult_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s(ns3::SbMeasResult_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::SbMeasResult_s(ns3::SbMeasResult_s const & arg0) [constructor] cls.add_constructor([param('ns3::SbMeasResult_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SbMeasResult_s::m_bwPart [variable] cls.add_instance_attribute('m_bwPart', 'ns3::BwPart_s', is_const=False) @@ -8688,7 +9103,7 @@ def register_Ns3SequenceNumber10_methods(root_module, cls): cls.add_constructor([]) ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(uint16_t value) [constructor] cls.add_constructor([param('uint16_t', 'value')]) - ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(ns3::SequenceNumber10 const & value) [copy constructor] + ## lte-rlc-sequence-number.h (module 'lte'): ns3::SequenceNumber10::SequenceNumber10(ns3::SequenceNumber10 const & value) [constructor] cls.add_constructor([param('ns3::SequenceNumber10 const &', 'value')]) ## lte-rlc-sequence-number.h (module 'lte'): uint16_t ns3::SequenceNumber10::GetValue() const [member function] cls.add_method('GetValue', @@ -8708,7 +9123,7 @@ def register_Ns3SequenceNumber10_methods(root_module, cls): def register_Ns3SiConfiguration_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s(ns3::SiConfiguration_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::SiConfiguration_s(ns3::SiConfiguration_s const & arg0) [constructor] cls.add_constructor([param('ns3::SiConfiguration_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SiConfiguration_s::m_sfn [variable] cls.add_instance_attribute('m_sfn', 'uint16_t', is_const=False) @@ -8723,7 +9138,7 @@ def register_Ns3SiConfiguration_s_methods(root_module, cls): def register_Ns3SiMessageListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s(ns3::SiMessageListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::SiMessageListElement_s(ns3::SiMessageListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::SiMessageListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SiMessageListElement_s::m_length [variable] cls.add_instance_attribute('m_length', 'uint16_t', is_const=False) @@ -8734,7 +9149,7 @@ def register_Ns3SiMessageListElement_s_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -8744,7 +9159,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -8826,7 +9241,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3SpsConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s(ns3::SpsConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::SpsConfig_s(ns3::SpsConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::SpsConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SpsConfig_s::m_implicitReleaseAfter [variable] cls.add_instance_attribute('m_implicitReleaseAfter', 'uint8_t', is_const=False) @@ -8845,7 +9260,7 @@ def register_Ns3SpsConfig_s_methods(root_module, cls): def register_Ns3SrConfig_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s(ns3::SrConfig_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::SrConfig_s(ns3::SrConfig_s const & arg0) [constructor] cls.add_constructor([param('ns3::SrConfig_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SrConfig_s::m_action [variable] cls.add_instance_attribute('m_action', 'ns3::SetupRelease_e', is_const=False) @@ -8858,7 +9273,7 @@ def register_Ns3SrConfig_s_methods(root_module, cls): def register_Ns3SrListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s(ns3::SrListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::SrListElement_s(ns3::SrListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::SrListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::SrListElement_s::m_rnti [variable] cls.add_instance_attribute('m_rnti', 'uint16_t', is_const=False) @@ -8867,7 +9282,7 @@ def register_Ns3SrListElement_s_methods(root_module, cls): def register_Ns3StatisticalSummary_methods(root_module, cls): ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary() [constructor] cls.add_constructor([]) - ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::StatisticalSummary::StatisticalSummary(ns3::StatisticalSummary const & arg0) [constructor] cls.add_constructor([param('ns3::StatisticalSummary const &', 'arg0')]) ## data-calculator.h (module 'stats'): long int ns3::StatisticalSummary::getCount() const [member function] cls.add_method('getCount', @@ -8914,7 +9329,7 @@ def register_Ns3StatisticalSummary_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -8944,7 +9359,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -8988,14 +9403,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -9009,7 +9424,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): def register_Ns3TbId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t(ns3::TbId_t const & arg0) [copy constructor] + ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t(ns3::TbId_t const & arg0) [constructor] cls.add_constructor([param('ns3::TbId_t const &', 'arg0')]) ## lte-spectrum-phy.h (module 'lte'): ns3::TbId_t::TbId_t() [constructor] cls.add_constructor([]) @@ -9024,7 +9439,7 @@ def register_Ns3TbId_t_methods(root_module, cls): def register_Ns3TbStats_t_methods(root_module, cls): ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t() [constructor] cls.add_constructor([]) - ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t(ns3::TbStats_t const & arg0) [copy constructor] + ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::TbStats_t(ns3::TbStats_t const & arg0) [constructor] cls.add_constructor([param('ns3::TbStats_t const &', 'arg0')]) ## lte-mi-error-model.h (module 'lte'): ns3::TbStats_t::mi [variable] cls.add_instance_attribute('mi', 'double', is_const=False) @@ -9034,7 +9449,7 @@ def register_Ns3TbStats_t_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -9043,7 +9458,7 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TransmissionModesLayers_methods(root_module, cls): ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers() [constructor] cls.add_constructor([]) - ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers(ns3::TransmissionModesLayers const & arg0) [copy constructor] + ## lte-common.h (module 'lte'): ns3::TransmissionModesLayers::TransmissionModesLayers(ns3::TransmissionModesLayers const & arg0) [constructor] cls.add_constructor([param('ns3::TransmissionModesLayers const &', 'arg0')]) ## lte-common.h (module 'lte'): static uint8_t ns3::TransmissionModesLayers::TxMode2LayerNum(uint8_t txMode) [member function] cls.add_method('TxMode2LayerNum', @@ -9053,33 +9468,32 @@ def register_Ns3TransmissionModesLayers_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -9095,7 +9509,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -9105,9 +9519,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -9174,12 +9588,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -9189,12 +9603,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -9204,7 +9618,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -9220,7 +9634,7 @@ def register_Ns3TypeId_methods(root_module, cls): cls.add_method('SetParent', 'ns3::TypeId', [], - template_parameters=['ns3::Object']) + template_parameters=[u'ns3::Object']) ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetSize(std::size_t size) [member function] cls.add_method('SetSize', 'ns3::TypeId', @@ -9234,13 +9648,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -9259,7 +9672,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -9278,7 +9691,7 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3UeCapabilities_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s(ns3::UeCapabilities_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::UeCapabilities_s(ns3::UeCapabilities_s const & arg0) [constructor] cls.add_constructor([param('ns3::UeCapabilities_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UeCapabilities_s::m_halfDuplex [variable] cls.add_instance_attribute('m_halfDuplex', 'bool', is_const=False) @@ -9295,7 +9708,7 @@ def register_Ns3UeCapabilities_s_methods(root_module, cls): def register_Ns3UeSelected_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s(ns3::UeSelected_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::UeSelected_s(ns3::UeSelected_s const & arg0) [constructor] cls.add_constructor([param('ns3::UeSelected_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UeSelected_s::m_sbCqi [variable] cls.add_instance_attribute('m_sbCqi', 'std::vector< unsigned char >', is_const=False) @@ -9308,7 +9721,7 @@ def register_Ns3UeSelected_s_methods(root_module, cls): def register_Ns3UlCqi_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s(ns3::UlCqi_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::UlCqi_s(ns3::UlCqi_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlCqi_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlCqi_s::m_sinr [variable] cls.add_instance_attribute('m_sinr', 'std::vector< unsigned short >', is_const=False) @@ -9319,7 +9732,7 @@ def register_Ns3UlCqi_s_methods(root_module, cls): def register_Ns3UlDciListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s(ns3::UlDciListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::UlDciListElement_s(ns3::UlDciListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlDciListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlDciListElement_s::m_aggrLevel [variable] cls.add_instance_attribute('m_aggrLevel', 'uint8_t', is_const=False) @@ -9360,7 +9773,7 @@ def register_Ns3UlDciListElement_s_methods(root_module, cls): def register_Ns3UlGrant_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s(ns3::UlGrant_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::UlGrant_s(ns3::UlGrant_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlGrant_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlGrant_s::m_cqiRequest [variable] cls.add_instance_attribute('m_cqiRequest', 'bool', is_const=False) @@ -9385,7 +9798,7 @@ def register_Ns3UlGrant_s_methods(root_module, cls): def register_Ns3UlInfoListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s(ns3::UlInfoListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::UlInfoListElement_s(ns3::UlInfoListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::UlInfoListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::UlInfoListElement_s::m_receptionStatus [variable] cls.add_instance_attribute('m_receptionStatus', 'ns3::UlInfoListElement_s::ReceptionStatus_e', is_const=False) @@ -9400,7 +9813,7 @@ def register_Ns3UlInfoListElement_s_methods(root_module, cls): def register_Ns3UplinkLteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase(ns3::UplinkLteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::UplinkLteGlobalPathlossDatabase::UplinkLteGlobalPathlossDatabase(ns3::UplinkLteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::UplinkLteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): void ns3::UplinkLteGlobalPathlossDatabase::UpdatePathloss(std::string context, ns3::Ptr txPhy, ns3::Ptr rxPhy, double lossDb) [member function] cls.add_method('UpdatePathloss', @@ -9410,14 +9823,21 @@ def register_Ns3UplinkLteGlobalPathlossDatabase_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -9425,14 +9845,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -9444,7 +9871,7 @@ def register_Ns3Vector3D_methods(root_module, cls): def register_Ns3VendorSpecificListElement_s_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s(ns3::VendorSpecificListElement_s const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::VendorSpecificListElement_s(ns3::VendorSpecificListElement_s const & arg0) [constructor] cls.add_constructor([param('ns3::VendorSpecificListElement_s const &', 'arg0')]) ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificListElement_s::m_length [variable] cls.add_instance_attribute('m_length', 'uint32_t', is_const=False) @@ -9457,14 +9884,14 @@ def register_Ns3VendorSpecificListElement_s_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3FdbetsFlowPerf_t_methods(root_module, cls): ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t() [constructor] cls.add_constructor([]) - ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t(ns3::fdbetsFlowPerf_t const & arg0) [copy constructor] + ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::fdbetsFlowPerf_t(ns3::fdbetsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::fdbetsFlowPerf_t const &', 'arg0')]) ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::fdbetsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9479,7 +9906,7 @@ def register_Ns3FdbetsFlowPerf_t_methods(root_module, cls): def register_Ns3FdtbfqsFlowPerf_t_methods(root_module, cls): ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t() [constructor] cls.add_constructor([]) - ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t(ns3::fdtbfqsFlowPerf_t const & arg0) [copy constructor] + ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::fdtbfqsFlowPerf_t(ns3::fdtbfqsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::fdtbfqsFlowPerf_t const &', 'arg0')]) ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::fdtbfqsFlowPerf_t::burstCredit [variable] cls.add_instance_attribute('burstCredit', 'uint32_t', is_const=False) @@ -9502,76 +9929,76 @@ def register_Ns3FdtbfqsFlowPerf_t_methods(root_module, cls): return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3PfsFlowPerf_t_methods(root_module, cls): ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t() [constructor] cls.add_constructor([]) - ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t(ns3::pfsFlowPerf_t const & arg0) [copy constructor] + ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::pfsFlowPerf_t(ns3::pfsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::pfsFlowPerf_t const &', 'arg0')]) ## pf-ff-mac-scheduler.h (module 'lte'): ns3::pfsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9586,7 +10013,7 @@ def register_Ns3PfsFlowPerf_t_methods(root_module, cls): def register_Ns3PssFlowPerf_t_methods(root_module, cls): ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t() [constructor] cls.add_constructor([]) - ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t(ns3::pssFlowPerf_t const & arg0) [copy constructor] + ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::pssFlowPerf_t(ns3::pssFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::pssFlowPerf_t const &', 'arg0')]) ## pss-ff-mac-scheduler.h (module 'lte'): ns3::pssFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9605,7 +10032,7 @@ def register_Ns3PssFlowPerf_t_methods(root_module, cls): def register_Ns3TbInfo_t_methods(root_module, cls): ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t() [constructor] cls.add_constructor([]) - ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t(ns3::tbInfo_t const & arg0) [copy constructor] + ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::tbInfo_t(ns3::tbInfo_t const & arg0) [constructor] cls.add_constructor([param('ns3::tbInfo_t const &', 'arg0')]) ## lte-spectrum-phy.h (module 'lte'): ns3::tbInfo_t::corrupt [variable] cls.add_instance_attribute('corrupt', 'bool', is_const=False) @@ -9632,7 +10059,7 @@ def register_Ns3TbInfo_t_methods(root_module, cls): def register_Ns3TdbetsFlowPerf_t_methods(root_module, cls): ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t() [constructor] cls.add_constructor([]) - ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t(ns3::tdbetsFlowPerf_t const & arg0) [copy constructor] + ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::tdbetsFlowPerf_t(ns3::tdbetsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::tdbetsFlowPerf_t const &', 'arg0')]) ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::tdbetsFlowPerf_t::flowStart [variable] cls.add_instance_attribute('flowStart', 'ns3::Time', is_const=False) @@ -9647,7 +10074,7 @@ def register_Ns3TdbetsFlowPerf_t_methods(root_module, cls): def register_Ns3TdtbfqsFlowPerf_t_methods(root_module, cls): ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t() [constructor] cls.add_constructor([]) - ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t(ns3::tdtbfqsFlowPerf_t const & arg0) [copy constructor] + ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::tdtbfqsFlowPerf_t(ns3::tdtbfqsFlowPerf_t const & arg0) [constructor] cls.add_constructor([param('ns3::tdtbfqsFlowPerf_t const &', 'arg0')]) ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::tdtbfqsFlowPerf_t::burstCredit [variable] cls.add_instance_attribute('burstCredit', 'uint32_t', is_const=False) @@ -9672,7 +10099,7 @@ def register_Ns3TdtbfqsFlowPerf_t_methods(root_module, cls): def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -9694,7 +10121,7 @@ def register_Ns3Chunk_methods(root_module, cls): def register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, cls): ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase() [constructor] cls.add_constructor([]) - ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase(ns3::DownlinkLteGlobalPathlossDatabase const & arg0) [copy constructor] + ## lte-global-pathloss-database.h (module 'lte'): ns3::DownlinkLteGlobalPathlossDatabase::DownlinkLteGlobalPathlossDatabase(ns3::DownlinkLteGlobalPathlossDatabase const & arg0) [constructor] cls.add_constructor([param('ns3::DownlinkLteGlobalPathlossDatabase const &', 'arg0')]) ## lte-global-pathloss-database.h (module 'lte'): void ns3::DownlinkLteGlobalPathlossDatabase::UpdatePathloss(std::string context, ns3::Ptr txPhy, ns3::Ptr rxPhy, double lossDb) [member function] cls.add_method('UpdatePathloss', @@ -9704,7 +10131,7 @@ def register_Ns3DownlinkLteGlobalPathlossDatabase_methods(root_module, cls): return def register_Ns3EpsBearerTag_methods(root_module, cls): - ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag(ns3::EpsBearerTag const & arg0) [copy constructor] + ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag(ns3::EpsBearerTag const & arg0) [constructor] cls.add_constructor([param('ns3::EpsBearerTag const &', 'arg0')]) ## eps-bearer-tag.h (module 'lte'): ns3::EpsBearerTag::EpsBearerTag() [constructor] cls.add_constructor([]) @@ -9764,7 +10191,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -9794,7 +10221,7 @@ def register_Ns3Header_methods(root_module, cls): return def register_Ns3Ipv4Header_methods(root_module, cls): - ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [copy constructor] + ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header(ns3::Ipv4Header const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Header const &', 'arg0')]) ## ipv4-header.h (module 'internet'): ns3::Ipv4Header::Ipv4Header() [constructor] cls.add_constructor([]) @@ -9968,7 +10395,7 @@ def register_Ns3Ipv4Header_methods(root_module, cls): def register_Ns3LteCcmMacSapUser_methods(root_module, cls): ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser() [constructor] cls.add_constructor([]) - ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser(ns3::LteCcmMacSapUser const & arg0) [copy constructor] + ## lte-ccm-mac-sap.h (module 'lte'): ns3::LteCcmMacSapUser::LteCcmMacSapUser(ns3::LteCcmMacSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteCcmMacSapUser const &', 'arg0')]) ## lte-ccm-mac-sap.h (module 'lte'): void ns3::LteCcmMacSapUser::NotifyPrbOccupancy(double prbOccupancy, uint8_t componentCarrierId) [member function] cls.add_method('NotifyPrbOccupancy', @@ -9985,7 +10412,7 @@ def register_Ns3LteCcmMacSapUser_methods(root_module, cls): def register_Ns3LteEnbRrcSapProvider_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider(ns3::LteEnbRrcSapProvider const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::LteEnbRrcSapProvider(ns3::LteEnbRrcSapProvider const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapProvider const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapProvider::CompleteSetupUe(uint16_t rnti, ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters params) [member function] cls.add_method('CompleteSetupUe', @@ -10027,7 +10454,7 @@ def register_Ns3LteEnbRrcSapProvider_methods(root_module, cls): def register_Ns3LteEnbRrcSapProviderCompleteSetupUeParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters(ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::CompleteSetupUeParameters(ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapProvider::CompleteSetupUeParameters::srb0SapUser [variable] cls.add_instance_attribute('srb0SapUser', 'ns3::LteRlcSapUser *', is_const=False) @@ -10038,7 +10465,7 @@ def register_Ns3LteEnbRrcSapProviderCompleteSetupUeParameters_methods(root_modul def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser(ns3::LteEnbRrcSapUser const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::LteEnbRrcSapUser(ns3::LteEnbRrcSapUser const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapUser const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteRrcSap::RrcConnectionReconfiguration ns3::LteEnbRrcSapUser::DecodeHandoverCommand(ns3::Ptr p) [member function] cls.add_method('DecodeHandoverCommand', @@ -10095,10 +10522,10 @@ def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): 'void', [param('uint16_t', 'rnti'), param('ns3::LteRrcSap::RrcConnectionSetup', 'msg')], is_pure_virtual=True, is_virtual=True) - ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SendSystemInformation(ns3::LteRrcSap::SystemInformation msg) [member function] + ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SendSystemInformation(uint16_t cellId, ns3::LteRrcSap::SystemInformation msg) [member function] cls.add_method('SendSystemInformation', 'void', - [param('ns3::LteRrcSap::SystemInformation', 'msg')], + [param('uint16_t', 'cellId'), param('ns3::LteRrcSap::SystemInformation', 'msg')], is_pure_virtual=True, is_virtual=True) ## lte-rrc-sap.h (module 'lte'): void ns3::LteEnbRrcSapUser::SetupUe(uint16_t rnti, ns3::LteEnbRrcSapUser::SetupUeParameters params) [member function] cls.add_method('SetupUe', @@ -10110,7 +10537,7 @@ def register_Ns3LteEnbRrcSapUser_methods(root_module, cls): def register_Ns3LteEnbRrcSapUserSetupUeParameters_methods(root_module, cls): ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters() [constructor] cls.add_constructor([]) - ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters(ns3::LteEnbRrcSapUser::SetupUeParameters const & arg0) [copy constructor] + ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::SetupUeParameters(ns3::LteEnbRrcSapUser::SetupUeParameters const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcSapUser::SetupUeParameters const &', 'arg0')]) ## lte-rrc-sap.h (module 'lte'): ns3::LteEnbRrcSapUser::SetupUeParameters::srb0SapProvider [variable] cls.add_instance_attribute('srb0SapProvider', 'ns3::LteRlcSapProvider *', is_const=False) @@ -10119,7 +10546,7 @@ def register_Ns3LteEnbRrcSapUserSetupUeParameters_methods(root_module, cls): return def register_Ns3LtePdcpHeader_methods(root_module, cls): - ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader(ns3::LtePdcpHeader const & arg0) [copy constructor] + ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader(ns3::LtePdcpHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcpHeader const &', 'arg0')]) ## lte-pdcp-header.h (module 'lte'): ns3::LtePdcpHeader::LtePdcpHeader() [constructor] cls.add_constructor([]) @@ -10174,7 +10601,7 @@ def register_Ns3LtePdcpHeader_methods(root_module, cls): return def register_Ns3LtePhyTag_methods(root_module, cls): - ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag(ns3::LtePhyTag const & arg0) [copy constructor] + ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag(ns3::LtePhyTag const & arg0) [constructor] cls.add_constructor([param('ns3::LtePhyTag const &', 'arg0')]) ## lte-phy-tag.h (module 'lte'): ns3::LtePhyTag::LtePhyTag() [constructor] cls.add_constructor([]) @@ -10218,7 +10645,7 @@ def register_Ns3LtePhyTag_methods(root_module, cls): return def register_Ns3LteRadioBearerTag_methods(root_module, cls): - ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag(ns3::LteRadioBearerTag const & arg0) [copy constructor] + ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag(ns3::LteRadioBearerTag const & arg0) [constructor] cls.add_constructor([param('ns3::LteRadioBearerTag const &', 'arg0')]) ## lte-radio-bearer-tag.h (module 'lte'): ns3::LteRadioBearerTag::LteRadioBearerTag() [constructor] cls.add_constructor([]) @@ -10286,7 +10713,7 @@ def register_Ns3LteRadioBearerTag_methods(root_module, cls): return def register_Ns3LteRlcAmHeader_methods(root_module, cls): - ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader(ns3::LteRlcAmHeader const & arg0) [copy constructor] + ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader(ns3::LteRlcAmHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcAmHeader const &', 'arg0')]) ## lte-rlc-am-header.h (module 'lte'): ns3::LteRlcAmHeader::LteRlcAmHeader() [constructor] cls.add_constructor([]) @@ -10441,7 +10868,7 @@ def register_Ns3LteRlcAmHeader_methods(root_module, cls): return def register_Ns3LteRlcHeader_methods(root_module, cls): - ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader(ns3::LteRlcHeader const & arg0) [copy constructor] + ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader(ns3::LteRlcHeader const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcHeader const &', 'arg0')]) ## lte-rlc-header.h (module 'lte'): ns3::LteRlcHeader::LteRlcHeader() [constructor] cls.add_constructor([]) @@ -10512,7 +10939,7 @@ def register_Ns3LteRlcHeader_methods(root_module, cls): return def register_Ns3LteRlcSduStatusTag_methods(root_module, cls): - ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag(ns3::LteRlcSduStatusTag const & arg0) [copy constructor] + ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag(ns3::LteRlcSduStatusTag const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSduStatusTag const &', 'arg0')]) ## lte-rlc-sdu-status-tag.h (module 'lte'): ns3::LteRlcSduStatusTag::LteRlcSduStatusTag() [constructor] cls.add_constructor([]) @@ -10592,7 +11019,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -10613,7 +11040,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -10622,14 +11049,14 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) return def register_Ns3PacketBurst_methods(root_module, cls): - ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor] + ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [constructor] cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')]) ## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor] cls.add_constructor([]) @@ -10637,9 +11064,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): cls.add_method('AddPacket', 'void', [param('ns3::Ptr< ns3::Packet >', 'packet')]) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::Begin() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): ns3::Ptr ns3::PacketBurst::Copy() const [member function] @@ -10647,9 +11074,9 @@ def register_Ns3PacketBurst_methods(root_module, cls): 'ns3::Ptr< ns3::PacketBurst >', [], is_const=True) - ## packet-burst.h (module 'network'): std::_List_const_iterator > ns3::PacketBurst::End() const [member function] + ## packet-burst.h (module 'network'): std::list, std::allocator > >::const_iterator ns3::PacketBurst::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >', + 'std::list< ns3::Ptr< ns3::Packet > > const_iterator', [], is_const=True) ## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function] @@ -10680,7 +11107,7 @@ def register_Ns3PacketBurst_methods(root_module, cls): return def register_Ns3PdcpTag_methods(root_module, cls): - ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag(ns3::PdcpTag const & arg0) [copy constructor] + ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag(ns3::PdcpTag const & arg0) [constructor] cls.add_constructor([param('ns3::PdcpTag const &', 'arg0')]) ## lte-pdcp-tag.h (module 'lte'): ns3::PdcpTag::PdcpTag() [constructor] cls.add_constructor([]) @@ -10799,7 +11226,7 @@ def register_Ns3RandomVariableStream_methods(root_module, cls): return def register_Ns3RlcTag_methods(root_module, cls): - ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag(ns3::RlcTag const & arg0) [copy constructor] + ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag(ns3::RlcTag const & arg0) [constructor] cls.add_constructor([param('ns3::RlcTag const &', 'arg0')]) ## lte-rlc-tag.h (module 'lte'): ns3::RlcTag::RlcTag() [constructor] cls.add_constructor([]) @@ -10889,7 +11316,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10901,7 +11328,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10913,7 +11340,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10925,7 +11352,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10937,7 +11364,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EpcTft_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTft__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EpcTft, ns3::empty, ns3::DefaultDeleter< ns3::EpcTft > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10949,7 +11376,7 @@ def register_Ns3SimpleRefCount__Ns3EpcTft_Ns3Empty_Ns3DefaultDeleter__lt__ns3Epc def register_Ns3SimpleRefCount__Ns3EpcTftClassifier_Ns3Empty_Ns3DefaultDeleter__lt__ns3EpcTftClassifier__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EpcTftClassifier, ns3::empty, ns3::DefaultDeleter< ns3::EpcTftClassifier > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10961,7 +11388,7 @@ def register_Ns3SimpleRefCount__Ns3EpcTftClassifier_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10973,7 +11400,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10985,7 +11412,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3Ipv4MulticastRoute_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4MulticastRoute__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Ipv4MulticastRoute, ns3::empty, ns3::DefaultDeleter< ns3::Ipv4MulticastRoute > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -10997,7 +11424,7 @@ def register_Ns3SimpleRefCount__Ns3Ipv4MulticastRoute_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3Ipv4Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3Ipv4Route__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Ipv4Route, ns3::empty, ns3::DefaultDeleter< ns3::Ipv4Route > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11009,7 +11436,7 @@ def register_Ns3SimpleRefCount__Ns3Ipv4Route_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3LteChunkProcessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteChunkProcessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteChunkProcessor, ns3::empty, ns3::DefaultDeleter< ns3::LteChunkProcessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11021,7 +11448,7 @@ def register_Ns3SimpleRefCount__Ns3LteChunkProcessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3LteControlMessage_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteControlMessage__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteControlMessage, ns3::empty, ns3::DefaultDeleter< ns3::LteControlMessage > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11033,7 +11460,7 @@ def register_Ns3SimpleRefCount__Ns3LteControlMessage_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns3LteHarqPhy__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::LteHarqPhy, ns3::empty, ns3::DefaultDeleter< ns3::LteHarqPhy > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11045,7 +11472,7 @@ def register_Ns3SimpleRefCount__Ns3LteHarqPhy_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11057,7 +11484,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11069,7 +11496,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumModel__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumModel, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumModel > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11081,7 +11508,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumModel_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumSignalParameters__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumSignalParameters, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumSignalParameters > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11093,7 +11520,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumSignalParameters_Ns3Empty_Ns3DefaultD def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3SpectrumValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::SpectrumValue, ns3::empty, ns3::DefaultDeleter< ns3::SpectrumValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11105,7 +11532,7 @@ def register_Ns3SimpleRefCount__Ns3SpectrumValue_Ns3Empty_Ns3DefaultDeleter__lt_ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11117,7 +11544,7 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3VendorSpecificValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3VendorSpecificValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::VendorSpecificValue, ns3::empty, ns3::DefaultDeleter< ns3::VendorSpecificValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11129,7 +11556,7 @@ def register_Ns3SimpleRefCount__Ns3VendorSpecificValue_Ns3Empty_Ns3DefaultDelete def register_Ns3SimpleRefCount__Ns3X2CellInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2CellInfo__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::X2CellInfo, ns3::empty, ns3::DefaultDeleter< ns3::X2CellInfo > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11141,7 +11568,7 @@ def register_Ns3SimpleRefCount__Ns3X2CellInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns def register_Ns3SimpleRefCount__Ns3X2IfaceInfo_Ns3Empty_Ns3DefaultDeleter__lt__ns3X2IfaceInfo__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::X2IfaceInfo, ns3::empty, ns3::DefaultDeleter< ns3::X2IfaceInfo > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -11151,7 +11578,7 @@ def register_Ns3SimpleRefCount__Ns3X2IfaceInfo_Ns3Empty_Ns3DefaultDeleter__lt__n return def register_Ns3Socket_methods(root_module, cls): - ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::Socket::Socket(ns3::Socket const & arg0) [constructor] cls.add_constructor([param('ns3::Socket const &', 'arg0')]) ## socket.h (module 'network'): ns3::Socket::Socket() [constructor] cls.add_constructor([]) @@ -11269,7 +11696,7 @@ def register_Ns3Socket_methods(root_module, cls): 'uint8_t', [param('uint8_t', 'ipTos')], is_static=True) - ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] + ## socket.h (module 'network'): void ns3::Socket::Ipv6JoinGroup(ns3::Ipv6Address address, ns3::Socket::Ipv6MulticastFilterMode filterMode, std::vector > sourceAddresses) [member function] cls.add_method('Ipv6JoinGroup', 'void', [param('ns3::Ipv6Address', 'address'), param('ns3::Socket::Ipv6MulticastFilterMode', 'filterMode'), param('std::vector< ns3::Ipv6Address >', 'sourceAddresses')], @@ -11362,7 +11789,7 @@ def register_Ns3Socket_methods(root_module, cls): cls.add_method('SendTo', 'int', [param('uint8_t const *', 'buf'), param('uint32_t', 'size'), param('uint32_t', 'flags'), param('ns3::Address const &', 'address')]) - ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] + ## socket.h (module 'network'): void ns3::Socket::SetAcceptCallback(ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> connectionRequest, ns3::Callback, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> newConnectionCreated) [member function] cls.add_method('SetAcceptCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'connectionRequest'), param('ns3::Callback< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'newConnectionCreated')]) @@ -11511,7 +11938,7 @@ def register_Ns3Socket_methods(root_module, cls): return def register_Ns3SocketIpTosTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag(ns3::SocketIpTosTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTosTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTosTag::SocketIpTosTag() [constructor] cls.add_constructor([]) @@ -11557,7 +11984,7 @@ def register_Ns3SocketIpTosTag_methods(root_module, cls): return def register_Ns3SocketIpTtlTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag(ns3::SocketIpTtlTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpTtlTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpTtlTag::SocketIpTtlTag() [constructor] cls.add_constructor([]) @@ -11603,7 +12030,7 @@ def register_Ns3SocketIpTtlTag_methods(root_module, cls): return def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag(ns3::SocketIpv6HopLimitTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6HopLimitTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6HopLimitTag::SocketIpv6HopLimitTag() [constructor] cls.add_constructor([]) @@ -11649,7 +12076,7 @@ def register_Ns3SocketIpv6HopLimitTag_methods(root_module, cls): return def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag(ns3::SocketIpv6TclassTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketIpv6TclassTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketIpv6TclassTag::SocketIpv6TclassTag() [constructor] cls.add_constructor([]) @@ -11695,7 +12122,7 @@ def register_Ns3SocketIpv6TclassTag_methods(root_module, cls): return def register_Ns3SocketPriorityTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag(ns3::SocketPriorityTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketPriorityTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketPriorityTag::SocketPriorityTag() [constructor] cls.add_constructor([]) @@ -11741,7 +12168,7 @@ def register_Ns3SocketPriorityTag_methods(root_module, cls): return def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): - ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [copy constructor] + ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag(ns3::SocketSetDontFragmentTag const & arg0) [constructor] cls.add_constructor([param('ns3::SocketSetDontFragmentTag const &', 'arg0')]) ## socket.h (module 'network'): ns3::SocketSetDontFragmentTag::SocketSetDontFragmentTag() [constructor] cls.add_constructor([]) @@ -11791,22 +12218,8 @@ def register_Ns3SocketSetDontFragmentTag_methods(root_module, cls): return def register_Ns3SpectrumInterference_methods(root_module, cls): - ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [copy constructor] - cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference() [constructor] cls.add_constructor([]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] - cls.add_method('AbortRx', - 'void', - []) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] - cls.add_method('AddSignal', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) - ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] - cls.add_method('EndRx', - 'bool', - []) ## spectrum-interference.h (module 'spectrum'): static ns3::TypeId ns3::SpectrumInterference::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', @@ -11816,14 +12229,28 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): cls.add_method('SetErrorModel', 'void', [param('ns3::Ptr< ns3::SpectrumErrorModel >', 'e')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] - cls.add_method('SetNoisePowerSpectralDensity', - 'void', - [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) - ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::StartRx(ns3::Ptr p, ns3::Ptr rxPsd) [member function] cls.add_method('StartRx', 'void', [param('ns3::Ptr< ns3::Packet const >', 'p'), param('ns3::Ptr< ns3::SpectrumValue const >', 'rxPsd')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AbortRx() [member function] + cls.add_method('AbortRx', + 'void', + []) + ## spectrum-interference.h (module 'spectrum'): bool ns3::SpectrumInterference::EndRx() [member function] + cls.add_method('EndRx', + 'bool', + []) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] + cls.add_method('AddSignal', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) + ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + cls.add_method('SetNoisePowerSpectralDensity', + 'void', + [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) + ## spectrum-interference.h (module 'spectrum'): ns3::SpectrumInterference::SpectrumInterference(ns3::SpectrumInterference const & arg0) [constructor] + cls.add_constructor([param('ns3::SpectrumInterference const &', 'arg0')]) ## spectrum-interference.h (module 'spectrum'): void ns3::SpectrumInterference::DoDispose() [member function] cls.add_method('DoDispose', 'void', @@ -11833,20 +12260,20 @@ def register_Ns3SpectrumInterference_methods(root_module, cls): def register_Ns3SpectrumModel_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [copy constructor] + ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::SpectrumModel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumModel const &', 'arg0')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(std::vector > centerFreqs) [constructor] cls.add_constructor([param('std::vector< double >', 'centerFreqs')]) ## spectrum-model.h (module 'spectrum'): ns3::SpectrumModel::SpectrumModel(ns3::Bands bands) [constructor] cls.add_constructor([param('ns3::Bands', 'bands')]) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::Begin() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-model.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumModel::End() const [member function] + ## spectrum-model.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumModel::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) ## spectrum-model.h (module 'spectrum'): size_t ns3::SpectrumModel::GetNumBands() const [member function] @@ -11899,7 +12326,7 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::SpectrumChannel >', 'c')], is_pure_virtual=True, is_virtual=True) - ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] + ## spectrum-phy.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -11917,11 +12344,11 @@ def register_Ns3SpectrumPhy_methods(root_module, cls): return def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel(ns3::SpectrumPropagationLossModel const & arg0) [copy constructor] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel(ns3::SpectrumPropagationLossModel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumPropagationLossModel const &', 'arg0')]) ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::SpectrumPropagationLossModel::SpectrumPropagationLossModel() [constructor] cls.add_constructor([]) - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::CalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::CalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('CalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -11940,7 +12367,7 @@ def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) - ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## spectrum-propagation-loss-model.h (module 'spectrum'): ns3::Ptr ns3::SpectrumPropagationLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('DoCalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -11950,34 +12377,34 @@ def register_Ns3SpectrumPropagationLossModel_methods(root_module, cls): def register_Ns3SpectrumSignalParameters_methods(root_module, cls): ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters() [constructor] cls.add_constructor([]) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [copy constructor] + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::SpectrumSignalParameters(ns3::SpectrumSignalParameters const & p) [constructor] cls.add_constructor([param('ns3::SpectrumSignalParameters const &', 'p')]) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::Ptr ns3::SpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::duration [variable] - cls.add_instance_attribute('duration', 'ns3::Time', is_const=False) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::psd [variable] cls.add_instance_attribute('psd', 'ns3::Ptr< ns3::SpectrumValue >', is_const=False) - ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txAntenna [variable] - cls.add_instance_attribute('txAntenna', 'ns3::Ptr< ns3::AntennaModel >', is_const=False) + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::duration [variable] + cls.add_instance_attribute('duration', 'ns3::Time', is_const=False) ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txPhy [variable] cls.add_instance_attribute('txPhy', 'ns3::Ptr< ns3::SpectrumPhy >', is_const=False) + ## spectrum-signal-parameters.h (module 'spectrum'): ns3::SpectrumSignalParameters::txAntenna [variable] + cls.add_instance_attribute('txAntenna', 'ns3::Ptr< ns3::AntennaModel >', is_const=False) return def register_Ns3SpectrumValue_methods(root_module, cls): + cls.add_output_stream_operator() + cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('*', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_unary_numeric_operator('-') cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) - cls.add_binary_numeric_operator('/', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) - cls.add_output_stream_operator() + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('double', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::SpectrumValue'], root_module['ns3::SpectrumValue'], param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('*=', param('double', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::SpectrumValue const &', u'right')) @@ -11986,30 +12413,30 @@ def register_Ns3SpectrumValue_methods(root_module, cls): cls.add_inplace_numeric_operator('-=', param('double', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::SpectrumValue const &', u'right')) cls.add_inplace_numeric_operator('/=', param('double', u'right')) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [copy constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::SpectrumValue const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumValue const &', 'arg0')]) - ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] + ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue(ns3::Ptr sm) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::SpectrumModel const >', 'sm')]) ## spectrum-value.h (module 'spectrum'): ns3::SpectrumValue::SpectrumValue() [constructor] cls.add_constructor([]) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsBegin() const [member function] cls.add_method('ConstBandsBegin', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstBandsEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstBandsEnd() const [member function] cls.add_method('ConstBandsEnd', - '__gnu_cxx::__normal_iterator< ns3::BandInfo const *, std::vector< ns3::BandInfo > >', + 'std::vector< ns3::BandInfo > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesBegin() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesBegin() const [member function] cls.add_method('ConstValuesBegin', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ConstValuesEnd() const [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::const_iterator ns3::SpectrumValue::ConstValuesEnd() const [member function] cls.add_method('ConstValuesEnd', - '__gnu_cxx::__normal_iterator< double const *, std::vector< double > >', + 'std::vector< double > const_iterator', [], is_const=True) ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::Copy() const [member function] @@ -12017,7 +12444,7 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] + ## spectrum-value.h (module 'spectrum'): ns3::Ptr ns3::SpectrumValue::GetSpectrumModel() const [member function] cls.add_method('GetSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -12027,33 +12454,33 @@ def register_Ns3SpectrumValue_methods(root_module, cls): 'ns3::SpectrumModelUid_t', [], is_const=True) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesBegin() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesBegin() [member function] cls.add_method('ValuesBegin', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) - ## spectrum-value.h (module 'spectrum'): __gnu_cxx::__normal_iterator > > ns3::SpectrumValue::ValuesEnd() [member function] + ## spectrum-value.h (module 'spectrum'): std::vector >::iterator ns3::SpectrumValue::ValuesEnd() [member function] cls.add_method('ValuesEnd', - '__gnu_cxx::__normal_iterator< double *, std::vector< double > >', + 'std::vector< double > iterator', []) return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') + cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -12236,7 +12663,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceFadingLossModel_methods(root_module, cls): - ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel(ns3::TraceFadingLossModel const & arg0) [copy constructor] + ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel(ns3::TraceFadingLossModel const & arg0) [constructor] cls.add_constructor([param('ns3::TraceFadingLossModel const &', 'arg0')]) ## trace-fading-loss-model.h (module 'lte'): ns3::TraceFadingLossModel::TraceFadingLossModel() [constructor] cls.add_constructor([]) @@ -12254,7 +12681,7 @@ def register_Ns3TraceFadingLossModel_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## trace-fading-loss-model.h (module 'lte'): ns3::Ptr ns3::TraceFadingLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] + ## trace-fading-loss-model.h (module 'lte'): ns3::Ptr ns3::TraceFadingLossModel::DoCalcRxPowerSpectralDensity(ns3::Ptr txPsd, ns3::Ptr a, ns3::Ptr b) const [member function] cls.add_method('DoCalcRxPowerSpectralDensity', 'ns3::Ptr< ns3::SpectrumValue >', [param('ns3::Ptr< ns3::SpectrumValue const >', 'txPsd'), param('ns3::Ptr< ns3::MobilityModel const >', 'a'), param('ns3::Ptr< ns3::MobilityModel const >', 'b')], @@ -12262,7 +12689,7 @@ def register_Ns3TraceFadingLossModel_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -12292,7 +12719,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -12365,12 +12792,12 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): return def register_Ns3UeManager_methods(root_module, cls): - ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::UeManager const & arg0) [copy constructor] + ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::UeManager const & arg0) [constructor] cls.add_constructor([param('ns3::UeManager const &', 'arg0')]) ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager() [constructor] cls.add_constructor([]) - ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::Ptr rrc, uint16_t rnti, ns3::UeManager::State s) [constructor] - cls.add_constructor([param('ns3::Ptr< ns3::LteEnbRrc >', 'rrc'), param('uint16_t', 'rnti'), param('ns3::UeManager::State', 's')]) + ## lte-enb-rrc.h (module 'lte'): ns3::UeManager::UeManager(ns3::Ptr rrc, uint16_t rnti, ns3::UeManager::State s, uint8_t componentCarrierId) [constructor] + cls.add_constructor([param('ns3::Ptr< ns3::LteEnbRrc >', 'rrc'), param('uint16_t', 'rnti'), param('ns3::UeManager::State', 's'), param('uint8_t', 'componentCarrierId')]) ## lte-enb-rrc.h (module 'lte'): void ns3::UeManager::CmacUeConfigUpdateInd(ns3::LteEnbCmacSapUser::UeConfig cmacParams) [member function] cls.add_method('CmacUeConfigUpdateInd', 'void', @@ -12383,6 +12810,11 @@ def register_Ns3UeManager_methods(root_module, cls): cls.add_method('DoReceivePdcpSdu', 'void', [param('ns3::LtePdcpSapUser::ReceivePdcpSduParameters', 'params')]) + ## lte-enb-rrc.h (module 'lte'): uint8_t ns3::UeManager::GetComponentCarrierId() const [member function] + cls.add_method('GetComponentCarrierId', + 'uint8_t', + [], + is_const=True) ## lte-enb-rrc.h (module 'lte'): std::vector > ns3::UeManager::GetErabList() [member function] cls.add_method('GetErabList', 'std::vector< ns3::EpcX2Sap::ErabToBeSetupItem >', @@ -12561,7 +12993,7 @@ def register_Ns3UniformRandomVariable_methods(root_module, cls): def register_Ns3VendorSpecificValue_methods(root_module, cls): ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue() [constructor] cls.add_constructor([]) - ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue(ns3::VendorSpecificValue const & arg0) [copy constructor] + ## ff-mac-common.h (module 'lte'): ns3::VendorSpecificValue::VendorSpecificValue(ns3::VendorSpecificValue const & arg0) [constructor] cls.add_constructor([param('ns3::VendorSpecificValue const &', 'arg0')]) return @@ -12609,7 +13041,7 @@ def register_Ns3WeibullRandomVariable_methods(root_module, cls): return def register_Ns3X2CellInfo_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(ns3::X2CellInfo const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(ns3::X2CellInfo const & arg0) [constructor] cls.add_constructor([param('ns3::X2CellInfo const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::X2CellInfo::X2CellInfo(uint16_t localCellId, uint16_t remoteCellId) [constructor] cls.add_constructor([param('uint16_t', 'localCellId'), param('uint16_t', 'remoteCellId')]) @@ -12620,7 +13052,7 @@ def register_Ns3X2CellInfo_methods(root_module, cls): return def register_Ns3X2IfaceInfo_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::X2IfaceInfo const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::X2IfaceInfo const & arg0) [constructor] cls.add_constructor([param('ns3::X2IfaceInfo const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::X2IfaceInfo::X2IfaceInfo(ns3::Ipv4Address remoteIpAddr, ns3::Ptr localCtrlPlaneSocket, ns3::Ptr localUserPlaneSocket) [constructor] cls.add_constructor([param('ns3::Ipv4Address', 'remoteIpAddr'), param('ns3::Ptr< ns3::Socket >', 'localCtrlPlaneSocket'), param('ns3::Ptr< ns3::Socket >', 'localUserPlaneSocket')]) @@ -12704,7 +13136,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3Application_methods(root_module, cls): - ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [copy constructor] + ## application.h (module 'network'): ns3::Application::Application(ns3::Application const & arg0) [constructor] cls.add_constructor([param('ns3::Application const &', 'arg0')]) ## application.h (module 'network'): ns3::Application::Application() [constructor] cls.add_constructor([]) @@ -12753,7 +13185,7 @@ def register_Ns3Application_methods(root_module, cls): return def register_Ns3Asn1Header_methods(root_module, cls): - ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header(ns3::Asn1Header const & arg0) [copy constructor] + ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header(ns3::Asn1Header const & arg0) [constructor] cls.add_constructor([param('ns3::Asn1Header const &', 'arg0')]) ## lte-asn1-header.h (module 'lte'): ns3::Asn1Header::Asn1Header() [constructor] cls.add_constructor([]) @@ -12792,50 +13224,50 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [param('ns3::Buffer::Iterator', 'bIterator')], is_const=True, is_virtual=True) - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitset(std::bitset<8u> * data, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitset(std::bitset<8> * data, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitset', 'ns3::Buffer::Iterator', - [param('std::bitset< 8u > *', 'data'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 8 > *', 'data'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<1u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<1> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 1u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 1 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<2u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<2> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 2u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 2 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<8u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<8> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 8u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 8 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<10u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<10> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 10u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 10 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<16u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<16> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 16u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 16 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<27u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<27> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 27u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 27 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<28u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<28> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 28u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 28 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<32u> * bitstring, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBitstring(std::bitset<32> * bitstring, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBitstring', 'ns3::Buffer::Iterator', - [param('std::bitset< 32u > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 32 > *', 'bitstring'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeBoolean(bool * value, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeBoolean', @@ -12862,60 +13294,60 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'ns3::Buffer::Iterator', [param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<0u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<0> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 0u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 0 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<1u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<1> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 1u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 1 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<2u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<2> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 2u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 2 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<3u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<3> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 3u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 3 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<4u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<4> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 4u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 4 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<5u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<5> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 5u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 5 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<6u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<6> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 6u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 6 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<7u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<7> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 7u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 7 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<9u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<9> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 9u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 9 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<10u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<10> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 10u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 10 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') - ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<11u> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] + ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequence(std::bitset<11> * optionalOrDefaultMask, bool isExtensionMarkerPresent, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequence', 'ns3::Buffer::Iterator', - [param('std::bitset< 11u > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], + [param('std::bitset< 11 > *', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent'), param('ns3::Buffer::Iterator', 'bIterator')], visibility='protected') ## lte-asn1-header.h (module 'lte'): ns3::Buffer::Iterator ns3::Asn1Header::DeserializeSequenceOf(int * numElems, int nMax, int nMin, ns3::Buffer::Iterator bIterator) [member function] cls.add_method('DeserializeSequenceOf', @@ -12927,45 +13359,45 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<1u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<1> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 1u >', 'bitstring')], + [param('std::bitset< 1 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<2u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<2> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 2u >', 'bitstring')], + [param('std::bitset< 2 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<8u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<8> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 8u >', 'bitstring')], + [param('std::bitset< 8 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<10u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<10> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 10u >', 'bitstring')], + [param('std::bitset< 10 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<16u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<16> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 16u >', 'bitstring')], + [param('std::bitset< 16 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<27u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<27> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 27u >', 'bitstring')], + [param('std::bitset< 27 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<28u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<28> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 28u >', 'bitstring')], + [param('std::bitset< 28 >', 'bitstring')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<32u> bitstring) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBitstring(std::bitset<32> bitstring) const [member function] cls.add_method('SerializeBitstring', 'void', - [param('std::bitset< 32u >', 'bitstring')], + [param('std::bitset< 32 >', 'bitstring')], is_const=True, visibility='protected') ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeBoolean(bool value) const [member function] cls.add_method('SerializeBoolean', @@ -12992,60 +13424,60 @@ def register_Ns3Asn1Header_methods(root_module, cls): 'void', [], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<0u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<0> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 0u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 0 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<1u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<1> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 1u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 1 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<2u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<2> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 2u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 2 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<3u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<3> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 3u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 3 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<4u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<4> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 4u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 4 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<5u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<5> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 5u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 5 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<6u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<6> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 6u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 6 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<7u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<7> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 7u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 7 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<9u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<9> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 9u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 9 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<10u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<10> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 10u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 10 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') - ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<11u> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] + ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequence(std::bitset<11> optionalOrDefaultMask, bool isExtensionMarkerPresent) const [member function] cls.add_method('SerializeSequence', 'void', - [param('std::bitset< 11u >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], + [param('std::bitset< 11 >', 'optionalOrDefaultMask'), param('bool', 'isExtensionMarkerPresent')], is_const=True, visibility='protected') ## lte-asn1-header.h (module 'lte'): void ns3::Asn1Header::SerializeSequenceOf(int numElems, int nMax, int nMin) const [member function] cls.add_method('SerializeSequenceOf', @@ -13060,7 +13492,7 @@ def register_Ns3Asn1Header_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -13087,7 +13519,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -13129,7 +13561,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -13138,12 +13570,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13153,13 +13585,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -13170,7 +13602,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13180,7 +13612,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13194,21 +13626,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -13218,10 +13650,140 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::PhyReceptionStatParameters']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'double']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned char']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::PhyTransmissionStatParameters']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteUePhy::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::EpcUeNas::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::SpectrumValue const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned long long']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UeManager::State']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteRrcSap::MeasurementReport']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::DlSchedulingCallbackInfo']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::LteUeRrc::State']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -13232,12 +13794,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13249,7 +13811,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3CcHelper_methods(root_module, cls): - ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper(ns3::CcHelper const & arg0) [copy constructor] + ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper(ns3::CcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::CcHelper const &', 'arg0')]) ## cc-helper.h (module 'lte'): ns3::CcHelper::CcHelper() [constructor] cls.add_constructor([]) @@ -13262,7 +13824,7 @@ def register_Ns3CcHelper_methods(root_module, cls): 'void', [], is_virtual=True) - ## cc-helper.h (module 'lte'): std::map, std::allocator > > ns3::CcHelper::EquallySpacedCcs() [member function] + ## cc-helper.h (module 'lte'): std::map, std::allocator > > ns3::CcHelper::EquallySpacedCcs() [member function] cls.add_method('EquallySpacedCcs', 'std::map< unsigned char, ns3::ComponentCarrier >', []) @@ -13323,7 +13885,7 @@ def register_Ns3CcHelper_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -13350,7 +13912,7 @@ def register_Ns3Channel_methods(root_module, cls): return def register_Ns3ComponentCarrier_methods(root_module, cls): - ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier(ns3::ComponentCarrier const & arg0) [copy constructor] + ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier(ns3::ComponentCarrier const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrier const &', 'arg0')]) ## component-carrier.h (module 'lte'): ns3::ComponentCarrier::ComponentCarrier() [constructor] cls.add_constructor([]) @@ -13443,7 +14005,7 @@ def register_Ns3ComponentCarrier_methods(root_module, cls): return def register_Ns3ComponentCarrierEnb_methods(root_module, cls): - ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb(ns3::ComponentCarrierEnb const & arg0) [copy constructor] + ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb(ns3::ComponentCarrierEnb const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrierEnb const &', 'arg0')]) ## component-carrier-enb.h (module 'lte'): ns3::ComponentCarrierEnb::ComponentCarrierEnb() [constructor] cls.add_constructor([]) @@ -13452,6 +14014,10 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): 'void', [], is_virtual=True) + ## component-carrier-enb.h (module 'lte'): uint16_t ns3::ComponentCarrierEnb::GetCellId() [member function] + cls.add_method('GetCellId', + 'uint16_t', + []) ## component-carrier-enb.h (module 'lte'): ns3::Ptr ns3::ComponentCarrierEnb::GetFfMacScheduler() [member function] cls.add_method('GetFfMacScheduler', 'ns3::Ptr< ns3::FfMacScheduler >', @@ -13473,6 +14039,10 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) + ## component-carrier-enb.h (module 'lte'): void ns3::ComponentCarrierEnb::SetCellId(uint16_t cellId) [member function] + cls.add_method('SetCellId', + 'void', + [param('uint16_t', 'cellId')]) ## component-carrier-enb.h (module 'lte'): void ns3::ComponentCarrierEnb::SetFfMacScheduler(ns3::Ptr s) [member function] cls.add_method('SetFfMacScheduler', 'void', @@ -13497,7 +14067,7 @@ def register_Ns3ComponentCarrierEnb_methods(root_module, cls): return def register_Ns3ComponentCarrierUe_methods(root_module, cls): - ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe(ns3::ComponentCarrierUe const & arg0) [copy constructor] + ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe(ns3::ComponentCarrierUe const & arg0) [constructor] cls.add_constructor([param('ns3::ComponentCarrierUe const &', 'arg0')]) ## component-carrier-ue.h (module 'lte'): ns3::ComponentCarrierUe::ComponentCarrierUe() [constructor] cls.add_constructor([]) @@ -13570,7 +14140,7 @@ def register_Ns3ConstantRandomVariable_methods(root_module, cls): return def register_Ns3DataCalculator_methods(root_module, cls): - ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [copy constructor] + ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator(ns3::DataCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::DataCalculator const &', 'arg0')]) ## data-calculator.h (module 'stats'): ns3::DataCalculator::DataCalculator() [constructor] cls.add_constructor([]) @@ -13633,7 +14203,7 @@ def register_Ns3DataCalculator_methods(root_module, cls): return def register_Ns3DataOutputInterface_methods(root_module, cls): - ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [copy constructor] + ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface(ns3::DataOutputInterface const & arg0) [constructor] cls.add_constructor([param('ns3::DataOutputInterface const &', 'arg0')]) ## data-output-interface.h (module 'stats'): ns3::DataOutputInterface::DataOutputInterface() [constructor] cls.add_constructor([]) @@ -13666,23 +14236,23 @@ def register_Ns3DataOutputInterface_methods(root_module, cls): def register_Ns3DataRateChecker_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [copy constructor] + ## data-rate.h (module 'network'): ns3::DataRateChecker::DataRateChecker(ns3::DataRateChecker const & arg0) [constructor] cls.add_constructor([param('ns3::DataRateChecker const &', 'arg0')]) return def register_Ns3DataRateValue_methods(root_module, cls): ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue() [constructor] cls.add_constructor([]) - ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRate const & value) [constructor] cls.add_constructor([param('ns3::DataRate const &', 'value')]) + ## data-rate.h (module 'network'): ns3::DataRateValue::DataRateValue(ns3::DataRateValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DataRateValue const &', 'arg0')]) ## data-rate.h (module 'network'): ns3::Ptr ns3::DataRateValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## data-rate.h (module 'network'): bool ns3::DataRateValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13692,7 +14262,7 @@ def register_Ns3DataRateValue_methods(root_module, cls): 'ns3::DataRate', [], is_const=True) - ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] + ## data-rate.h (module 'network'): std::string ns3::DataRateValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13730,16 +14300,16 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13749,7 +14319,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13795,7 +14365,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -13822,7 +14392,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -13859,7 +14429,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -13868,12 +14438,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13881,7 +14451,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -13926,7 +14496,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -13937,7 +14507,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13947,7 +14517,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -13959,7 +14529,7 @@ def register_Ns3EnumValue_methods(root_module, cls): return def register_Ns3EpcEnbApplication_methods(root_module, cls): - ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::EpcEnbApplication const & arg0) [copy constructor] + ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::EpcEnbApplication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbApplication const &', 'arg0')]) ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpcEnbApplication(ns3::Ptr lteSocket, ns3::Ptr s1uSocket, ns3::Ipv4Address enbS1uAddress, ns3::Ipv4Address sgwS1uAddress, uint16_t cellId) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::Socket >', 'lteSocket'), param('ns3::Ptr< ns3::Socket >', 's1uSocket'), param('ns3::Ipv4Address', 'enbS1uAddress'), param('ns3::Ipv4Address', 'sgwS1uAddress'), param('uint16_t', 'cellId')]) @@ -14002,7 +14572,7 @@ def register_Ns3EpcEnbApplication_methods(root_module, cls): def register_Ns3EpcEnbApplicationEpsFlowId_t_methods(root_module, cls): cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('==') - ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t(ns3::EpcEnbApplication::EpsFlowId_t const & arg0) [copy constructor] + ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t(ns3::EpcEnbApplication::EpsFlowId_t const & arg0) [constructor] cls.add_constructor([param('ns3::EpcEnbApplication::EpsFlowId_t const &', 'arg0')]) ## epc-enb-application.h (module 'lte'): ns3::EpcEnbApplication::EpsFlowId_t::EpsFlowId_t() [constructor] cls.add_constructor([]) @@ -14015,7 +14585,7 @@ def register_Ns3EpcEnbApplicationEpsFlowId_t_methods(root_module, cls): return def register_Ns3EpcHelper_methods(root_module, cls): - ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper(ns3::EpcHelper const & arg0) [copy constructor] + ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper(ns3::EpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EpcHelper const &', 'arg0')]) ## epc-helper.h (module 'lte'): ns3::EpcHelper::EpcHelper() [constructor] cls.add_constructor([]) @@ -14067,7 +14637,7 @@ def register_Ns3EpcHelper_methods(root_module, cls): return def register_Ns3EpcMme_methods(root_module, cls): - ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme(ns3::EpcMme const & arg0) [copy constructor] + ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme(ns3::EpcMme const & arg0) [constructor] cls.add_constructor([param('ns3::EpcMme const &', 'arg0')]) ## epc-mme.h (module 'lte'): ns3::EpcMme::EpcMme() [constructor] cls.add_constructor([]) @@ -14108,7 +14678,7 @@ def register_Ns3EpcMme_methods(root_module, cls): return def register_Ns3EpcSgwPgwApplication_methods(root_module, cls): - ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::EpcSgwPgwApplication const & arg0) [copy constructor] + ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::EpcSgwPgwApplication const & arg0) [constructor] cls.add_constructor([param('ns3::EpcSgwPgwApplication const &', 'arg0')]) ## epc-sgw-pgw-application.h (module 'lte'): ns3::EpcSgwPgwApplication::EpcSgwPgwApplication(ns3::Ptr const tunDevice, ns3::Ptr const s1uSocket) [constructor] cls.add_constructor([param('ns3::Ptr< ns3::VirtualNetDevice > const', 'tunDevice'), param('ns3::Ptr< ns3::Socket > const', 's1uSocket')]) @@ -14161,7 +14731,7 @@ def register_Ns3EpcSgwPgwApplication_methods(root_module, cls): return def register_Ns3EpcTft_methods(root_module, cls): - ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft(ns3::EpcTft const & arg0) [copy constructor] + ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft(ns3::EpcTft const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTft const &', 'arg0')]) ## epc-tft.h (module 'lte'): ns3::EpcTft::EpcTft() [constructor] cls.add_constructor([]) @@ -14181,7 +14751,7 @@ def register_Ns3EpcTft_methods(root_module, cls): return def register_Ns3EpcTftPacketFilter_methods(root_module, cls): - ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter(ns3::EpcTft::PacketFilter const & arg0) [copy constructor] + ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter(ns3::EpcTft::PacketFilter const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTft::PacketFilter const &', 'arg0')]) ## epc-tft.h (module 'lte'): ns3::EpcTft::PacketFilter::PacketFilter() [constructor] cls.add_constructor([]) @@ -14216,7 +14786,7 @@ def register_Ns3EpcTftPacketFilter_methods(root_module, cls): return def register_Ns3EpcTftClassifier_methods(root_module, cls): - ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier(ns3::EpcTftClassifier const & arg0) [copy constructor] + ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier(ns3::EpcTftClassifier const & arg0) [constructor] cls.add_constructor([param('ns3::EpcTftClassifier const &', 'arg0')]) ## epc-tft-classifier.h (module 'lte'): ns3::EpcTftClassifier::EpcTftClassifier() [constructor] cls.add_constructor([]) @@ -14235,7 +14805,7 @@ def register_Ns3EpcTftClassifier_methods(root_module, cls): return def register_Ns3EpcUeNas_methods(root_module, cls): - ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas(ns3::EpcUeNas const & arg0) [copy constructor] + ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas(ns3::EpcUeNas const & arg0) [constructor] cls.add_constructor([param('ns3::EpcUeNas const &', 'arg0')]) ## epc-ue-nas.h (module 'lte'): ns3::EpcUeNas::EpcUeNas() [constructor] cls.add_constructor([]) @@ -14310,7 +14880,7 @@ def register_Ns3EpcUeNas_methods(root_module, cls): return def register_Ns3EpcX2_methods(root_module, cls): - ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2(ns3::EpcX2 const & arg0) [copy constructor] + ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2(ns3::EpcX2 const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2 const &', 'arg0')]) ## epc-x2.h (module 'lte'): ns3::EpcX2::EpcX2() [constructor] cls.add_constructor([]) @@ -14387,7 +14957,7 @@ def register_Ns3EpcX2_methods(root_module, cls): return def register_Ns3EpcX2HandoverPreparationFailureHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader(ns3::EpcX2HandoverPreparationFailureHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader(ns3::EpcX2HandoverPreparationFailureHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverPreparationFailureHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverPreparationFailureHeader::EpcX2HandoverPreparationFailureHeader() [constructor] cls.add_constructor([]) @@ -14461,7 +15031,7 @@ def register_Ns3EpcX2HandoverPreparationFailureHeader_methods(root_module, cls): return def register_Ns3EpcX2HandoverRequestAckHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader(ns3::EpcX2HandoverRequestAckHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader(ns3::EpcX2HandoverRequestAckHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverRequestAckHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestAckHeader::EpcX2HandoverRequestAckHeader() [constructor] cls.add_constructor([]) @@ -14544,7 +15114,7 @@ def register_Ns3EpcX2HandoverRequestAckHeader_methods(root_module, cls): return def register_Ns3EpcX2HandoverRequestHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader(ns3::EpcX2HandoverRequestHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader(ns3::EpcX2HandoverRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2HandoverRequestHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2HandoverRequestHeader::EpcX2HandoverRequestHeader() [constructor] cls.add_constructor([]) @@ -14654,7 +15224,7 @@ def register_Ns3EpcX2HandoverRequestHeader_methods(root_module, cls): return def register_Ns3EpcX2Header_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header(ns3::EpcX2Header const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header(ns3::EpcX2Header const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2Header const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2Header::EpcX2Header() [constructor] cls.add_constructor([]) @@ -14717,7 +15287,7 @@ def register_Ns3EpcX2Header_methods(root_module, cls): return def register_Ns3EpcX2LoadInformationHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader(ns3::EpcX2LoadInformationHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader(ns3::EpcX2LoadInformationHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2LoadInformationHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2LoadInformationHeader::EpcX2LoadInformationHeader() [constructor] cls.add_constructor([]) @@ -14773,7 +15343,7 @@ def register_Ns3EpcX2LoadInformationHeader_methods(root_module, cls): return def register_Ns3EpcX2ResourceStatusUpdateHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader(ns3::EpcX2ResourceStatusUpdateHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader(ns3::EpcX2ResourceStatusUpdateHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2ResourceStatusUpdateHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2ResourceStatusUpdateHeader::EpcX2ResourceStatusUpdateHeader() [constructor] cls.add_constructor([]) @@ -14847,7 +15417,7 @@ def register_Ns3EpcX2ResourceStatusUpdateHeader_methods(root_module, cls): return def register_Ns3EpcX2SnStatusTransferHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader(ns3::EpcX2SnStatusTransferHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader(ns3::EpcX2SnStatusTransferHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2SnStatusTransferHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2SnStatusTransferHeader::EpcX2SnStatusTransferHeader() [constructor] cls.add_constructor([]) @@ -14921,7 +15491,7 @@ def register_Ns3EpcX2SnStatusTransferHeader_methods(root_module, cls): return def register_Ns3EpcX2UeContextReleaseHeader_methods(root_module, cls): - ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader(ns3::EpcX2UeContextReleaseHeader const & arg0) [copy constructor] + ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader(ns3::EpcX2UeContextReleaseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::EpcX2UeContextReleaseHeader const &', 'arg0')]) ## epc-x2-header.h (module 'lte'): ns3::EpcX2UeContextReleaseHeader::EpcX2UeContextReleaseHeader() [constructor] cls.add_constructor([]) @@ -15024,7 +15594,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -15086,7 +15656,7 @@ def register_Ns3ExponentialRandomVariable_methods(root_module, cls): return def register_Ns3FfMacScheduler_methods(root_module, cls): - ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler(ns3::FfMacScheduler const & arg0) [copy constructor] + ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler(ns3::FfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FfMacScheduler const &', 'arg0')]) ## ff-mac-scheduler.h (module 'lte'): ns3::FfMacScheduler::FfMacScheduler() [constructor] cls.add_constructor([]) @@ -15172,7 +15742,7 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3GtpuHeader_methods(root_module, cls): cls.add_binary_comparison_operator('==') - ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader(ns3::GtpuHeader const & arg0) [copy constructor] + ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader(ns3::GtpuHeader const & arg0) [constructor] cls.add_constructor([param('ns3::GtpuHeader const &', 'arg0')]) ## epc-gtpu-header.h (module 'lte'): ns3::GtpuHeader::GtpuHeader() [constructor] cls.add_constructor([]) @@ -15261,65 +15831,65 @@ def register_Ns3GtpuHeader_methods(root_module, cls): 'void', [param('ns3::Buffer::Iterator', 'start')], is_const=True, is_virtual=True) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetExtensionHeaderFlag(bool m_extensionHeaderFlag) [member function] + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetExtensionHeaderFlag(bool extensionHeaderFlag) [member function] cls.add_method('SetExtensionHeaderFlag', 'void', - [param('bool', 'm_extensionHeaderFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetLength(uint16_t m_length) [member function] + [param('bool', 'extensionHeaderFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetLength(uint16_t length) [member function] cls.add_method('SetLength', 'void', - [param('uint16_t', 'm_length')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetMessageType(uint8_t m_messageType) [member function] + [param('uint16_t', 'length')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetMessageType(uint8_t messageType) [member function] cls.add_method('SetMessageType', 'void', - [param('uint8_t', 'm_messageType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumber(uint8_t m_nPduNumber) [member function] + [param('uint8_t', 'messageType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumber(uint8_t nPduNumber) [member function] cls.add_method('SetNPduNumber', 'void', - [param('uint8_t', 'm_nPduNumber')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumberFlag(bool m_nPduNumberFlag) [member function] + [param('uint8_t', 'nPduNumber')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNPduNumberFlag(bool nPduNumberFlag) [member function] cls.add_method('SetNPduNumberFlag', 'void', - [param('bool', 'm_nPduNumberFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNextExtensionType(uint8_t m_nextExtensionType) [member function] + [param('bool', 'nPduNumberFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetNextExtensionType(uint8_t nextExtensionType) [member function] cls.add_method('SetNextExtensionType', 'void', - [param('uint8_t', 'm_nextExtensionType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetProtocolType(bool m_protocolType) [member function] + [param('uint8_t', 'nextExtensionType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetProtocolType(bool protocolType) [member function] cls.add_method('SetProtocolType', 'void', - [param('bool', 'm_protocolType')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumber(uint16_t m_sequenceNumber) [member function] + [param('bool', 'protocolType')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumber(uint16_t sequenceNumber) [member function] cls.add_method('SetSequenceNumber', 'void', - [param('uint16_t', 'm_sequenceNumber')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumberFlag(bool m_sequenceNumberFlag) [member function] + [param('uint16_t', 'sequenceNumber')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetSequenceNumberFlag(bool sequenceNumberFlag) [member function] cls.add_method('SetSequenceNumberFlag', 'void', - [param('bool', 'm_sequenceNumberFlag')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetTeid(uint32_t m_teid) [member function] + [param('bool', 'sequenceNumberFlag')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetTeid(uint32_t teid) [member function] cls.add_method('SetTeid', 'void', - [param('uint32_t', 'm_teid')]) - ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetVersion(uint8_t m_version) [member function] + [param('uint32_t', 'teid')]) + ## epc-gtpu-header.h (module 'lte'): void ns3::GtpuHeader::SetVersion(uint8_t version) [member function] cls.add_method('SetVersion', 'void', - [param('uint8_t', 'm_version')]) + [param('uint8_t', 'version')]) return def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15329,7 +15899,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15341,7 +15911,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): return def register_Ns3Ipv4_methods(root_module, cls): - ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [copy constructor] + ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4(ns3::Ipv4 const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4 const &', 'arg0')]) ## ipv4.h (module 'internet'): ns3::Ipv4::Ipv4() [constructor] cls.add_constructor([]) @@ -15547,23 +16117,23 @@ def register_Ns3Ipv4_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15573,7 +16143,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15587,23 +16157,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15613,7 +16183,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15625,7 +16195,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): return def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): - ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & arg0) [copy constructor] + ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute(ns3::Ipv4MulticastRoute const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MulticastRoute const &', 'arg0')]) ## ipv4-route.h (module 'internet'): ns3::Ipv4MulticastRoute::Ipv4MulticastRoute() [constructor] cls.add_constructor([]) @@ -15639,7 +16209,7 @@ def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-route.h (module 'internet'): std::map, std::allocator > > ns3::Ipv4MulticastRoute::GetOutputTtlMap() const [member function] + ## ipv4-route.h (module 'internet'): std::map, std::allocator > > ns3::Ipv4MulticastRoute::GetOutputTtlMap() const [member function] cls.add_method('GetOutputTtlMap', 'std::map< unsigned int, unsigned int >', [], @@ -15673,7 +16243,7 @@ def register_Ns3Ipv4MulticastRoute_methods(root_module, cls): def register_Ns3Ipv4Route_methods(root_module, cls): cls.add_output_stream_operator() - ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & arg0) [copy constructor] + ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route(ns3::Ipv4Route const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Route const &', 'arg0')]) ## ipv4-route.h (module 'internet'): ns3::Ipv4Route::Ipv4Route() [constructor] cls.add_constructor([]) @@ -15718,23 +16288,23 @@ def register_Ns3Ipv4Route_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15744,7 +16314,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15758,23 +16328,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15784,7 +16354,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -15834,7 +16404,7 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): return def register_Ns3LteAmc_methods(root_module, cls): - ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc(ns3::LteAmc const & arg0) [copy constructor] + ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc(ns3::LteAmc const & arg0) [constructor] cls.add_constructor([param('ns3::LteAmc const &', 'arg0')]) ## lte-amc.h (module 'lte'): ns3::LteAmc::LteAmc() [constructor] cls.add_constructor([]) @@ -15866,7 +16436,7 @@ def register_Ns3LteAmc_methods(root_module, cls): return def register_Ns3LteAnr_methods(root_module, cls): - ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(ns3::LteAnr const & arg0) [copy constructor] + ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(ns3::LteAnr const & arg0) [constructor] cls.add_constructor([param('ns3::LteAnr const &', 'arg0')]) ## lte-anr.h (module 'lte'): ns3::LteAnr::LteAnr(uint16_t servingCellId) [constructor] cls.add_constructor([param('uint16_t', 'servingCellId')]) @@ -15906,14 +16476,14 @@ def register_Ns3LteAnr_methods(root_module, cls): return def register_Ns3LteChunkProcessor_methods(root_module, cls): - ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor(ns3::LteChunkProcessor const & arg0) [copy constructor] + ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor(ns3::LteChunkProcessor const & arg0) [constructor] cls.add_constructor([param('ns3::LteChunkProcessor const &', 'arg0')]) ## lte-chunk-processor.h (module 'lte'): ns3::LteChunkProcessor::LteChunkProcessor() [constructor] cls.add_constructor([]) ## lte-chunk-processor.h (module 'lte'): void ns3::LteChunkProcessor::AddCallback(ns3::LteChunkProcessorCallback c) [member function] cls.add_method('AddCallback', 'void', - [param('ns3::LteChunkProcessorCallback', 'c')], + [param('ns3::Callback< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')], is_virtual=True) ## lte-chunk-processor.h (module 'lte'): void ns3::LteChunkProcessor::End() [member function] cls.add_method('End', @@ -15933,7 +16503,7 @@ def register_Ns3LteChunkProcessor_methods(root_module, cls): return def register_Ns3LteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage(ns3::LteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage(ns3::LteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::LteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::LteControlMessage::LteControlMessage() [constructor] cls.add_constructor([]) @@ -15948,7 +16518,7 @@ def register_Ns3LteControlMessage_methods(root_module, cls): return def register_Ns3LteEnbComponentCarrierManager_methods(root_module, cls): - ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager(ns3::LteEnbComponentCarrierManager const & arg0) [copy constructor] + ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager(ns3::LteEnbComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbComponentCarrierManager const &', 'arg0')]) ## lte-enb-component-carrier-manager.h (module 'lte'): ns3::LteEnbComponentCarrierManager::LteEnbComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -16010,7 +16580,7 @@ def register_Ns3LteEnbComponentCarrierManager_methods(root_module, cls): return def register_Ns3LteEnbMac_methods(root_module, cls): - ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac(ns3::LteEnbMac const & arg0) [copy constructor] + ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac(ns3::LteEnbMac const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbMac const &', 'arg0')]) ## lte-enb-mac.h (module 'lte'): ns3::LteEnbMac::LteEnbMac() [constructor] cls.add_constructor([]) @@ -16083,7 +16653,7 @@ def register_Ns3LteEnbMac_methods(root_module, cls): return def register_Ns3LteEnbRrc_methods(root_module, cls): - ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc(ns3::LteEnbRrc const & arg0) [copy constructor] + ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc(ns3::LteEnbRrc const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrc const &', 'arg0')]) ## lte-enb-rrc.h (module 'lte'): ns3::LteEnbRrc::LteEnbRrc() [constructor] cls.add_constructor([]) @@ -16095,14 +16665,22 @@ def register_Ns3LteEnbRrc_methods(root_module, cls): cls.add_method('AddX2Neighbour', 'void', [param('uint16_t', 'cellId')]) - ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCarriers(std::map, std::allocator > > ccPhyConf, uint16_t numberOfCarriers) [member function] + ## lte-enb-rrc.h (module 'lte'): uint8_t ns3::LteEnbRrc::CellToComponentCarrierId(uint16_t cellId) [member function] + cls.add_method('CellToComponentCarrierId', + 'uint8_t', + [param('uint16_t', 'cellId')]) + ## lte-enb-rrc.h (module 'lte'): uint16_t ns3::LteEnbRrc::ComponentCarrierToCellId(uint8_t componentCarrierId) [member function] + cls.add_method('ComponentCarrierToCellId', + 'uint16_t', + [param('uint8_t', 'componentCarrierId')]) + ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCarriers(std::map, std::less, std::allocator > > > ccPhyConf) [member function] cls.add_method('ConfigureCarriers', 'void', - [param('std::map< unsigned char, ns3::ComponentCarrier >', 'ccPhyConf'), param('uint16_t', 'numberOfCarriers')]) - ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCell(uint16_t cellId) [member function] + [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccPhyConf')]) + ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConfigureCell(std::map, std::less, std::allocator > > > ccPhyConf) [member function] cls.add_method('ConfigureCell', 'void', - [param('uint16_t', 'cellId')]) + [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccPhyConf')]) ## lte-enb-rrc.h (module 'lte'): void ns3::LteEnbRrc::ConnectionRejectedTimeout(uint16_t rnti) [member function] cls.add_method('ConnectionRejectedTimeout', 'void', @@ -16286,7 +16864,7 @@ def register_Ns3LteEnbRrc_methods(root_module, cls): return def register_Ns3LteEnbRrcProtocolIdeal_methods(root_module, cls): - ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal(ns3::LteEnbRrcProtocolIdeal const & arg0) [copy constructor] + ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal(ns3::LteEnbRrcProtocolIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolIdeal const &', 'arg0')]) ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteEnbRrcProtocolIdeal::LteEnbRrcProtocolIdeal() [constructor] cls.add_constructor([]) @@ -16323,7 +16901,7 @@ def register_Ns3LteEnbRrcProtocolIdeal_methods(root_module, cls): return def register_Ns3LteEnbRrcProtocolReal_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal(ns3::LteEnbRrcProtocolReal const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal(ns3::LteEnbRrcProtocolReal const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbRrcProtocolReal const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteEnbRrcProtocolReal::LteEnbRrcProtocolReal() [constructor] cls.add_constructor([]) @@ -16360,7 +16938,7 @@ def register_Ns3LteEnbRrcProtocolReal_methods(root_module, cls): return def register_Ns3LteFfrAlgorithm_methods(root_module, cls): - ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm(ns3::LteFfrAlgorithm const & arg0) [copy constructor] + ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm(ns3::LteFfrAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrAlgorithm const &', 'arg0')]) ## lte-ffr-algorithm.h (module 'lte'): ns3::LteFfrAlgorithm::LteFfrAlgorithm() [constructor] cls.add_constructor([]) @@ -16471,7 +17049,7 @@ def register_Ns3LteFfrAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], is_pure_virtual=True, visibility='protected', is_virtual=True) - ## lte-ffr-algorithm.h (module 'lte'): void ns3::LteFfrAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-algorithm.h (module 'lte'): void ns3::LteFfrAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16499,7 +17077,7 @@ def register_Ns3LteFfrAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): - ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm(ns3::LteFfrDistributedAlgorithm const & arg0) [copy constructor] + ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm(ns3::LteFfrDistributedAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrDistributedAlgorithm const &', 'arg0')]) ## lte-ffr-distributed-algorithm.h (module 'lte'): ns3::LteFfrDistributedAlgorithm::LteFfrDistributedAlgorithm() [constructor] cls.add_constructor([]) @@ -16588,7 +17166,7 @@ def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-distributed-algorithm.h (module 'lte'): void ns3::LteFfrDistributedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-distributed-algorithm.h (module 'lte'): void ns3::LteFfrDistributedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16601,7 +17179,7 @@ def register_Ns3LteFfrDistributedAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): - ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm(ns3::LteFfrEnhancedAlgorithm const & arg0) [copy constructor] + ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm(ns3::LteFfrEnhancedAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrEnhancedAlgorithm const &', 'arg0')]) ## lte-ffr-enhanced-algorithm.h (module 'lte'): ns3::LteFfrEnhancedAlgorithm::LteFfrEnhancedAlgorithm() [constructor] cls.add_constructor([]) @@ -16690,7 +17268,7 @@ def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-enhanced-algorithm.h (module 'lte'): void ns3::LteFfrEnhancedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-enhanced-algorithm.h (module 'lte'): void ns3::LteFfrEnhancedAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16703,7 +17281,7 @@ def register_Ns3LteFfrEnhancedAlgorithm_methods(root_module, cls): return def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): - ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm(ns3::LteFfrSoftAlgorithm const & arg0) [copy constructor] + ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm(ns3::LteFfrSoftAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFfrSoftAlgorithm const &', 'arg0')]) ## lte-ffr-soft-algorithm.h (module 'lte'): ns3::LteFfrSoftAlgorithm::LteFfrSoftAlgorithm() [constructor] cls.add_constructor([]) @@ -16792,7 +17370,7 @@ def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-ffr-soft-algorithm.h (module 'lte'): void ns3::LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-ffr-soft-algorithm.h (module 'lte'): void ns3::LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16805,7 +17383,7 @@ def register_Ns3LteFfrSoftAlgorithm_methods(root_module, cls): return def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): - ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm(ns3::LteFrHardAlgorithm const & arg0) [copy constructor] + ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm(ns3::LteFrHardAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrHardAlgorithm const &', 'arg0')]) ## lte-fr-hard-algorithm.h (module 'lte'): ns3::LteFrHardAlgorithm::LteFrHardAlgorithm() [constructor] cls.add_constructor([]) @@ -16894,7 +17472,7 @@ def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-hard-algorithm.h (module 'lte'): void ns3::LteFrHardAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-hard-algorithm.h (module 'lte'): void ns3::LteFrHardAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -16907,7 +17485,7 @@ def register_Ns3LteFrHardAlgorithm_methods(root_module, cls): return def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): - ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm(ns3::LteFrNoOpAlgorithm const & arg0) [copy constructor] + ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm(ns3::LteFrNoOpAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrNoOpAlgorithm const &', 'arg0')]) ## lte-fr-no-op-algorithm.h (module 'lte'): ns3::LteFrNoOpAlgorithm::LteFrNoOpAlgorithm() [constructor] cls.add_constructor([]) @@ -16996,7 +17574,7 @@ def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-no-op-algorithm.h (module 'lte'): void ns3::LteFrNoOpAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-no-op-algorithm.h (module 'lte'): void ns3::LteFrNoOpAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17009,7 +17587,7 @@ def register_Ns3LteFrNoOpAlgorithm_methods(root_module, cls): return def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): - ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm(ns3::LteFrSoftAlgorithm const & arg0) [copy constructor] + ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm(ns3::LteFrSoftAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrSoftAlgorithm const &', 'arg0')]) ## lte-fr-soft-algorithm.h (module 'lte'): ns3::LteFrSoftAlgorithm::LteFrSoftAlgorithm() [constructor] cls.add_constructor([]) @@ -17098,7 +17676,7 @@ def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-soft-algorithm.h (module 'lte'): void ns3::LteFrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-soft-algorithm.h (module 'lte'): void ns3::LteFrSoftAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17111,7 +17689,7 @@ def register_Ns3LteFrSoftAlgorithm_methods(root_module, cls): return def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): - ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm(ns3::LteFrStrictAlgorithm const & arg0) [copy constructor] + ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm(ns3::LteFrStrictAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteFrStrictAlgorithm const &', 'arg0')]) ## lte-fr-strict-algorithm.h (module 'lte'): ns3::LteFrStrictAlgorithm::LteFrStrictAlgorithm() [constructor] cls.add_constructor([]) @@ -17200,7 +17778,7 @@ def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): 'void', [param('ns3::FfMacSchedSapProvider::SchedUlCqiInfoReqParameters const &', 'params')], visibility='protected', is_virtual=True) - ## lte-fr-strict-algorithm.h (module 'lte'): void ns3::LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] + ## lte-fr-strict-algorithm.h (module 'lte'): void ns3::LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map >, std::less, std::allocator > > > > ulCqiMap) [member function] cls.add_method('DoReportUlCqiInfo', 'void', [param('std::map< unsigned short, std::vector< double > >', 'ulCqiMap')], @@ -17213,7 +17791,7 @@ def register_Ns3LteFrStrictAlgorithm_methods(root_module, cls): return def register_Ns3LteHandoverAlgorithm_methods(root_module, cls): - ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm(ns3::LteHandoverAlgorithm const & arg0) [copy constructor] + ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm(ns3::LteHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::LteHandoverAlgorithm const &', 'arg0')]) ## lte-handover-algorithm.h (module 'lte'): ns3::LteHandoverAlgorithm::LteHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -17245,7 +17823,7 @@ def register_Ns3LteHandoverAlgorithm_methods(root_module, cls): return def register_Ns3LteHarqPhy_methods(root_module, cls): - ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy(ns3::LteHarqPhy const & arg0) [copy constructor] + ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy(ns3::LteHarqPhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteHarqPhy const &', 'arg0')]) ## lte-harq-phy.h (module 'lte'): ns3::LteHarqPhy::LteHarqPhy() [constructor] cls.add_constructor([]) @@ -17288,7 +17866,7 @@ def register_Ns3LteHarqPhy_methods(root_module, cls): return def register_Ns3LteHelper_methods(root_module, cls): - ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper(ns3::LteHelper const & arg0) [copy constructor] + ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper(ns3::LteHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteHelper const &', 'arg0')]) ## lte-helper.h (module 'lte'): ns3::LteHelper::LteHelper() [constructor] cls.add_constructor([]) @@ -17414,11 +17992,6 @@ def register_Ns3LteHelper_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumChannel >', [], is_const=True) - ## lte-helper.h (module 'lte'): ns3::Ptr ns3::LteHelper::GetDownlinkSpectrumChannel(uint8_t carrierId) const [member function] - cls.add_method('GetDownlinkSpectrumChannel', - 'ns3::Ptr< ns3::SpectrumChannel >', - [param('uint8_t', 'carrierId')], - is_const=True) ## lte-helper.h (module 'lte'): std::string ns3::LteHelper::GetEnbComponentCarrierManagerType() const [member function] cls.add_method('GetEnbComponentCarrierManagerType', 'std::string', @@ -17466,6 +18039,10 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('HandoverRequest', 'void', [param('ns3::Time', 'hoTime'), param('ns3::Ptr< ns3::NetDevice >', 'ueDev'), param('ns3::Ptr< ns3::NetDevice >', 'sourceEnbDev'), param('ns3::Ptr< ns3::NetDevice >', 'targetEnbDev')]) + ## lte-helper.h (module 'lte'): void ns3::LteHelper::HandoverRequest(ns3::Time hoTime, ns3::Ptr ueDev, ns3::Ptr sourceEnbDev, uint16_t targetCellId) [member function] + cls.add_method('HandoverRequest', + 'void', + [param('ns3::Time', 'hoTime'), param('ns3::Ptr< ns3::NetDevice >', 'ueDev'), param('ns3::Ptr< ns3::NetDevice >', 'sourceEnbDev'), param('uint16_t', 'targetCellId')]) ## lte-helper.h (module 'lte'): ns3::NetDeviceContainer ns3::LteHelper::InstallEnbDevice(ns3::NodeContainer c) [member function] cls.add_method('InstallEnbDevice', 'ns3::NetDeviceContainer', @@ -17474,7 +18051,7 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('InstallUeDevice', 'ns3::NetDeviceContainer', [param('ns3::NodeContainer', 'c')]) - ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetCcPhyParams(std::map, std::allocator > > ccmap) [member function] + ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetCcPhyParams(std::map, std::allocator > > ccmap) [member function] cls.add_method('SetCcPhyParams', 'void', [param('std::map< unsigned char, ns3::ComponentCarrier >', 'ccmap')]) @@ -17530,10 +18107,10 @@ def register_Ns3LteHelper_methods(root_module, cls): cls.add_method('SetPathlossModelAttribute', 'void', [param('std::string', 'n'), param('ns3::AttributeValue const &', 'v')]) - ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetPathlossModelType(std::string type) [member function] + ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetPathlossModelType(ns3::TypeId type) [member function] cls.add_method('SetPathlossModelType', 'void', - [param('std::string', 'type')]) + [param('ns3::TypeId', 'type')]) ## lte-helper.h (module 'lte'): void ns3::LteHelper::SetSchedulerAttribute(std::string n, ns3::AttributeValue const & v) [member function] cls.add_method('SetSchedulerAttribute', 'void', @@ -17578,7 +18155,7 @@ def register_Ns3LteHelper_methods(root_module, cls): return def register_Ns3LteHexGridEnbTopologyHelper_methods(root_module, cls): - ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper(ns3::LteHexGridEnbTopologyHelper const & arg0) [copy constructor] + ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper(ns3::LteHexGridEnbTopologyHelper const & arg0) [constructor] cls.add_constructor([param('ns3::LteHexGridEnbTopologyHelper const &', 'arg0')]) ## lte-hex-grid-enb-topology-helper.h (module 'lte'): ns3::LteHexGridEnbTopologyHelper::LteHexGridEnbTopologyHelper() [constructor] cls.add_constructor([]) @@ -17603,7 +18180,7 @@ def register_Ns3LteHexGridEnbTopologyHelper_methods(root_module, cls): return def register_Ns3LteInterference_methods(root_module, cls): - ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference(ns3::LteInterference const & arg0) [copy constructor] + ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference(ns3::LteInterference const & arg0) [constructor] cls.add_constructor([param('ns3::LteInterference const &', 'arg0')]) ## lte-interference.h (module 'lte'): ns3::LteInterference::LteInterference() [constructor] cls.add_constructor([]) @@ -17615,7 +18192,7 @@ def register_Ns3LteInterference_methods(root_module, cls): cls.add_method('AddRsPowerChunkProcessor', 'void', [param('ns3::Ptr< ns3::LteChunkProcessor >', 'p')]) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::AddSignal(ns3::Ptr spd, ns3::Time const duration) [member function] cls.add_method('AddSignal', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'spd'), param('ns3::Time const', 'duration')]) @@ -17637,18 +18214,18 @@ def register_Ns3LteInterference_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] cls.add_method('SetNoisePowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) - ## lte-interference.h (module 'lte'): void ns3::LteInterference::StartRx(ns3::Ptr rxPsd) [member function] + ## lte-interference.h (module 'lte'): void ns3::LteInterference::StartRx(ns3::Ptr rxPsd) [member function] cls.add_method('StartRx', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'rxPsd')]) return def register_Ns3LtePdcp_methods(root_module, cls): - ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp(ns3::LtePdcp const & arg0) [copy constructor] + ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp(ns3::LtePdcp const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcp const &', 'arg0')]) ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::LtePdcp() [constructor] cls.add_constructor([]) @@ -17711,7 +18288,7 @@ def register_Ns3LtePdcp_methods(root_module, cls): def register_Ns3LtePdcpStatus_methods(root_module, cls): ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status() [constructor] cls.add_constructor([]) - ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status(ns3::LtePdcp::Status const & arg0) [copy constructor] + ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::Status(ns3::LtePdcp::Status const & arg0) [constructor] cls.add_constructor([param('ns3::LtePdcp::Status const &', 'arg0')]) ## lte-pdcp.h (module 'lte'): ns3::LtePdcp::Status::rxSn [variable] cls.add_instance_attribute('rxSn', 'uint16_t', is_const=False) @@ -17720,7 +18297,7 @@ def register_Ns3LtePdcpStatus_methods(root_module, cls): return def register_Ns3LtePhy_methods(root_module, cls): - ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy(ns3::LtePhy const & arg0) [copy constructor] + ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy(ns3::LtePhy const & arg0) [constructor] cls.add_constructor([param('ns3::LtePhy const &', 'arg0')]) ## lte-phy.h (module 'lte'): ns3::LtePhy::LtePhy() [constructor] cls.add_constructor([]) @@ -17846,7 +18423,7 @@ def register_Ns3LtePhy_methods(root_module, cls): return def register_Ns3LteRadioBearerInfo_methods(root_module, cls): - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo(ns3::LteRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo(ns3::LteRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): ns3::LteRadioBearerInfo::LteRadioBearerInfo() [constructor] cls.add_constructor([]) @@ -17862,7 +18439,7 @@ def register_Ns3LteRadioBearerInfo_methods(root_module, cls): return def register_Ns3LteRlc_methods(root_module, cls): - ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc(ns3::LteRlc const & arg0) [copy constructor] + ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc(ns3::LteRlc const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlc const &', 'arg0')]) ## lte-rlc.h (module 'lte'): ns3::LteRlc::LteRlc() [constructor] cls.add_constructor([]) @@ -17923,7 +18500,7 @@ def register_Ns3LteRlc_methods(root_module, cls): return def register_Ns3LteRlcAm_methods(root_module, cls): - ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm(ns3::LteRlcAm const & arg0) [copy constructor] + ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm(ns3::LteRlcAm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcAm const &', 'arg0')]) ## lte-rlc-am.h (module 'lte'): ns3::LteRlcAm::LteRlcAm() [constructor] cls.add_constructor([]) @@ -17960,7 +18537,7 @@ def register_Ns3LteRlcAm_methods(root_module, cls): return def register_Ns3LteRlcSm_methods(root_module, cls): - ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm(ns3::LteRlcSm const & arg0) [copy constructor] + ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm(ns3::LteRlcSm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcSm const &', 'arg0')]) ## lte-rlc.h (module 'lte'): ns3::LteRlcSm::LteRlcSm() [constructor] cls.add_constructor([]) @@ -18002,7 +18579,7 @@ def register_Ns3LteRlcSm_methods(root_module, cls): return def register_Ns3LteRlcTm_methods(root_module, cls): - ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm(ns3::LteRlcTm const & arg0) [copy constructor] + ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm(ns3::LteRlcTm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcTm const &', 'arg0')]) ## lte-rlc-tm.h (module 'lte'): ns3::LteRlcTm::LteRlcTm() [constructor] cls.add_constructor([]) @@ -18039,7 +18616,7 @@ def register_Ns3LteRlcTm_methods(root_module, cls): return def register_Ns3LteRlcUm_methods(root_module, cls): - ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm(ns3::LteRlcUm const & arg0) [copy constructor] + ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm(ns3::LteRlcUm const & arg0) [constructor] cls.add_constructor([param('ns3::LteRlcUm const &', 'arg0')]) ## lte-rlc-um.h (module 'lte'): ns3::LteRlcUm::LteRlcUm() [constructor] cls.add_constructor([]) @@ -18078,7 +18655,7 @@ def register_Ns3LteRlcUm_methods(root_module, cls): def register_Ns3LteSignalingRadioBearerInfo_methods(root_module, cls): ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo() [constructor] cls.add_constructor([]) - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo(ns3::LteSignalingRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteSignalingRadioBearerInfo::LteSignalingRadioBearerInfo(ns3::LteSignalingRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteSignalingRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): static ns3::TypeId ns3::LteSignalingRadioBearerInfo::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -18129,7 +18706,7 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): 'ns3::Ptr< ns3::NetDevice >', [], is_const=True, is_virtual=True) - ## lte-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::LteSpectrumPhy::GetRxSpectrumModel() const [member function] + ## lte-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::LteSpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -18164,7 +18741,7 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): cls.add_method('SetTxPowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue >', 'txPsd')]) - ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] + ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetNoisePowerSpectralDensity(ns3::Ptr noisePsd) [member function] cls.add_method('SetNoisePowerSpectralDensity', 'void', [param('ns3::Ptr< ns3::SpectrumValue const >', 'noisePsd')]) @@ -18191,35 +18768,35 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyTxEndCallback(ns3::LtePhyTxEndCallback c) [member function] cls.add_method('SetLtePhyTxEndCallback', 'void', - [param('ns3::LtePhyTxEndCallback', 'c')]) + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxDataEndErrorCallback(ns3::LtePhyRxDataEndErrorCallback c) [member function] cls.add_method('SetLtePhyRxDataEndErrorCallback', 'void', - [param('ns3::LtePhyRxDataEndErrorCallback', 'c')]) + [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxDataEndOkCallback(ns3::LtePhyRxDataEndOkCallback c) [member function] cls.add_method('SetLtePhyRxDataEndOkCallback', 'void', - [param('ns3::LtePhyRxDataEndOkCallback', 'c')]) + [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxCtrlEndOkCallback(ns3::LtePhyRxCtrlEndOkCallback c) [member function] cls.add_method('SetLtePhyRxCtrlEndOkCallback', 'void', - [param('ns3::LtePhyRxCtrlEndOkCallback', 'c')]) + [param('ns3::Callback< void, std::list< ns3::Ptr< ns3::LteControlMessage > >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxCtrlEndErrorCallback(ns3::LtePhyRxCtrlEndErrorCallback c) [member function] cls.add_method('SetLtePhyRxCtrlEndErrorCallback', 'void', - [param('ns3::LtePhyRxCtrlEndErrorCallback', 'c')]) + [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyRxPssCallback(ns3::LtePhyRxPssCallback c) [member function] cls.add_method('SetLtePhyRxPssCallback', 'void', - [param('ns3::LtePhyRxPssCallback', 'c')]) + [param('ns3::Callback< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyDlHarqFeedbackCallback(ns3::LtePhyDlHarqFeedbackCallback c) [member function] cls.add_method('SetLtePhyDlHarqFeedbackCallback', 'void', - [param('ns3::LtePhyDlHarqFeedbackCallback', 'c')]) + [param('ns3::Callback< void, ns3::DlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetLtePhyUlHarqFeedbackCallback(ns3::LtePhyUlHarqFeedbackCallback c) [member function] cls.add_method('SetLtePhyUlHarqFeedbackCallback', 'void', - [param('ns3::LtePhyUlHarqFeedbackCallback', 'c')]) + [param('ns3::Callback< void, ns3::UlInfoListElement_s, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'c')]) ## lte-spectrum-phy.h (module 'lte'): void ns3::LteSpectrumPhy::SetState(ns3::LteSpectrumPhy::State newState) [member function] cls.add_method('SetState', 'void', @@ -18279,71 +18856,71 @@ def register_Ns3LteSpectrumPhy_methods(root_module, cls): return def register_Ns3LteSpectrumSignalParameters_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters(ns3::LteSpectrumSignalParameters const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParameters const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParameters::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::LteSpectrumSignalParameters(ns3::LteSpectrumSignalParameters const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParameters const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParameters::packetBurst [variable] cls.add_instance_attribute('packetBurst', 'ns3::Ptr< ns3::PacketBurst >', is_const=False) return def register_Ns3LteSpectrumSignalParametersDataFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame(ns3::LteSpectrumSignalParametersDataFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersDataFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersDataFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::cellId [variable] - cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::ctrlMsgList [variable] - cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::LteSpectrumSignalParametersDataFrame(ns3::LteSpectrumSignalParametersDataFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersDataFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::packetBurst [variable] cls.add_instance_attribute('packetBurst', 'ns3::Ptr< ns3::PacketBurst >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::ctrlMsgList [variable] + cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDataFrame::cellId [variable] + cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) return def register_Ns3LteSpectrumSignalParametersDlCtrlFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame(ns3::LteSpectrumSignalParametersDlCtrlFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersDlCtrlFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersDlCtrlFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::cellId [variable] - cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::LteSpectrumSignalParametersDlCtrlFrame(ns3::LteSpectrumSignalParametersDlCtrlFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersDlCtrlFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::ctrlMsgList [variable] cls.add_instance_attribute('ctrlMsgList', 'std::list< ns3::Ptr< ns3::LteControlMessage > >', is_const=False) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::cellId [variable] + cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersDlCtrlFrame::pss [variable] cls.add_instance_attribute('pss', 'bool', is_const=False) return def register_Ns3LteSpectrumSignalParametersUlSrsFrame_methods(root_module, cls): - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame() [constructor] - cls.add_constructor([]) - ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame(ns3::LteSpectrumSignalParametersUlSrsFrame const & p) [copy constructor] - cls.add_constructor([param('ns3::LteSpectrumSignalParametersUlSrsFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::Ptr ns3::LteSpectrumSignalParametersUlSrsFrame::Copy() [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::SpectrumSignalParameters >', [], is_virtual=True) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame() [constructor] + cls.add_constructor([]) + ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::LteSpectrumSignalParametersUlSrsFrame(ns3::LteSpectrumSignalParametersUlSrsFrame const & p) [constructor] + cls.add_constructor([param('ns3::LteSpectrumSignalParametersUlSrsFrame const &', 'p')]) ## lte-spectrum-signal-parameters.h (module 'lte'): ns3::LteSpectrumSignalParametersUlSrsFrame::cellId [variable] cls.add_instance_attribute('cellId', 'uint16_t', is_const=False) return def register_Ns3LteStatsCalculator_methods(root_module, cls): - ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator(ns3::LteStatsCalculator const & arg0) [copy constructor] + ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator(ns3::LteStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::LteStatsCalculator const &', 'arg0')]) ## lte-stats-calculator.h (module 'lte'): ns3::LteStatsCalculator::LteStatsCalculator() [constructor] cls.add_constructor([]) @@ -18435,7 +19012,7 @@ def register_Ns3LteStatsCalculator_methods(root_module, cls): return def register_Ns3LteUeComponentCarrierManager_methods(root_module, cls): - ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager(ns3::LteUeComponentCarrierManager const & arg0) [copy constructor] + ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager(ns3::LteUeComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeComponentCarrierManager const &', 'arg0')]) ## lte-ue-component-carrier-manager.h (module 'lte'): ns3::LteUeComponentCarrierManager::LteUeComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -18475,7 +19052,7 @@ def register_Ns3LteUeComponentCarrierManager_methods(root_module, cls): return def register_Ns3LteUeMac_methods(root_module, cls): - ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac(ns3::LteUeMac const & arg0) [copy constructor] + ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac(ns3::LteUeMac const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeMac const &', 'arg0')]) ## lte-ue-mac.h (module 'lte'): ns3::LteUeMac::LteUeMac() [constructor] cls.add_constructor([]) @@ -18524,7 +19101,7 @@ def register_Ns3LteUeMac_methods(root_module, cls): return def register_Ns3LteUePhy_methods(root_module, cls): - ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy(ns3::LteUePhy const & arg0) [copy constructor] + ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy(ns3::LteUePhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePhy const &', 'arg0')]) ## lte-ue-phy.h (module 'lte'): ns3::LteUePhy::LteUePhy() [constructor] cls.add_constructor([]) @@ -18624,10 +19201,10 @@ def register_Ns3LteUePhy_methods(root_module, cls): cls.add_method('PhyPduReceived', 'void', [param('ns3::Ptr< ns3::Packet >', 'p')]) - ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteControlMessageList(std::list, std::allocator > > arg0) [member function] + ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteControlMessageList(std::list, std::allocator > > msgList) [member function] cls.add_method('ReceiveLteControlMessageList', 'void', - [param('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'arg0')], + [param('std::list< ns3::Ptr< ns3::LteControlMessage > >', 'msgList')], is_virtual=True) ## lte-ue-phy.h (module 'lte'): void ns3::LteUePhy::ReceiveLteDlHarqFeedback(ns3::DlInfoListElement_s mes) [member function] cls.add_method('ReceiveLteDlHarqFeedback', @@ -18708,7 +19285,7 @@ def register_Ns3LteUePhy_methods(root_module, cls): return def register_Ns3LteUePowerControl_methods(root_module, cls): - ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl(ns3::LteUePowerControl const & arg0) [copy constructor] + ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl(ns3::LteUePowerControl const & arg0) [constructor] cls.add_constructor([param('ns3::LteUePowerControl const &', 'arg0')]) ## lte-ue-power-control.h (module 'lte'): ns3::LteUePowerControl::LteUePowerControl() [constructor] cls.add_constructor([]) @@ -18798,7 +19375,7 @@ def register_Ns3LteUePowerControl_methods(root_module, cls): return def register_Ns3LteUeRrc_methods(root_module, cls): - ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc(ns3::LteUeRrc const & arg0) [copy constructor] + ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc(ns3::LteUeRrc const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrc const &', 'arg0')]) ## lte-ue-rrc.h (module 'lte'): ns3::LteUeRrc::LteUeRrc() [constructor] cls.add_constructor([]) @@ -18934,7 +19511,7 @@ def register_Ns3LteUeRrc_methods(root_module, cls): return def register_Ns3LteUeRrcProtocolIdeal_methods(root_module, cls): - ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal(ns3::LteUeRrcProtocolIdeal const & arg0) [copy constructor] + ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal(ns3::LteUeRrcProtocolIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcProtocolIdeal const &', 'arg0')]) ## lte-rrc-protocol-ideal.h (module 'lte'): ns3::LteUeRrcProtocolIdeal::LteUeRrcProtocolIdeal() [constructor] cls.add_constructor([]) @@ -18963,7 +19540,7 @@ def register_Ns3LteUeRrcProtocolIdeal_methods(root_module, cls): return def register_Ns3LteUeRrcProtocolReal_methods(root_module, cls): - ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal(ns3::LteUeRrcProtocolReal const & arg0) [copy constructor] + ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal(ns3::LteUeRrcProtocolReal const & arg0) [constructor] cls.add_constructor([param('ns3::LteUeRrcProtocolReal const &', 'arg0')]) ## lte-rrc-protocol-real.h (module 'lte'): ns3::LteUeRrcProtocolReal::LteUeRrcProtocolReal() [constructor] cls.add_constructor([]) @@ -18994,23 +19571,23 @@ def register_Ns3LteUeRrcProtocolReal_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19020,7 +19597,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19032,7 +19609,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): return def register_Ns3MacStatsCalculator_methods(root_module, cls): - ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator(ns3::MacStatsCalculator const & arg0) [copy constructor] + ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator(ns3::MacStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::MacStatsCalculator const &', 'arg0')]) ## mac-stats-calculator.h (module 'lte'): ns3::MacStatsCalculator::MacStatsCalculator() [constructor] cls.add_constructor([]) @@ -19078,7 +19655,7 @@ def register_Ns3MacStatsCalculator_methods(root_module, cls): return def register_Ns3MibLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage(ns3::MibLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage(ns3::MibLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::MibLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::MibLteControlMessage::MibLteControlMessage() [constructor] cls.add_constructor([]) @@ -19093,75 +19670,215 @@ def register_Ns3MibLteControlMessage_methods(root_module, cls): [param('ns3::LteRrcSap::MasterInformationBlock', 'mib')]) return -def register_Ns3MobilityModel_methods(root_module, cls): - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor] - cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] +def register_Ns3MinMaxAvgTotalCalculator__Unsigned_int_methods(root_module, cls): + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] + cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned int > const &', 'arg0')]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] cls.add_constructor([]) - ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::AssignStreams(int64_t stream) [member function] - cls.add_method('AssignStreams', - 'int64_t', - [param('int64_t', 'stream')]) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] - cls.add_method('GetDistanceFrom', - 'double', - [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], - is_const=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetPosition() const [member function] - cls.add_method('GetPosition', - 'ns3::Vector', - [], - is_const=True) - ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] - cls.add_method('GetRelativeSpeed', - 'double', - [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], - is_const=True) - ## mobility-model.h (module 'mobility'): static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function] + ## basic-data-calculators.h (module 'stats'): static ns3::TypeId ns3::MinMaxAvgTotalCalculator::GetTypeId() [member function] cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetVelocity() const [member function] - cls.add_method('GetVelocity', - 'ns3::Vector', - [], - is_const=True) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function] - cls.add_method('SetPosition', + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function] + cls.add_method('Output', 'void', - [param('ns3::Vector const &', 'position')]) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::NotifyCourseChange() const [member function] - cls.add_method('NotifyCourseChange', + [param('ns3::DataOutputCallback &', 'callback')], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Reset() [member function] + cls.add_method('Reset', + 'void', + []) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Update(unsigned int const i) [member function] + cls.add_method('Update', 'void', + [param('unsigned int const', 'i')]) + ## basic-data-calculators.h (module 'stats'): long int ns3::MinMaxAvgTotalCalculator::getCount() const [member function] + cls.add_method('getCount', + 'long int', [], - is_const=True, visibility='protected') - ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::DoAssignStreams(int64_t start) [member function] - cls.add_method('DoAssignStreams', - 'int64_t', - [param('int64_t', 'start')], - visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function] - cls.add_method('DoGetPosition', - 'ns3::Vector', + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMax() const [member function] + cls.add_method('getMax', + 'double', [], - is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function] - cls.add_method('DoGetVelocity', - 'ns3::Vector', + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMean() const [member function] + cls.add_method('getMean', + 'double', [], - is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) - ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function] - cls.add_method('DoSetPosition', - 'void', - [param('ns3::Vector const &', 'position')], - is_pure_virtual=True, visibility='private', is_virtual=True) - return - -def register_Ns3NetDevice_methods(root_module, cls): - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] - cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMin() const [member function] + cls.add_method('getMin', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSqrSum() const [member function] + cls.add_method('getSqrSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getStddev() const [member function] + cls.add_method('getStddev', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSum() const [member function] + cls.add_method('getSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getVariance() const [member function] + cls.add_method('getVariance', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3MinMaxAvgTotalCalculator__Unsigned_long_methods(root_module, cls): + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator(ns3::MinMaxAvgTotalCalculator const & arg0) [constructor] + cls.add_constructor([param('ns3::MinMaxAvgTotalCalculator< unsigned long long > const &', 'arg0')]) + ## basic-data-calculators.h (module 'stats'): ns3::MinMaxAvgTotalCalculator::MinMaxAvgTotalCalculator() [constructor] + cls.add_constructor([]) + ## basic-data-calculators.h (module 'stats'): static ns3::TypeId ns3::MinMaxAvgTotalCalculator::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Output(ns3::DataOutputCallback & callback) const [member function] + cls.add_method('Output', + 'void', + [param('ns3::DataOutputCallback &', 'callback')], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Reset() [member function] + cls.add_method('Reset', + 'void', + []) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::Update(long unsigned int const i) [member function] + cls.add_method('Update', + 'void', + [param('long unsigned int const', 'i')]) + ## basic-data-calculators.h (module 'stats'): long int ns3::MinMaxAvgTotalCalculator::getCount() const [member function] + cls.add_method('getCount', + 'long int', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMax() const [member function] + cls.add_method('getMax', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMean() const [member function] + cls.add_method('getMean', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getMin() const [member function] + cls.add_method('getMin', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSqrSum() const [member function] + cls.add_method('getSqrSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getStddev() const [member function] + cls.add_method('getStddev', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getSum() const [member function] + cls.add_method('getSum', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): double ns3::MinMaxAvgTotalCalculator::getVariance() const [member function] + cls.add_method('getVariance', + 'double', + [], + is_const=True, is_virtual=True) + ## basic-data-calculators.h (module 'stats'): void ns3::MinMaxAvgTotalCalculator::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + visibility='protected', is_virtual=True) + return + +def register_Ns3MobilityModel_methods(root_module, cls): + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [constructor] + cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] + cls.add_constructor([]) + ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::AssignStreams(int64_t stream) [member function] + cls.add_method('AssignStreams', + 'int64_t', + [param('int64_t', 'stream')]) + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetDistanceFrom(ns3::Ptr position) const [member function] + cls.add_method('GetDistanceFrom', + 'double', + [param('ns3::Ptr< ns3::MobilityModel const >', 'position')], + is_const=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetPosition() const [member function] + cls.add_method('GetPosition', + 'ns3::Vector', + [], + is_const=True) + ## mobility-model.h (module 'mobility'): double ns3::MobilityModel::GetRelativeSpeed(ns3::Ptr other) const [member function] + cls.add_method('GetRelativeSpeed', + 'double', + [param('ns3::Ptr< ns3::MobilityModel const >', 'other')], + is_const=True) + ## mobility-model.h (module 'mobility'): static ns3::TypeId ns3::MobilityModel::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::GetVelocity() const [member function] + cls.add_method('GetVelocity', + 'ns3::Vector', + [], + is_const=True) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::SetPosition(ns3::Vector const & position) [member function] + cls.add_method('SetPosition', + 'void', + [param('ns3::Vector const &', 'position')]) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::NotifyCourseChange() const [member function] + cls.add_method('NotifyCourseChange', + 'void', + [], + is_const=True, visibility='protected') + ## mobility-model.h (module 'mobility'): int64_t ns3::MobilityModel::DoAssignStreams(int64_t start) [member function] + cls.add_method('DoAssignStreams', + 'int64_t', + [param('int64_t', 'start')], + visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetPosition() const [member function] + cls.add_method('DoGetPosition', + 'ns3::Vector', + [], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): ns3::Vector ns3::MobilityModel::DoGetVelocity() const [member function] + cls.add_method('DoGetVelocity', + 'ns3::Vector', + [], + is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True) + ## mobility-model.h (module 'mobility'): void ns3::MobilityModel::DoSetPosition(ns3::Vector const & position) [member function] + cls.add_method('DoSetPosition', + 'void', + [param('ns3::Vector const &', 'position')], + is_pure_virtual=True, visibility='private', is_virtual=True) + return + +def register_Ns3NetDevice_methods(root_module, cls): + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] + cls.add_constructor([]) + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -19273,12 +19990,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -19294,7 +20011,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -19335,7 +20052,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3NoOpComponentCarrierManager_methods(root_module, cls): - ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager(ns3::NoOpComponentCarrierManager const & arg0) [copy constructor] + ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager(ns3::NoOpComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::NoOpComponentCarrierManager const &', 'arg0')]) ## no-op-component-carrier-manager.h (module 'lte'): ns3::NoOpComponentCarrierManager::NoOpComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -19427,7 +20144,7 @@ def register_Ns3NoOpComponentCarrierManager_methods(root_module, cls): return def register_Ns3NoOpHandoverAlgorithm_methods(root_module, cls): - ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm(ns3::NoOpHandoverAlgorithm const & arg0) [copy constructor] + ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm(ns3::NoOpHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::NoOpHandoverAlgorithm const &', 'arg0')]) ## no-op-handover-algorithm.h (module 'lte'): ns3::NoOpHandoverAlgorithm::NoOpHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -19464,7 +20181,7 @@ def register_Ns3NoOpHandoverAlgorithm_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -19523,19 +20240,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -19599,23 +20316,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19625,7 +20342,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -19640,7 +20357,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -19833,7 +20550,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -19870,7 +20587,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): return def register_Ns3PfFfMacScheduler_methods(root_module, cls): - ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler(ns3::PfFfMacScheduler const & arg0) [copy constructor] + ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler(ns3::PfFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::PfFfMacScheduler const &', 'arg0')]) ## pf-ff-mac-scheduler.h (module 'lte'): ns3::PfFfMacScheduler::PfFfMacScheduler() [constructor] cls.add_constructor([]) @@ -19921,7 +20638,7 @@ def register_Ns3PfFfMacScheduler_methods(root_module, cls): return def register_Ns3PhyRxStatsCalculator_methods(root_module, cls): - ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator(ns3::PhyRxStatsCalculator const & arg0) [copy constructor] + ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator(ns3::PhyRxStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyRxStatsCalculator const &', 'arg0')]) ## phy-rx-stats-calculator.h (module 'lte'): ns3::PhyRxStatsCalculator::PhyRxStatsCalculator() [constructor] cls.add_constructor([]) @@ -19967,7 +20684,7 @@ def register_Ns3PhyRxStatsCalculator_methods(root_module, cls): return def register_Ns3PhyStatsCalculator_methods(root_module, cls): - ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator(ns3::PhyStatsCalculator const & arg0) [copy constructor] + ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator(ns3::PhyStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyStatsCalculator const &', 'arg0')]) ## phy-stats-calculator.h (module 'lte'): ns3::PhyStatsCalculator::PhyStatsCalculator() [constructor] cls.add_constructor([]) @@ -20030,7 +20747,7 @@ def register_Ns3PhyStatsCalculator_methods(root_module, cls): return def register_Ns3PhyTxStatsCalculator_methods(root_module, cls): - ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator(ns3::PhyTxStatsCalculator const & arg0) [copy constructor] + ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator(ns3::PhyTxStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::PhyTxStatsCalculator const &', 'arg0')]) ## phy-tx-stats-calculator.h (module 'lte'): ns3::PhyTxStatsCalculator::PhyTxStatsCalculator() [constructor] cls.add_constructor([]) @@ -20076,7 +20793,7 @@ def register_Ns3PhyTxStatsCalculator_methods(root_module, cls): return def register_Ns3PointToPointEpcHelper_methods(root_module, cls): - ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper(ns3::PointToPointEpcHelper const & arg0) [copy constructor] + ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper(ns3::PointToPointEpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::PointToPointEpcHelper const &', 'arg0')]) ## point-to-point-epc-helper.h (module 'lte'): ns3::PointToPointEpcHelper::PointToPointEpcHelper() [constructor] cls.add_constructor([]) @@ -20130,7 +20847,7 @@ def register_Ns3PointToPointEpcHelper_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -20140,7 +20857,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -20151,7 +20868,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -20161,7 +20878,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -20173,7 +20890,7 @@ def register_Ns3PointerValue_methods(root_module, cls): return def register_Ns3PssFfMacScheduler_methods(root_module, cls): - ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler(ns3::PssFfMacScheduler const & arg0) [copy constructor] + ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler(ns3::PssFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::PssFfMacScheduler const &', 'arg0')]) ## pss-ff-mac-scheduler.h (module 'lte'): ns3::PssFfMacScheduler::PssFfMacScheduler() [constructor] cls.add_constructor([]) @@ -20224,7 +20941,7 @@ def register_Ns3PssFfMacScheduler_methods(root_module, cls): return def register_Ns3RachPreambleLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage(ns3::RachPreambleLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage(ns3::RachPreambleLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RachPreambleLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RachPreambleLteControlMessage::RachPreambleLteControlMessage() [constructor] cls.add_constructor([]) @@ -20240,7 +20957,7 @@ def register_Ns3RachPreambleLteControlMessage_methods(root_module, cls): return def register_Ns3RadioBearerStatsCalculator_methods(root_module, cls): - ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator(ns3::RadioBearerStatsCalculator const & arg0) [copy constructor] + ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator(ns3::RadioBearerStatsCalculator const & arg0) [constructor] cls.add_constructor([param('ns3::RadioBearerStatsCalculator const &', 'arg0')]) ## radio-bearer-stats-calculator.h (module 'lte'): ns3::RadioBearerStatsCalculator::RadioBearerStatsCalculator() [constructor] cls.add_constructor([]) @@ -20381,7 +21098,7 @@ def register_Ns3RadioBearerStatsCalculator_methods(root_module, cls): return def register_Ns3RarLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage(ns3::RarLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage(ns3::RarLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RarLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::RarLteControlMessage() [constructor] cls.add_constructor([]) @@ -20394,14 +21111,14 @@ def register_Ns3RarLteControlMessage_methods(root_module, cls): 'uint16_t', [], is_const=True) - ## lte-control-messages.h (module 'lte'): std::_List_const_iterator ns3::RarLteControlMessage::RarListBegin() const [member function] + ## lte-control-messages.h (module 'lte'): std::list >::const_iterator ns3::RarLteControlMessage::RarListBegin() const [member function] cls.add_method('RarListBegin', - 'std::_List_const_iterator< ns3::RarLteControlMessage::Rar >', + 'std::list< ns3::RarLteControlMessage::Rar > const_iterator', [], is_const=True) - ## lte-control-messages.h (module 'lte'): std::_List_const_iterator ns3::RarLteControlMessage::RarListEnd() const [member function] + ## lte-control-messages.h (module 'lte'): std::list >::const_iterator ns3::RarLteControlMessage::RarListEnd() const [member function] cls.add_method('RarListEnd', - 'std::_List_const_iterator< ns3::RarLteControlMessage::Rar >', + 'std::list< ns3::RarLteControlMessage::Rar > const_iterator', [], is_const=True) ## lte-control-messages.h (module 'lte'): void ns3::RarLteControlMessage::SetRaRnti(uint16_t raRnti) [member function] @@ -20413,7 +21130,7 @@ def register_Ns3RarLteControlMessage_methods(root_module, cls): def register_Ns3RarLteControlMessageRar_methods(root_module, cls): ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar(ns3::RarLteControlMessage::Rar const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::Rar(ns3::RarLteControlMessage::Rar const & arg0) [constructor] cls.add_constructor([param('ns3::RarLteControlMessage::Rar const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::RarLteControlMessage::Rar::rapId [variable] cls.add_instance_attribute('rapId', 'uint8_t', is_const=False) @@ -20459,7 +21176,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): 'ns3::Ptr< ns3::NetDevice >', [], is_const=True, is_virtual=True) - ## rem-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::RemSpectrumPhy::GetRxSpectrumModel() const [member function] + ## rem-spectrum-phy.h (module 'lte'): ns3::Ptr ns3::RemSpectrumPhy::GetRxSpectrumModel() const [member function] cls.add_method('GetRxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', [], @@ -20474,7 +21191,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::SpectrumSignalParameters >', 'params')], is_virtual=True) - ## rem-spectrum-phy.h (module 'lte'): void ns3::RemSpectrumPhy::SetRxSpectrumModel(ns3::Ptr m) [member function] + ## rem-spectrum-phy.h (module 'lte'): void ns3::RemSpectrumPhy::SetRxSpectrumModel(ns3::Ptr m) [member function] cls.add_method('SetRxSpectrumModel', 'void', [param('ns3::Ptr< ns3::SpectrumModel const >', 'm')]) @@ -20505,7 +21222,7 @@ def register_Ns3RemSpectrumPhy_methods(root_module, cls): return def register_Ns3RrComponentCarrierManager_methods(root_module, cls): - ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager(ns3::RrComponentCarrierManager const & arg0) [copy constructor] + ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager(ns3::RrComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::RrComponentCarrierManager const &', 'arg0')]) ## no-op-component-carrier-manager.h (module 'lte'): ns3::RrComponentCarrierManager::RrComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -20527,7 +21244,7 @@ def register_Ns3RrComponentCarrierManager_methods(root_module, cls): return def register_Ns3RrFfMacScheduler_methods(root_module, cls): - ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler(ns3::RrFfMacScheduler const & arg0) [copy constructor] + ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler(ns3::RrFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::RrFfMacScheduler const &', 'arg0')]) ## rr-ff-mac-scheduler.h (module 'lte'): ns3::RrFfMacScheduler::RrFfMacScheduler() [constructor] cls.add_constructor([]) @@ -20578,7 +21295,7 @@ def register_Ns3RrFfMacScheduler_methods(root_module, cls): return def register_Ns3RrcAsn1Header_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header(ns3::RrcAsn1Header const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header(ns3::RrcAsn1Header const & arg0) [constructor] cls.add_constructor([param('ns3::RrcAsn1Header const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcAsn1Header::RrcAsn1Header() [constructor] cls.add_constructor([]) @@ -20814,7 +21531,7 @@ def register_Ns3RrcAsn1Header_methods(root_module, cls): return def register_Ns3RrcDlCcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage(ns3::RrcDlCcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage(ns3::RrcDlCcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcDlCcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcDlCcchMessage::RrcDlCcchMessage() [constructor] cls.add_constructor([]) @@ -20846,7 +21563,7 @@ def register_Ns3RrcDlCcchMessage_methods(root_module, cls): return def register_Ns3RrcDlDcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage(ns3::RrcDlDcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage(ns3::RrcDlDcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcDlDcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcDlDcchMessage::RrcDlDcchMessage() [constructor] cls.add_constructor([]) @@ -20878,7 +21595,7 @@ def register_Ns3RrcDlDcchMessage_methods(root_module, cls): return def register_Ns3RrcUlCcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage(ns3::RrcUlCcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage(ns3::RrcUlCcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcUlCcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcUlCcchMessage::RrcUlCcchMessage() [constructor] cls.add_constructor([]) @@ -20910,7 +21627,7 @@ def register_Ns3RrcUlCcchMessage_methods(root_module, cls): return def register_Ns3RrcUlDcchMessage_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage(ns3::RrcUlDcchMessage const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage(ns3::RrcUlDcchMessage const & arg0) [constructor] cls.add_constructor([param('ns3::RrcUlDcchMessage const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcUlDcchMessage::RrcUlDcchMessage() [constructor] cls.add_constructor([]) @@ -20942,7 +21659,7 @@ def register_Ns3RrcUlDcchMessage_methods(root_module, cls): return def register_Ns3Sib1LteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage(ns3::Sib1LteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage(ns3::Sib1LteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::Sib1LteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::Sib1LteControlMessage::Sib1LteControlMessage() [constructor] cls.add_constructor([]) @@ -20958,7 +21675,7 @@ def register_Ns3Sib1LteControlMessage_methods(root_module, cls): return def register_Ns3SimpleUeComponentCarrierManager_methods(root_module, cls): - ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager(ns3::SimpleUeComponentCarrierManager const & arg0) [copy constructor] + ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager(ns3::SimpleUeComponentCarrierManager const & arg0) [constructor] cls.add_constructor([param('ns3::SimpleUeComponentCarrierManager const &', 'arg0')]) ## simple-ue-component-carrier-manager.h (module 'lte'): ns3::SimpleUeComponentCarrierManager::SimpleUeComponentCarrierManager() [constructor] cls.add_constructor([]) @@ -21047,7 +21764,7 @@ def register_Ns3SimpleUeComponentCarrierManager_methods(root_module, cls): def register_Ns3SpectrumChannel_methods(root_module, cls): ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel() [constructor] cls.add_constructor([]) - ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [copy constructor] + ## spectrum-channel.h (module 'spectrum'): ns3::SpectrumChannel::SpectrumChannel(ns3::SpectrumChannel const & arg0) [constructor] cls.add_constructor([param('ns3::SpectrumChannel const &', 'arg0')]) ## spectrum-channel.h (module 'spectrum'): void ns3::SpectrumChannel::AddPropagationLossModel(ns3::Ptr loss) [member function] cls.add_method('AddPropagationLossModel', @@ -21082,7 +21799,7 @@ def register_Ns3SpectrumChannel_methods(root_module, cls): return def register_Ns3SrsCqiRntiVsp_methods(root_module, cls): - ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(ns3::SrsCqiRntiVsp const & arg0) [copy constructor] + ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(ns3::SrsCqiRntiVsp const & arg0) [constructor] cls.add_constructor([param('ns3::SrsCqiRntiVsp const &', 'arg0')]) ## lte-vendor-specific-parameters.h (module 'lte'): ns3::SrsCqiRntiVsp::SrsCqiRntiVsp(uint16_t rnti) [constructor] cls.add_constructor([param('uint16_t', 'rnti')]) @@ -21095,23 +21812,23 @@ def register_Ns3SrsCqiRntiVsp_methods(root_module, cls): def register_Ns3StringChecker_methods(root_module, cls): ## string.h (module 'core'): ns3::StringChecker::StringChecker() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [copy constructor] + ## string.h (module 'core'): ns3::StringChecker::StringChecker(ns3::StringChecker const & arg0) [constructor] cls.add_constructor([param('ns3::StringChecker const &', 'arg0')]) return def register_Ns3StringValue_methods(root_module, cls): ## string.h (module 'core'): ns3::StringValue::StringValue() [constructor] cls.add_constructor([]) - ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::StringValue::StringValue(std::string const & value) [constructor] cls.add_constructor([param('std::string const &', 'value')]) + ## string.h (module 'core'): ns3::StringValue::StringValue(ns3::StringValue const & arg0) [constructor] + cls.add_constructor([param('ns3::StringValue const &', 'arg0')]) ## string.h (module 'core'): ns3::Ptr ns3::StringValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## string.h (module 'core'): bool ns3::StringValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21121,7 +21838,7 @@ def register_Ns3StringValue_methods(root_module, cls): 'std::string', [], is_const=True) - ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] + ## string.h (module 'core'): std::string ns3::StringValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21133,7 +21850,7 @@ def register_Ns3StringValue_methods(root_module, cls): return def register_Ns3TdBetFfMacScheduler_methods(root_module, cls): - ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler(ns3::TdBetFfMacScheduler const & arg0) [copy constructor] + ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler(ns3::TdBetFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdBetFfMacScheduler const &', 'arg0')]) ## tdbet-ff-mac-scheduler.h (module 'lte'): ns3::TdBetFfMacScheduler::TdBetFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21184,7 +21901,7 @@ def register_Ns3TdBetFfMacScheduler_methods(root_module, cls): return def register_Ns3TdMtFfMacScheduler_methods(root_module, cls): - ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler(ns3::TdMtFfMacScheduler const & arg0) [copy constructor] + ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler(ns3::TdMtFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdMtFfMacScheduler const &', 'arg0')]) ## tdmt-ff-mac-scheduler.h (module 'lte'): ns3::TdMtFfMacScheduler::TdMtFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21235,7 +21952,7 @@ def register_Ns3TdMtFfMacScheduler_methods(root_module, cls): return def register_Ns3TdTbfqFfMacScheduler_methods(root_module, cls): - ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler(ns3::TdTbfqFfMacScheduler const & arg0) [copy constructor] + ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler(ns3::TdTbfqFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TdTbfqFfMacScheduler const &', 'arg0')]) ## tdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::TdTbfqFfMacScheduler::TdTbfqFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21288,16 +22005,16 @@ def register_Ns3TdTbfqFfMacScheduler_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21307,7 +22024,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21319,7 +22036,7 @@ def register_Ns3TimeValue_methods(root_module, cls): return def register_Ns3TtaFfMacScheduler_methods(root_module, cls): - ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler(ns3::TtaFfMacScheduler const & arg0) [copy constructor] + ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler(ns3::TtaFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::TtaFfMacScheduler const &', 'arg0')]) ## tta-ff-mac-scheduler.h (module 'lte'): ns3::TtaFfMacScheduler::TtaFfMacScheduler() [constructor] cls.add_constructor([]) @@ -21372,23 +22089,23 @@ def register_Ns3TtaFfMacScheduler_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21398,7 +22115,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21412,16 +22129,16 @@ def register_Ns3TypeIdValue_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21431,7 +22148,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21443,7 +22160,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): return def register_Ns3UlDciLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage(ns3::UlDciLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage(ns3::UlDciLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::UlDciLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::UlDciLteControlMessage::UlDciLteControlMessage() [constructor] cls.add_constructor([]) @@ -21460,23 +22177,23 @@ def register_Ns3UlDciLteControlMessage_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21486,7 +22203,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21500,23 +22217,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21526,7 +22243,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21538,7 +22255,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): return def register_Ns3VirtualNetDevice_methods(root_module, cls): - ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice(ns3::VirtualNetDevice const & arg0) [copy constructor] + ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice(ns3::VirtualNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::VirtualNetDevice const &', 'arg0')]) ## virtual-net-device.h (module 'virtual-net-device'): ns3::VirtualNetDevice::VirtualNetDevice() [constructor] cls.add_constructor([]) @@ -21664,17 +22381,17 @@ def register_Ns3VirtualNetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetSendCallback(ns3::Callback, ns3::Address const&, ns3::Address const&, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> transmitCb) [member function] + ## virtual-net-device.h (module 'virtual-net-device'): void ns3::VirtualNetDevice::SetSendCallback(ns3::VirtualNetDevice::SendCallback transmitCb) [member function] cls.add_method('SetSendCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::Packet >, ns3::Address const &, ns3::Address const &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'transmitCb')]) @@ -21695,7 +22412,7 @@ def register_Ns3VirtualNetDevice_methods(root_module, cls): return def register_Ns3A2A4RsrqHandoverAlgorithm_methods(root_module, cls): - ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm(ns3::A2A4RsrqHandoverAlgorithm const & arg0) [copy constructor] + ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm(ns3::A2A4RsrqHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::A2A4RsrqHandoverAlgorithm const &', 'arg0')]) ## a2-a4-rsrq-handover-algorithm.h (module 'lte'): ns3::A2A4RsrqHandoverAlgorithm::A2A4RsrqHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -21732,7 +22449,7 @@ def register_Ns3A2A4RsrqHandoverAlgorithm_methods(root_module, cls): return def register_Ns3A3RsrpHandoverAlgorithm_methods(root_module, cls): - ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm(ns3::A3RsrpHandoverAlgorithm const & arg0) [copy constructor] + ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm(ns3::A3RsrpHandoverAlgorithm const & arg0) [constructor] cls.add_constructor([param('ns3::A3RsrpHandoverAlgorithm const &', 'arg0')]) ## a3-rsrp-handover-algorithm.h (module 'lte'): ns3::A3RsrpHandoverAlgorithm::A3RsrpHandoverAlgorithm() [constructor] cls.add_constructor([]) @@ -21771,23 +22488,23 @@ def register_Ns3A3RsrpHandoverAlgorithm_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21797,7 +22514,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -21809,7 +22526,7 @@ def register_Ns3AddressValue_methods(root_module, cls): return def register_Ns3BsrLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage(ns3::BsrLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage(ns3::BsrLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::BsrLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::BsrLteControlMessage::BsrLteControlMessage() [constructor] cls.add_constructor([]) @@ -21823,89 +22540,881 @@ def register_Ns3BsrLteControlMessage_methods(root_module, cls): [param('ns3::MacCeListElement_s', 'bsr')]) return -def register_Ns3CqaFfMacScheduler_methods(root_module, cls): - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler(ns3::CqaFfMacScheduler const & arg0) [copy constructor] - cls.add_constructor([param('ns3::CqaFfMacScheduler const &', 'arg0')]) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler() [constructor] +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] cls.add_constructor([]) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::DoDispose() [member function] - cls.add_method('DoDispose', - 'void', + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacCschedSapProvider * ns3::CqaFfMacScheduler::GetFfMacCschedSapProvider() [member function] - cls.add_method('GetFfMacCschedSapProvider', - 'ns3::FfMacCschedSapProvider *', + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacSchedSapProvider * ns3::CqaFfMacScheduler::GetFfMacSchedSapProvider() [member function] - cls.add_method('GetFfMacSchedSapProvider', - 'ns3::FfMacSchedSapProvider *', + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::LteFfrSapUser * ns3::CqaFfMacScheduler::GetLteFfrSapUser() [member function] - cls.add_method('GetLteFfrSapUser', - 'ns3::LteFfrSapUser *', + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', [], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): static ns3::TypeId ns3::CqaFfMacScheduler::GetTypeId() [member function] - cls.add_method('GetTypeId', - 'ns3::TypeId', + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Packet__gt___Const_ns3Address___amp___Const_ns3Address___amp___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Packet >, ns3::Address const &, ns3::Address const &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', [], is_static=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacCschedSapUser(ns3::FfMacCschedSapUser * s) [member function] - cls.add_method('SetFfMacCschedSapUser', - 'void', - [param('ns3::FfMacCschedSapUser *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacSchedSapUser(ns3::FfMacSchedSapUser * s) [member function] - cls.add_method('SetFfMacSchedSapUser', - 'void', - [param('ns3::FfMacSchedSapUser *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetLteFfrSapProvider(ns3::LteFfrSapProvider * s) [member function] - cls.add_method('SetLteFfrSapProvider', - 'void', - [param('ns3::LteFfrSapProvider *', 's')], - is_virtual=True) - ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::TransmissionModeConfigurationUpdate(uint16_t rnti, uint8_t txMode) [member function] - cls.add_method('TransmissionModeConfigurationUpdate', - 'void', - [param('uint16_t', 'rnti'), param('uint8_t', 'txMode')]) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, const ns3::Address &, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1, ns3::Address const & arg2, short unsigned int arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::Address const &', 'arg1'), param('ns3::Address const &', 'arg2'), param('short unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') return -def register_Ns3DlCqiLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage(ns3::DlCqiLteControlMessage const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlCqiLteControlMessage const &', 'arg0')]) - ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage() [constructor] +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::CqiListElement_s ns3::DlCqiLteControlMessage::GetDlCqi() [member function] - cls.add_method('GetDlCqi', - 'ns3::CqiListElement_s', - []) - ## lte-control-messages.h (module 'lte'): void ns3::DlCqiLteControlMessage::SetDlCqi(ns3::CqiListElement_s dlcqi) [member function] - cls.add_method('SetDlCqi', - 'void', - [param('ns3::CqiListElement_s', 'dlcqi')]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') return -def register_Ns3DlDciLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage(ns3::DlDciLteControlMessage const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DlDciLteControlMessage const &', 'arg0')]) - ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage() [constructor] +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] cls.add_constructor([]) - ## lte-control-messages.h (module 'lte'): ns3::DlDciListElement_s ns3::DlDciLteControlMessage::GetDci() [member function] - cls.add_method('GetDci', - 'ns3::DlDciListElement_s', - []) - ## lte-control-messages.h (module 'lte'): void ns3::DlDciLteControlMessage::SetDci(ns3::DlDciListElement_s dci) [member function] - cls.add_method('SetDci', - 'void', + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Const_ns3SpectrumValue___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::SpectrumValue const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::SpectrumValue const & arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::SpectrumValue const &', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3DlSchedulingCallbackInfo_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::DlSchedulingCallbackInfo, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::DlSchedulingCallbackInfo arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::DlSchedulingCallbackInfo', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3EpcUeNasState_Ns3EpcUeNasState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::EpcUeNas::State, ns3::EpcUeNas::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::EpcUeNas::State arg0, ns3::EpcUeNas::State arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::EpcUeNas::State', 'arg0'), param('ns3::EpcUeNas::State', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3PhyReceptionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::PhyReceptionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::PhyReceptionStatParameters arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::PhyReceptionStatParameters', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3PhyTransmissionStatParameters_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::PhyTransmissionStatParameters, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::PhyTransmissionStatParameters arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::PhyTransmissionStatParameters', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::MobilityModel const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::MobilityModel const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3PacketBurst__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::PacketBurst const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Address const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('ns3::Address const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Socket__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Socket >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Socket >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_int_Unsigned_int_Unsigned_short_Unsigned_char_Unsigned_short_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned int, unsigned int, unsigned short, unsigned char, unsigned short, unsigned char, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(unsigned int arg0, unsigned int arg1, short unsigned int arg2, unsigned char arg3, short unsigned int arg4, unsigned char arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('unsigned int', 'arg0'), param('unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('unsigned char', 'arg3'), param('short unsigned int', 'arg4'), param('unsigned char', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteRrcSapMeasurementReport_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::LteRrcSap::MeasurementReport, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::LteRrcSap::MeasurementReport arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::LteRrcSap::MeasurementReport', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3LteUeRrcState_Ns3LteUeRrcState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::LteUeRrc::State, ns3::LteUeRrc::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::LteUeRrc::State arg3, ns3::LteUeRrc::State arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::LteUeRrc::State', 'arg3'), param('ns3::LteUeRrc::State', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3UeManagerState_Ns3UeManagerState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::UeManager::State, ns3::UeManager::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, ns3::UeManager::State arg3, ns3::UeManager::State arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::UeManager::State', 'arg3'), param('ns3::UeManager::State', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_long_Unsigned_short_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned long long, unsigned short, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(long unsigned int arg0, short unsigned int arg1, short unsigned int arg2, short unsigned int arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('long unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('short unsigned int', 'arg2'), param('short unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Ns3Ptr__lt__ns3SpectrumValue__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, ns3::Ptr< ns3::SpectrumValue >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(short unsigned int arg0, ns3::Ptr arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('ns3::Ptr< ns3::SpectrumValue >', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, unsigned char arg1, unsigned int arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('unsigned char', 'arg1'), param('unsigned int', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_char_Unsigned_int_Unsigned_long_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned char, unsigned int, unsigned long long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, unsigned char arg1, unsigned int arg2, long unsigned int arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('unsigned char', 'arg1'), param('unsigned int', 'arg2'), param('long unsigned int', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Bool_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, bool, unsigned char, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, double arg3, bool arg4, unsigned char arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('double', 'arg3'), param('bool', 'arg4'), param('unsigned char', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, double arg3, unsigned char arg4) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('double', 'arg3'), param('unsigned char', 'arg4')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Double_Unsigned_char_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, double, unsigned char, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, double arg2, unsigned char arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('double', 'arg2'), param('unsigned char', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3LteUePhyState_Ns3LteUePhyState_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::LteUePhy::State, ns3::LteUePhy::State, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1, ns3::LteUePhy::State arg2, ns3::LteUePhy::State arg3) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1'), param('ns3::LteUePhy::State', 'arg2'), param('ns3::LteUePhy::State', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Unsigned_short_Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, unsigned short, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(short unsigned int arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('short unsigned int', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CqaFfMacScheduler_methods(root_module, cls): + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler(ns3::CqaFfMacScheduler const & arg0) [constructor] + cls.add_constructor([param('ns3::CqaFfMacScheduler const &', 'arg0')]) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::CqaFfMacScheduler::CqaFfMacScheduler() [constructor] + cls.add_constructor([]) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::DoDispose() [member function] + cls.add_method('DoDispose', + 'void', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacCschedSapProvider * ns3::CqaFfMacScheduler::GetFfMacCschedSapProvider() [member function] + cls.add_method('GetFfMacCschedSapProvider', + 'ns3::FfMacCschedSapProvider *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::FfMacSchedSapProvider * ns3::CqaFfMacScheduler::GetFfMacSchedSapProvider() [member function] + cls.add_method('GetFfMacSchedSapProvider', + 'ns3::FfMacSchedSapProvider *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): ns3::LteFfrSapUser * ns3::CqaFfMacScheduler::GetLteFfrSapUser() [member function] + cls.add_method('GetLteFfrSapUser', + 'ns3::LteFfrSapUser *', + [], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): static ns3::TypeId ns3::CqaFfMacScheduler::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacCschedSapUser(ns3::FfMacCschedSapUser * s) [member function] + cls.add_method('SetFfMacCschedSapUser', + 'void', + [param('ns3::FfMacCschedSapUser *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetFfMacSchedSapUser(ns3::FfMacSchedSapUser * s) [member function] + cls.add_method('SetFfMacSchedSapUser', + 'void', + [param('ns3::FfMacSchedSapUser *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::SetLteFfrSapProvider(ns3::LteFfrSapProvider * s) [member function] + cls.add_method('SetLteFfrSapProvider', + 'void', + [param('ns3::LteFfrSapProvider *', 's')], + is_virtual=True) + ## cqa-ff-mac-scheduler.h (module 'lte'): void ns3::CqaFfMacScheduler::TransmissionModeConfigurationUpdate(uint16_t rnti, uint8_t txMode) [member function] + cls.add_method('TransmissionModeConfigurationUpdate', + 'void', + [param('uint16_t', 'rnti'), param('uint8_t', 'txMode')]) + return + +def register_Ns3DlCqiLteControlMessage_methods(root_module, cls): + ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage(ns3::DlCqiLteControlMessage const & arg0) [constructor] + cls.add_constructor([param('ns3::DlCqiLteControlMessage const &', 'arg0')]) + ## lte-control-messages.h (module 'lte'): ns3::DlCqiLteControlMessage::DlCqiLteControlMessage() [constructor] + cls.add_constructor([]) + ## lte-control-messages.h (module 'lte'): ns3::CqiListElement_s ns3::DlCqiLteControlMessage::GetDlCqi() [member function] + cls.add_method('GetDlCqi', + 'ns3::CqiListElement_s', + []) + ## lte-control-messages.h (module 'lte'): void ns3::DlCqiLteControlMessage::SetDlCqi(ns3::CqiListElement_s dlcqi) [member function] + cls.add_method('SetDlCqi', + 'void', + [param('ns3::CqiListElement_s', 'dlcqi')]) + return + +def register_Ns3DlDciLteControlMessage_methods(root_module, cls): + ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage(ns3::DlDciLteControlMessage const & arg0) [constructor] + cls.add_constructor([param('ns3::DlDciLteControlMessage const &', 'arg0')]) + ## lte-control-messages.h (module 'lte'): ns3::DlDciLteControlMessage::DlDciLteControlMessage() [constructor] + cls.add_constructor([]) + ## lte-control-messages.h (module 'lte'): ns3::DlDciListElement_s ns3::DlDciLteControlMessage::GetDci() [member function] + cls.add_method('GetDci', + 'ns3::DlDciListElement_s', + []) + ## lte-control-messages.h (module 'lte'): void ns3::DlDciLteControlMessage::SetDci(ns3::DlDciListElement_s dci) [member function] + cls.add_method('SetDci', + 'void', [param('ns3::DlDciListElement_s', 'dci')]) return def register_Ns3DlHarqFeedbackLteControlMessage_methods(root_module, cls): - ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage(ns3::DlHarqFeedbackLteControlMessage const & arg0) [copy constructor] + ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage(ns3::DlHarqFeedbackLteControlMessage const & arg0) [constructor] cls.add_constructor([param('ns3::DlHarqFeedbackLteControlMessage const &', 'arg0')]) ## lte-control-messages.h (module 'lte'): ns3::DlHarqFeedbackLteControlMessage::DlHarqFeedbackLteControlMessage() [constructor] cls.add_constructor([]) @@ -21920,7 +23429,7 @@ def register_Ns3DlHarqFeedbackLteControlMessage_methods(root_module, cls): return def register_Ns3EmuEpcHelper_methods(root_module, cls): - ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper(ns3::EmuEpcHelper const & arg0) [copy constructor] + ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper(ns3::EmuEpcHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EmuEpcHelper const &', 'arg0')]) ## emu-epc-helper.h (module 'lte'): ns3::EmuEpcHelper::EmuEpcHelper() [constructor] cls.add_constructor([]) @@ -21977,7 +23486,7 @@ def register_Ns3EmuEpcHelper_methods(root_module, cls): return def register_Ns3FdBetFfMacScheduler_methods(root_module, cls): - ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler(ns3::FdBetFfMacScheduler const & arg0) [copy constructor] + ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler(ns3::FdBetFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdBetFfMacScheduler const &', 'arg0')]) ## fdbet-ff-mac-scheduler.h (module 'lte'): ns3::FdBetFfMacScheduler::FdBetFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22028,7 +23537,7 @@ def register_Ns3FdBetFfMacScheduler_methods(root_module, cls): return def register_Ns3FdMtFfMacScheduler_methods(root_module, cls): - ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler(ns3::FdMtFfMacScheduler const & arg0) [copy constructor] + ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler(ns3::FdMtFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdMtFfMacScheduler const &', 'arg0')]) ## fdmt-ff-mac-scheduler.h (module 'lte'): ns3::FdMtFfMacScheduler::FdMtFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22079,7 +23588,7 @@ def register_Ns3FdMtFfMacScheduler_methods(root_module, cls): return def register_Ns3FdTbfqFfMacScheduler_methods(root_module, cls): - ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler(ns3::FdTbfqFfMacScheduler const & arg0) [copy constructor] + ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler(ns3::FdTbfqFfMacScheduler const & arg0) [constructor] cls.add_constructor([param('ns3::FdTbfqFfMacScheduler const &', 'arg0')]) ## fdtbfq-ff-mac-scheduler.h (module 'lte'): ns3::FdTbfqFfMacScheduler::FdTbfqFfMacScheduler() [constructor] cls.add_constructor([]) @@ -22130,7 +23639,7 @@ def register_Ns3FdTbfqFfMacScheduler_methods(root_module, cls): return def register_Ns3HandoverPreparationInfoHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader(ns3::HandoverPreparationInfoHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader(ns3::HandoverPreparationInfoHeader const & arg0) [constructor] cls.add_constructor([param('ns3::HandoverPreparationInfoHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::HandoverPreparationInfoHeader::HandoverPreparationInfoHeader() [constructor] cls.add_constructor([]) @@ -22168,7 +23677,7 @@ def register_Ns3HandoverPreparationInfoHeader_methods(root_module, cls): def register_Ns3LteDataRadioBearerInfo_methods(root_module, cls): ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo() [constructor] cls.add_constructor([]) - ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo(ns3::LteDataRadioBearerInfo const & arg0) [copy constructor] + ## lte-radio-bearer-info.h (module 'lte'): ns3::LteDataRadioBearerInfo::LteDataRadioBearerInfo(ns3::LteDataRadioBearerInfo const & arg0) [constructor] cls.add_constructor([param('ns3::LteDataRadioBearerInfo const &', 'arg0')]) ## lte-radio-bearer-info.h (module 'lte'): static ns3::TypeId ns3::LteDataRadioBearerInfo::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -22194,7 +23703,7 @@ def register_Ns3LteDataRadioBearerInfo_methods(root_module, cls): return def register_Ns3LteEnbPhy_methods(root_module, cls): - ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy(ns3::LteEnbPhy const & arg0) [copy constructor] + ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy(ns3::LteEnbPhy const & arg0) [constructor] cls.add_constructor([param('ns3::LteEnbPhy const &', 'arg0')]) ## lte-enb-phy.h (module 'lte'): ns3::LteEnbPhy::LteEnbPhy() [constructor] cls.add_constructor([]) @@ -22222,7 +23731,7 @@ def register_Ns3LteEnbPhy_methods(root_module, cls): 'ns3::Ptr< ns3::SpectrumValue >', [], is_virtual=True) - ## lte-enb-phy.h (module 'lte'): std::list > ns3::LteEnbPhy::DequeueUlDci() [member function] + ## lte-enb-phy.h (module 'lte'): std::list > ns3::LteEnbPhy::DequeueUlDci() [member function] cls.add_method('DequeueUlDci', 'std::list< ns3::UlDciLteControlMessage >', []) @@ -22491,7 +24000,7 @@ def register_Ns3LteNetDevice_methods(root_module, cls): 'bool', [], is_const=True, is_virtual=True) - ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -22506,7 +24015,7 @@ def register_Ns3LteNetDevice_methods(root_module, cls): 'ns3::Address', [param('ns3::Ipv6Address', 'addr')], is_const=True, is_virtual=True) - ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetPromiscReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## lte-net-device.h (module 'lte'): void ns3::LteNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -22601,11 +24110,11 @@ def register_Ns3LteUeNetDevice_methods(root_module, cls): cls.add_method('GetTargetEnb', 'ns3::Ptr< ns3::LteEnbNetDevice >', []) - ## lte-ue-net-device.h (module 'lte'): void ns3::LteUeNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] + ## lte-ue-net-device.h (module 'lte'): void ns3::LteUeNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] cls.add_method('SetCcMap', 'void', [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', 'ccm')]) - ## lte-ue-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteUeNetDevice::GetCcMap() [member function] + ## lte-ue-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteUeNetDevice::GetCcMap() [member function] cls.add_method('GetCcMap', 'std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierUe > >', []) @@ -22617,7 +24126,7 @@ def register_Ns3LteUeNetDevice_methods(root_module, cls): return def register_Ns3MeasurementReportHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader(ns3::MeasurementReportHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader(ns3::MeasurementReportHeader const & arg0) [constructor] cls.add_constructor([param('ns3::MeasurementReportHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::MeasurementReportHeader::MeasurementReportHeader() [constructor] cls.add_constructor([]) @@ -22648,7 +24157,7 @@ def register_Ns3MeasurementReportHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReconfigurationCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader(ns3::RrcConnectionReconfigurationCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader(ns3::RrcConnectionReconfigurationCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReconfigurationCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationCompleteHeader() [constructor] cls.add_constructor([]) @@ -22684,7 +24193,7 @@ def register_Ns3RrcConnectionReconfigurationCompleteHeader_methods(root_module, return def register_Ns3RrcConnectionReconfigurationHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader(ns3::RrcConnectionReconfigurationHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader(ns3::RrcConnectionReconfigurationHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReconfigurationHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader() [constructor] cls.add_constructor([]) @@ -22782,7 +24291,7 @@ def register_Ns3RrcConnectionReconfigurationHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReestablishmentCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader(ns3::RrcConnectionReestablishmentCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader(ns3::RrcConnectionReestablishmentCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentCompleteHeader() [constructor] cls.add_constructor([]) @@ -22818,7 +24327,7 @@ def register_Ns3RrcConnectionReestablishmentCompleteHeader_methods(root_module, return def register_Ns3RrcConnectionReestablishmentHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader(ns3::RrcConnectionReestablishmentHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader(ns3::RrcConnectionReestablishmentHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader() [constructor] cls.add_constructor([]) @@ -22859,7 +24368,7 @@ def register_Ns3RrcConnectionReestablishmentHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReestablishmentRejectHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader(ns3::RrcConnectionReestablishmentRejectHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader(ns3::RrcConnectionReestablishmentRejectHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentRejectHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHeader() [constructor] cls.add_constructor([]) @@ -22890,7 +24399,7 @@ def register_Ns3RrcConnectionReestablishmentRejectHeader_methods(root_module, cl return def register_Ns3RrcConnectionReestablishmentRequestHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader(ns3::RrcConnectionReestablishmentRequestHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader(ns3::RrcConnectionReestablishmentRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReestablishmentRequestHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHeader() [constructor] cls.add_constructor([]) @@ -22931,7 +24440,7 @@ def register_Ns3RrcConnectionReestablishmentRequestHeader_methods(root_module, c return def register_Ns3RrcConnectionRejectHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader(ns3::RrcConnectionRejectHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader(ns3::RrcConnectionRejectHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionRejectHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRejectHeader::RrcConnectionRejectHeader() [constructor] cls.add_constructor([]) @@ -22962,7 +24471,7 @@ def register_Ns3RrcConnectionRejectHeader_methods(root_module, cls): return def register_Ns3RrcConnectionReleaseHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader(ns3::RrcConnectionReleaseHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader(ns3::RrcConnectionReleaseHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionReleaseHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionReleaseHeader::RrcConnectionReleaseHeader() [constructor] cls.add_constructor([]) @@ -22993,7 +24502,7 @@ def register_Ns3RrcConnectionReleaseHeader_methods(root_module, cls): return def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader(ns3::RrcConnectionRequestHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader(ns3::RrcConnectionRequestHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionRequestHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionRequestHeader::RrcConnectionRequestHeader() [constructor] cls.add_constructor([]) @@ -23007,14 +24516,14 @@ def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): 'ns3::LteRrcSap::RrcConnectionRequest', [], is_const=True) - ## lte-rrc-header.h (module 'lte'): std::bitset<8u> ns3::RrcConnectionRequestHeader::GetMmec() const [member function] + ## lte-rrc-header.h (module 'lte'): std::bitset<8> ns3::RrcConnectionRequestHeader::GetMmec() const [member function] cls.add_method('GetMmec', - 'std::bitset< 8u >', + 'std::bitset< 8 >', [], is_const=True) - ## lte-rrc-header.h (module 'lte'): std::bitset<32u> ns3::RrcConnectionRequestHeader::GetMtmsi() const [member function] + ## lte-rrc-header.h (module 'lte'): std::bitset<32> ns3::RrcConnectionRequestHeader::GetMtmsi() const [member function] cls.add_method('GetMtmsi', - 'std::bitset< 32u >', + 'std::bitset< 32 >', [], is_const=True) ## lte-rrc-header.h (module 'lte'): static ns3::TypeId ns3::RrcConnectionRequestHeader::GetTypeId() [member function] @@ -23039,7 +24548,7 @@ def register_Ns3RrcConnectionRequestHeader_methods(root_module, cls): return def register_Ns3RrcConnectionSetupCompleteHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader(ns3::RrcConnectionSetupCompleteHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader(ns3::RrcConnectionSetupCompleteHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionSetupCompleteHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader() [constructor] cls.add_constructor([]) @@ -23075,7 +24584,7 @@ def register_Ns3RrcConnectionSetupCompleteHeader_methods(root_module, cls): return def register_Ns3RrcConnectionSetupHeader_methods(root_module, cls): - ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader(ns3::RrcConnectionSetupHeader const & arg0) [copy constructor] + ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader(ns3::RrcConnectionSetupHeader const & arg0) [constructor] cls.add_constructor([param('ns3::RrcConnectionSetupHeader const &', 'arg0')]) ## lte-rrc-header.h (module 'lte'): ns3::RrcConnectionSetupHeader::RrcConnectionSetupHeader() [constructor] cls.add_constructor([]) @@ -23191,6 +24700,11 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): 'uint16_t', [], is_const=True) + ## lte-enb-net-device.h (module 'lte'): bool ns3::LteEnbNetDevice::HasCellId(uint16_t cellId) const [member function] + cls.add_method('HasCellId', + 'bool', + [param('uint16_t', 'cellId')], + is_const=True) ## lte-enb-net-device.h (module 'lte'): uint8_t ns3::LteEnbNetDevice::GetUlBandwidth() const [member function] cls.add_method('GetUlBandwidth', 'uint8_t', @@ -23245,11 +24759,11 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): cls.add_method('SetCsgIndication', 'void', [param('bool', 'csgIndication')]) - ## lte-enb-net-device.h (module 'lte'): void ns3::LteEnbNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] + ## lte-enb-net-device.h (module 'lte'): void ns3::LteEnbNetDevice::SetCcMap(std::map, std::less, std::allocator > > > ccm) [member function] cls.add_method('SetCcMap', 'void', [param('std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', 'ccm')]) - ## lte-enb-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteEnbNetDevice::GetCcMap() [member function] + ## lte-enb-net-device.h (module 'lte'): std::map, std::less, std::allocator > > > ns3::LteEnbNetDevice::GetCcMap() [member function] cls.add_method('GetCcMap', 'std::map< unsigned char, ns3::Ptr< ns3::ComponentCarrierEnb > >', []) @@ -23261,15 +24775,15 @@ def register_Ns3LteEnbNetDevice_methods(root_module, cls): return def register_Ns3ConfigMatchContainer_methods(root_module, cls): - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [copy constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(ns3::Config::MatchContainer const & arg0) [constructor] cls.add_constructor([param('ns3::Config::MatchContainer const &', 'arg0')]) ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer() [constructor] cls.add_constructor([]) - ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector > const & contexts, std::string path) [constructor] + ## config.h (module 'core'): ns3::Config::MatchContainer::MatchContainer(std::vector, std::allocator > > const & objects, std::vector, std::allocator > > const & contexts, std::string path) [constructor] cls.add_constructor([param('std::vector< ns3::Ptr< ns3::Object > > const &', 'objects'), param('std::vector< std::string > const &', 'contexts'), param('std::string', 'path')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::Begin() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): void ns3::Config::MatchContainer::Connect(std::string name, ns3::CallbackBase const & cb) [member function] @@ -23288,9 +24802,9 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): cls.add_method('DisconnectWithoutContext', 'void', [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')]) - ## config.h (module 'core'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::Config::MatchContainer::End() const [member function] + ## config.h (module 'core'): ns3::Config::MatchContainer::Iterator ns3::Config::MatchContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Object > const, std::vector< ns3::Ptr< ns3::Object > > >', + 'ns3::Config::MatchContainer::Iterator', [], is_const=True) ## config.h (module 'core'): ns3::Ptr ns3::Config::MatchContainer::Get(uint32_t i) const [member function] @@ -23320,7 +24834,7 @@ def register_Ns3ConfigMatchContainer_methods(root_module, cls): return def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -23342,7 +24856,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -23364,7 +24878,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -23381,7 +24895,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -23403,7 +24917,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) From f1e05bff1492b9c2960f0f4d9a1515c41512041e Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Wed, 9 Aug 2017 22:04:19 -0700 Subject: [PATCH 206/551] wifi: Fix some valgrind issues due to commit 12941:466f95c4105d --- src/wifi/model/dcf-manager.cc | 11 +++++++++++ src/wifi/model/dcf-manager.h | 3 +++ src/wifi/model/dcf-state.cc | 8 ++++++++ src/wifi/model/dcf-state.h | 3 +++ src/wifi/model/regular-wifi-mac.cc | 1 + 5 files changed, 26 insertions(+) diff --git a/src/wifi/model/dcf-manager.cc b/src/wifi/model/dcf-manager.cc index cabdacfbfce..ded68b7be11 100644 --- a/src/wifi/model/dcf-manager.cc +++ b/src/wifi/model/dcf-manager.cc @@ -116,6 +116,17 @@ DcfManager::~DcfManager () m_phyListener = 0; } +void +DcfManager::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + for (Ptr i : m_states) + { + i->Dispose (); + i = 0; + } +} + void DcfManager::SetupPhyListener (Ptr phy) { diff --git a/src/wifi/model/dcf-manager.h b/src/wifi/model/dcf-manager.h index bb1a4a66caf..0b384fd5f58 100644 --- a/src/wifi/model/dcf-manager.h +++ b/src/wifi/model/dcf-manager.h @@ -202,6 +202,9 @@ class DcfManager : public Object */ void NotifyCtsTimeoutResetNow (); +protected: + // Inherited from ns3::Object + void DoDispose (void); private: /** diff --git a/src/wifi/model/dcf-state.cc b/src/wifi/model/dcf-state.cc index e78554a1f3b..f59b7e431ac 100644 --- a/src/wifi/model/dcf-state.cc +++ b/src/wifi/model/dcf-state.cc @@ -55,6 +55,14 @@ DcfState::~DcfState () NS_LOG_FUNCTION (this); } +void +DcfState::DoDispose (void) +{ + NS_LOG_FUNCTION (this); + m_txop->Dispose (); + m_txop = 0; +} + void DcfState::SetAifsn (uint32_t aifsn) { diff --git a/src/wifi/model/dcf-state.h b/src/wifi/model/dcf-state.h index 51a385eb401..79f881ca718 100644 --- a/src/wifi/model/dcf-state.h +++ b/src/wifi/model/dcf-state.h @@ -146,6 +146,9 @@ class DcfState : public Object protected: friend class DcfManager; + // Inherited from ns3::Object + void DoDispose (void); + /** * Return the current number of backoff slots. * diff --git a/src/wifi/model/regular-wifi-mac.cc b/src/wifi/model/regular-wifi-mac.cc index 0cba59a7ce0..ddb001b5697 100644 --- a/src/wifi/model/regular-wifi-mac.cc +++ b/src/wifi/model/regular-wifi-mac.cc @@ -110,6 +110,7 @@ RegularWifiMac::DoDispose () i->second = 0; } + m_dcfManager->Dispose (); m_dcfManager = 0; } From 17e66a13d644aca9ad673ccc915a9f08b1882b12 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 10 Aug 2017 06:33:25 -0700 Subject: [PATCH 207/551] test: Reduce scope of valgrind example tests to speed execution time Some example programs are tested under different configurations; as long as we test one of these configurations, there is little to gain by valgrind testing additional configurations, but './test.py -g' will take longer. So in general, only one or a limited number of configurations of an example are valgrind tested. --- examples/wireless/examples-to-run.py | 24 +- src/traffic-control/test/examples-to-run.py | 40 +-- src/wifi/test/examples-to-run.py | 278 ++++++++++---------- 3 files changed, 171 insertions(+), 171 deletions(-) diff --git a/examples/wireless/examples-to-run.py b/examples/wireless/examples-to-run.py index 17432eca155..9b53598d47f 100755 --- a/examples/wireless/examples-to-run.py +++ b/examples/wireless/examples-to-run.py @@ -10,12 +10,12 @@ cpp_examples = [ ("mixed-wired-wireless", "True", "True"), ("multirate --totalTime=0.3s --rateManager=ns3::AarfcdWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::AmrrWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::CaraWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::IdealWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::MinstrelWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::OnoeWifiManager", "True", "True"), - ("multirate --totalTime=0.3s --rateManager=ns3::RraaWifiManager", "True", "True"), + ("multirate --totalTime=0.3s --rateManager=ns3::AmrrWifiManager", "True", "False"), + ("multirate --totalTime=0.3s --rateManager=ns3::CaraWifiManager", "True", "False"), + ("multirate --totalTime=0.3s --rateManager=ns3::IdealWifiManager", "True", "False"), + ("multirate --totalTime=0.3s --rateManager=ns3::MinstrelWifiManager", "True", "False"), + ("multirate --totalTime=0.3s --rateManager=ns3::OnoeWifiManager", "True", "False"), + ("multirate --totalTime=0.3s --rateManager=ns3::RraaWifiManager", "True", "False"), ("wifi-adhoc", "False", "True"), # Takes too long to run ("wifi-ap --verbose=0", "True", "True"), # Don't let it spew to stdout ("wifi-clear-channel-cmu", "False", "True"), # Requires specific hardware @@ -25,8 +25,8 @@ ("wifi-simple-interference", "True", "True"), ("wifi-wired-bridging", "True", "True"), ("power-adaptation-distance --manager=ns3::ParfWifiManager --outputFileName=parf --steps=5 --stepsSize=10", "True", "True"), - ("power-adaptation-distance --manager=ns3::AparfWifiManager --outputFileName=aparf --steps=5 --stepsSize=10", "True", "True"), - ("power-adaptation-distance --manager=ns3::RrpaaWifiManager --outputFileName=rrpaa --steps=5 --stepsSize=10", "True", "True"), + ("power-adaptation-distance --manager=ns3::AparfWifiManager --outputFileName=aparf --steps=5 --stepsSize=10", "True", "False"), + ("power-adaptation-distance --manager=ns3::RrpaaWifiManager --outputFileName=rrpaa --steps=5 --stepsSize=10", "True", "False"), ("ofdm-ht-validation", "True", "True"), ("ofdm-validation", "True", "True"), ("ofdm-vht-validation", "True", "True"), @@ -41,13 +41,13 @@ ("wifi-multi-tos --simulationTime=1 --nWifi=16 --useRts=1 --useShortGuardInterval=1", "True", "True"), ("wifi-tcp", "True", "True"), ("wifi-spectrum-per-example --distance=52 --index=3 --wifiType=ns3::SpectrumWifiPhy --simulationTime=1", "True", "True"), - ("wifi-spectrum-per-example --distance=24 --index=31 --wifiType=ns3::YansWifiPhy --simulationTime=1", "True", "True"), + ("wifi-spectrum-per-example --distance=24 --index=31 --wifiType=ns3::YansWifiPhy --simulationTime=1", "True", "False"), ("wifi-spectrum-per-interference --distance=24 --index=31 --simulationTime=1 --waveformPower=0.1", "True", "True"), ("wifi-spectrum-saturation-example --simulationTime=1 --index=63", "True", "True"), ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211n_5GHZ --simulationTime=1", "True", "True"), - ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211n_5GHZ --apRaa=Ideal --staRaa=Ideal --simulationTime=1", "True", "True"), - ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211ac --simulationTime=1", "True", "True"), - ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211ac --apRaa=Ideal --staRaa=Ideal --simulationTime=1", "True", "True"), + ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211n_5GHZ --apRaa=Ideal --staRaa=Ideal --simulationTime=1", "True", "False"), + ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211ac --simulationTime=1", "True", "False"), + ("wifi-backward-compatibility --apVersion=80211a --staVersion=80211ac --apRaa=Ideal --staRaa=Ideal --simulationTime=1", "True", "False"), ] # A list of Python examples to run in order to ensure that they remain diff --git a/src/traffic-control/test/examples-to-run.py b/src/traffic-control/test/examples-to-run.py index a4c4816e1bc..1743b4cdc2e 100644 --- a/src/traffic-control/test/examples-to-run.py +++ b/src/traffic-control/test/examples-to-run.py @@ -9,32 +9,32 @@ # See test.py for more information. cpp_examples = [ ("adaptive-red-tests --testNumber=1", "True", "True"), - ("adaptive-red-tests --testNumber=2", "True", "True"), - ("adaptive-red-tests --testNumber=6", "True", "True"), - ("adaptive-red-tests --testNumber=7", "True", "True"), - ("adaptive-red-tests --testNumber=8", "True", "True"), - ("adaptive-red-tests --testNumber=9", "True", "True"), - ("adaptive-red-tests --testNumber=10", "True", "True"), - ("adaptive-red-tests --testNumber=12", "True", "True"), - ("adaptive-red-tests --testNumber=13", "True", "True"), - ("adaptive-red-tests --testNumber=14", "True", "True"), - ("adaptive-red-tests --testNumber=15", "True", "True"), + ("adaptive-red-tests --testNumber=2", "True", "False"), + ("adaptive-red-tests --testNumber=6", "True", "False"), + ("adaptive-red-tests --testNumber=7", "True", "False"), + ("adaptive-red-tests --testNumber=8", "True", "False"), + ("adaptive-red-tests --testNumber=9", "True", "False"), + ("adaptive-red-tests --testNumber=10", "True", "False"), + ("adaptive-red-tests --testNumber=12", "True", "False"), + ("adaptive-red-tests --testNumber=13", "True", "False"), + ("adaptive-red-tests --testNumber=14", "True", "False"), + ("adaptive-red-tests --testNumber=15", "True", "False"), ("codel-vs-pfifo-asymmetric --routerWanQueueDiscType=PfifoFast --simDuration=10", "True", "True"), - ("codel-vs-pfifo-asymmetric --routerWanQueueDiscType=CoDel --simDuration=10", "True", "True"), - ("codel-vs-pfifo-basic-test --queueDiscType=PfifoFast --simDuration=10", "True", "True"), - ("codel-vs-pfifo-basic-test --queueDiscType=CoDel --simDuration=10", "True", "True"), + ("codel-vs-pfifo-asymmetric --routerWanQueueDiscType=CoDel --simDuration=10", "True", "False"), + ("codel-vs-pfifo-basic-test --queueDiscType=PfifoFast --simDuration=10", "True", "False"), + ("codel-vs-pfifo-basic-test --queueDiscType=CoDel --simDuration=10", "True", "False"), ("pfifo-vs-red --queueDiscType=PfifoFast", "True", "True"), - ("pfifo-vs-red --queueDiscType=PfifoFast --modeBytes=1", "True", "True"), + ("pfifo-vs-red --queueDiscType=PfifoFast --modeBytes=1", "True", "False"), ("pfifo-vs-red --queueDiscType=RED", "True", "True"), - ("pfifo-vs-red --queueDiscType=RED --modeBytes=1", "True", "True"), + ("pfifo-vs-red --queueDiscType=RED --modeBytes=1", "True", "False"), ("red-tests --testNumber=1", "True", "True"), - ("red-tests --testNumber=3", "True", "True"), - ("red-tests --testNumber=4", "True", "True"), - ("red-tests --testNumber=5", "True", "True"), + ("red-tests --testNumber=3", "True", "False"), + ("red-tests --testNumber=4", "True", "False"), + ("red-tests --testNumber=5", "True", "False"), ("red-vs-ared --queueDiscType=RED", "True", "True"), - ("red-vs-ared --queueDiscType=RED --modeBytes=true", "True", "True"), + ("red-vs-ared --queueDiscType=RED --modeBytes=true", "True", "False"), ("red-vs-ared --queueDiscType=ARED", "True", "True"), - ("red-vs-ared --queueDiscType=ARED --modeBytes=true", "True", "True"), + ("red-vs-ared --queueDiscType=ARED --modeBytes=true", "True", "False"), ] # A list of Python examples to run in order to ensure that they remain diff --git a/src/wifi/test/examples-to-run.py b/src/wifi/test/examples-to-run.py index 55987376c01..f1d0b54e9fe 100644 --- a/src/wifi/test/examples-to-run.py +++ b/src/wifi/test/examples-to-run.py @@ -9,83 +9,83 @@ # See test.py for more information. cpp_examples = [ ("wifi-phy-configuration --testCase=0", "True", "True"), - ("wifi-phy-configuration --testCase=1", "True", "True"), - ("wifi-phy-configuration --testCase=2", "True", "True"), - ("wifi-phy-configuration --testCase=3", "True", "True"), - ("wifi-phy-configuration --testCase=4", "True", "True"), - ("wifi-phy-configuration --testCase=5", "True", "True"), - ("wifi-phy-configuration --testCase=6", "True", "True"), - ("wifi-phy-configuration --testCase=7", "True", "True"), - ("wifi-phy-configuration --testCase=8", "True", "True"), - ("wifi-phy-configuration --testCase=9", "True", "True"), - ("wifi-phy-configuration --testCase=10", "True", "True"), - ("wifi-phy-configuration --testCase=11", "True", "True"), - ("wifi-phy-configuration --testCase=12", "True", "True"), - ("wifi-phy-configuration --testCase=13", "True", "True"), - ("wifi-phy-configuration --testCase=14", "True", "True"), - ("wifi-phy-configuration --testCase=15", "True", "True"), - ("wifi-phy-configuration --testCase=16", "True", "True"), - ("wifi-phy-configuration --testCase=17", "True", "True"), - ("wifi-phy-configuration --testCase=18", "True", "True"), + ("wifi-phy-configuration --testCase=1", "True", "False"), + ("wifi-phy-configuration --testCase=2", "True", "False"), + ("wifi-phy-configuration --testCase=3", "True", "False"), + ("wifi-phy-configuration --testCase=4", "True", "False"), + ("wifi-phy-configuration --testCase=5", "True", "False"), + ("wifi-phy-configuration --testCase=6", "True", "False"), + ("wifi-phy-configuration --testCase=7", "True", "False"), + ("wifi-phy-configuration --testCase=8", "True", "False"), + ("wifi-phy-configuration --testCase=9", "True", "False"), + ("wifi-phy-configuration --testCase=10", "True", "False"), + ("wifi-phy-configuration --testCase=11", "True", "False"), + ("wifi-phy-configuration --testCase=12", "True", "False"), + ("wifi-phy-configuration --testCase=13", "True", "False"), + ("wifi-phy-configuration --testCase=14", "True", "False"), + ("wifi-phy-configuration --testCase=15", "True", "False"), + ("wifi-phy-configuration --testCase=16", "True", "False"), + ("wifi-phy-configuration --testCase=17", "True", "False"), + ("wifi-phy-configuration --testCase=18", "True", "False"), ("wifi-manager-example --wifiManager=Aarf --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarf --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarf --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarf --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarf --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarf --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Aarf --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarf --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarf --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarf --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarf --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Aarfcd --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Amrr --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Amrr --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Amrr --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Amrr --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Amrr --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Amrr --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Amrr --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Amrr --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Amrr --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Amrr --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Amrr --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Arf --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Arf --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Arf --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Arf --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Arf --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Arf --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Arf --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Arf --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Arf --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Arf --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Arf --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Cara --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Cara --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Cara --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Cara --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Cara --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Cara --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Cara --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Cara --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Cara --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Cara --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Cara --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Onoe --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Onoe --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Onoe --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Onoe --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Onoe --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Onoe --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Onoe --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Onoe --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Onoe --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Onoe --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Onoe --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Rraa --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Rraa --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Rraa --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Rraa --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Rraa --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Rraa --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Rraa --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Rraa --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Rraa --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Rraa --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Rraa --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Minstrel --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Minstrel --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Minstrel --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-5MHz --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Minstrel --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Minstrel --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Minstrel --standard=802.11-5MHz --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-5MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11-5MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -96,7 +96,7 @@ ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), @@ -112,20 +112,20 @@ ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -160,18 +160,18 @@ ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=MinstrelHt --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11a --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11g --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11-holland --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11-10MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11-5MHz --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11b --serverChannelWidth=22 --clientChannelWidth=22 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11g --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11-holland --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11-10MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11-5MHz --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -182,7 +182,7 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "False", "False"), @@ -198,20 +198,20 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11n-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -246,26 +246,26 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ac --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=400 --clientShortGuardInterval=400 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=80 --clientChannelWidth=80 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -317,15 +317,15 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "True"), - ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "True"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-5GHz --serverChannelWidth=160 --clientChannelWidth=160 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=1 --clientNss=1 --stepTime=0.1", "True", "False"), + ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "True", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=20 --clientChannelWidth=20 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=800 --clientShortGuardInterval=800 --serverNss=2 --clientNss=2 --stepTime=0.1", "False", "False"), @@ -344,7 +344,7 @@ ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=1600 --clientShortGuardInterval=1600 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("wifi-manager-example --wifiManager=Ideal --standard=802.11ax-2.4GHz --serverChannelWidth=40 --clientChannelWidth=40 --serverShortGuardInterval=3200 --clientShortGuardInterval=3200 --serverNss=4 --clientNss=4 --stepTime=0.1", "False", "False"), ("test-interference-helper --enableCapture=0 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=0", "True", "True"), - ("test-interference-helper --enableCapture=1 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=1", "True", "True"), + ("test-interference-helper --enableCapture=1 --txPowerA=5 --txPowerB=15 --delay=10 --txModeA=OfdmRate6Mbps --txModeB=OfdmRate6Mbps --checkResults=1 --expectRxASuccessfull=0 --expectRxBSuccessfull=1", "True", "False"), ] # A list of Python examples to run in order to ensure that they remain From bf0870ce76a1d639d1aac3339fe502e873eae40c Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 10 Aug 2017 06:35:53 -0700 Subject: [PATCH 208/551] olsr: Extend DoDispose() to clear valgrind --- src/olsr/model/olsr-routing-protocol.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/olsr/model/olsr-routing-protocol.cc b/src/olsr/model/olsr-routing-protocol.cc index 1c316882c46..b35c238954f 100644 --- a/src/olsr/model/olsr-routing-protocol.cc +++ b/src/olsr/model/olsr-routing-protocol.cc @@ -244,6 +244,7 @@ void RoutingProtocol::DoDispose () if (m_recvSocket) { m_recvSocket->Close (); + m_recvSocket = 0; } for (std::map< Ptr, Ipv4InterfaceAddress >::iterator iter = m_sendSockets.begin (); @@ -252,6 +253,7 @@ void RoutingProtocol::DoDispose () iter->first->Close (); } m_sendSockets.clear (); + m_table.clear (); Ipv4RoutingProtocol::DoDispose (); } From ea9bfe9fd4a500ee45c04aaa7af4a2ecc4e34fd9 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 10 Aug 2017 07:01:46 -0700 Subject: [PATCH 209/551] wifi: Fix valgrind issue in test --- src/wifi/test/wifi-aggregation-test.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/wifi/test/wifi-aggregation-test.cc b/src/wifi/test/wifi-aggregation-test.cc index 8961c4e832c..701834ecb49 100644 --- a/src/wifi/test/wifi-aggregation-test.cc +++ b/src/wifi/test/wifi-aggregation-test.cc @@ -246,6 +246,7 @@ AmpduAggregationTest::DoRun (void) m_edca->Dispose (); m_edca = 0; + m_dcfManager->Dispose (); m_dcfManager = 0; } From 2c92eec27292efe6573a7d24773ddb461d0f775e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Thu, 10 Aug 2017 22:44:13 +0300 Subject: [PATCH 210/551] lte: Fix uninitialized variable --- src/lte/model/lte-enb-rrc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index f11ca538ba5..ffd8a1ddba6 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -1452,7 +1452,7 @@ UeManager::BuildNonCriticalExtentionConfigurationCa () component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.havePdschConfigDedicated = true; component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.pdschConfigDedicated.pa = LteRrcSap::PdschConfigDedicated::dB0; component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.haveUlConfiguration = true; - component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.haveAntennaInfoDedicated = true; + component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.haveAntennaInfoUlDedicated = true; component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.antennaInfoUl.transmissionMode = m_rrc->m_defaultTransmissionMode; component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.pushConfigDedicatedSCell.nPuschIdentity = 0; component.radioResourceConfigDedicateSCell.physicalConfigDedicatedSCell.ulPowerControlDedicatedSCell.pSrsOffset = 0; From 2ac1957c185e562323167bbe5dedad9638633ce2 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Sat, 12 Aug 2017 21:16:35 +0300 Subject: [PATCH 211/551] lte: Deserialize haveRadioResourceConfigDedicatedSCell --- src/lte/model/lte-rrc-header.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index efb03535957..590aa61d6b7 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -2617,6 +2617,7 @@ RrcAsn1Header::Print (std::ostream &os) const // Deserialize RadioResourceConfigCommonSCell NS_ASSERT (sCellToAddMod_r10[1]); bIterator = DeserializeRadioResourceConfigCommonSCell (&sctam.radioResourceConfigCommonSCell, bIterator); + sctam.haveRadioResourceConfigDedicatedSCell = sCellToAddMod_r10[0]; if (sCellToAddMod_r10[0]) { //Deserialize RadioResourceConfigDedicatedSCell From fcd45cda9f659375ad200c8e0e1ac0b36f7f03dc Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Sat, 12 Aug 2017 21:12:40 +0300 Subject: [PATCH 212/551] lte: Fix antennaInfoUl.transmissionMode deserialization --- src/lte/model/lte-rrc-header.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lte/model/lte-rrc-header.cc b/src/lte/model/lte-rrc-header.cc index 590aa61d6b7..9900bdca29b 100644 --- a/src/lte/model/lte-rrc-header.cc +++ b/src/lte/model/lte-rrc-header.cc @@ -2817,7 +2817,7 @@ RrcAsn1Header::Print (std::ostream &os) const int txmode; bIterator = DeserializeEnum (8,&txmode,bIterator); - pcdsc->antennaInfo.transmissionMode = txmode; + pcdsc->antennaInfoUl.transmissionMode = txmode; if (codebookSubsetRestrictionPresent[0]) { From 9c6fd63995734abfd292d48c09747bda81d1c3db Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Sun, 13 Aug 2017 18:00:45 -0700 Subject: [PATCH 213/551] documentation: Make script run correctly on symlinked path --- doc/doxygen.warnings.report.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/doxygen.warnings.report.sh b/doc/doxygen.warnings.report.sh index 8c085a0e382..41be0360eb9 100755 --- a/doc/doxygen.warnings.report.sh +++ b/doc/doxygen.warnings.report.sh @@ -6,7 +6,7 @@ me=$(basename $0) DIR="$(dirname $0)" # Trick to get the absolute path, since doxygen prefixes errors that way -ROOT=$(cd "$DIR/.."; pwd) +ROOT=$(cd "$DIR/.."; pwd -P) # Known log files STANDARDLOGFILE=doxygen.log From 8d13ef312d5234cd150a05136f0a883b33f6a84c Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 16 Aug 2017 19:00:22 +0300 Subject: [PATCH 214/551] core: spelling fixes --- src/core/model/int64x64.h | 2 +- src/core/model/object-base.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core/model/int64x64.h b/src/core/model/int64x64.h index 5c4a22d0a39..b50bbac4db2 100644 --- a/src/core/model/int64x64.h +++ b/src/core/model/int64x64.h @@ -151,7 +151,7 @@ inline bool operator >= (const int64x64_t & lhs, const int64x64_t & rhs) * Output streamer for int64x64_t. * * Values are printed with the following format flags - * (independent of the the stream flags): + * (independent of the stream flags): * - `showpos` * - `left` * diff --git a/src/core/model/object-base.h b/src/core/model/object-base.h index d31c5cd790c..8c43cd8bd0b 100644 --- a/src/core/model/object-base.h +++ b/src/core/model/object-base.h @@ -158,7 +158,7 @@ class ObjectBase /** * Set a single attribute without raising errors. * - * If the atttribute could not be set this will return \c false, + * If the attribute could not be set this will return \c false, * but not raise any errors. * * \param [in] name The name of the attribute to set. From 6691af358cb051aa6146991af8c87eb100f31358 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 16 Aug 2017 19:01:10 +0300 Subject: [PATCH 215/551] config-store: spelling fixes --- src/config-store/model/attribute-iterator.h | 2 +- src/config-store/model/display-functions.h | 2 +- src/config-store/model/xml-config.cc | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/config-store/model/attribute-iterator.h b/src/config-store/model/attribute-iterator.h index b6c096fff05..1c855f680a5 100644 --- a/src/config-store/model/attribute-iterator.h +++ b/src/config-store/model/attribute-iterator.h @@ -39,7 +39,7 @@ class AttributeIterator virtual ~AttributeIterator (); /** - * Start the processs of iterating all objects from the root namespace object + * Start the process of iterating all objects from the root namespace object */ void Iterate (void); protected: diff --git a/src/config-store/model/display-functions.h b/src/config-store/model/display-functions.h index 41d1c260b7c..467d301deca 100644 --- a/src/config-store/model/display-functions.h +++ b/src/config-store/model/display-functions.h @@ -119,7 +119,7 @@ load_clicked_default (GtkButton *button, gpointer user_data); /** * This functions is called whenever there is a change in the value of an attribute * If the input value is ok, it will be updated in the default value and in the - * gui, otherwise, it won't be updated in both. + * GUI, otherwise, it won't be updated in both. */ void cell_edited_callback_config_default (GtkCellRendererText *cell, gchar *path_string, diff --git a/src/config-store/model/xml-config.cc b/src/config-store/model/xml-config.cc index 3aae5731bb0..29ba66eea57 100644 --- a/src/config-store/model/xml-config.cc +++ b/src/config-store/model/xml-config.cc @@ -52,14 +52,14 @@ XmlConfigSave::SetFilename (std::string filename) m_writer = xmlNewTextWriterFilename (filename.c_str (), 0); if (m_writer == NULL) { - NS_FATAL_ERROR ("Error creating the xml writer"); + NS_FATAL_ERROR ("Error creating the XML writer"); } rc = xmlTextWriterSetIndent (m_writer, 1); if (rc < 0) { NS_FATAL_ERROR ("Error at xmlTextWriterSetIndent"); } - /* Start the document with the xml default for the version, + /* Start the document with the XML default for the version, * encoding utf-8 and the default for the standalone * declaration. */ rc = xmlTextWriterStartDocument (m_writer, NULL, "utf-8", NULL); @@ -68,7 +68,7 @@ XmlConfigSave::SetFilename (std::string filename) NS_FATAL_ERROR ("Error at xmlTextWriterStartDocument"); } - /* Start an element named "ns3". Since thist is the first + /* Start an element named "ns3". Since this is the first * element, this will be the root element of the document. */ rc = xmlTextWriterStartElement (m_writer, BAD_CAST "ns3"); if (rc < 0) From 8f180a8e49cb34b1ed26deef3b49e1cdfee0f45f Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 16 Aug 2017 19:13:57 +0300 Subject: [PATCH 216/551] lte: spelling fixes --- src/lte/helper/lte-helper.h | 4 ++-- src/lte/model/cqa-ff-mac-scheduler.h | 4 ++-- src/lte/model/epc-s1ap-sap.h | 2 +- src/lte/model/epc-x2-header.h | 8 ++++---- src/lte/model/epc-x2-sap.h | 4 ++-- src/lte/model/eps-bearer.h | 4 ++-- src/lte/model/fdbet-ff-mac-scheduler.h | 6 +++--- src/lte/model/fdmt-ff-mac-scheduler.h | 2 +- src/lte/model/fdtbfq-ff-mac-scheduler.h | 2 +- src/lte/model/lte-amc.h | 2 +- src/lte/model/lte-control-messages.h | 2 +- src/lte/model/lte-enb-component-carrier-manager.h | 2 +- src/lte/model/lte-enb-cphy-sap.h | 2 +- src/lte/model/lte-enb-mac.h | 4 ++-- src/lte/model/lte-ffr-soft-algorithm.h | 2 +- src/lte/model/lte-handover-algorithm.h | 2 +- src/lte/model/lte-harq-phy.h | 14 +++++++------- src/lte/model/lte-rlc-am.h | 2 +- src/lte/model/lte-rlc-sap.h | 2 +- src/lte/model/lte-rrc-sap.h | 10 +++++----- src/lte/model/lte-ue-phy.h | 2 +- src/lte/model/pf-ff-mac-scheduler.h | 2 +- src/lte/model/pss-ff-mac-scheduler.h | 2 +- src/lte/model/rem-spectrum-phy.h | 4 ++-- src/lte/model/rr-ff-mac-scheduler.h | 2 +- src/lte/model/tdbet-ff-mac-scheduler.h | 2 +- src/lte/model/tdmt-ff-mac-scheduler.h | 2 +- src/lte/model/tdtbfq-ff-mac-scheduler.h | 2 +- src/lte/model/tta-ff-mac-scheduler.h | 2 +- src/lte/test/lte-test-cqa-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-pss-ff-mac-scheduler.cc | 4 ++-- src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc | 4 ++-- src/lte/test/test-lte-handover-target.cc | 10 +++++----- 34 files changed, 63 insertions(+), 63 deletions(-) diff --git a/src/lte/helper/lte-helper.h b/src/lte/helper/lte-helper.h index 946a3266a1e..d10d1d4028d 100644 --- a/src/lte/helper/lte-helper.h +++ b/src/lte/helper/lte-helper.h @@ -734,7 +734,7 @@ class LteHelper : public Object */ void DoDeActivateDedicatedEpsBearer (Ptr ueDevice, Ptr enbDevice, uint8_t bearerId); - /// Function that performs a channel model initialization of all componment carriers + /// Function that performs a channel model initialization of all component carriers void ChannelModelInitialization (void); /** @@ -841,7 +841,7 @@ class LteHelper : public Object * The `UseCa` attribute. If true, Carrier Aggregation is enabled. * Hence, the helper will expect a valid component carrier map * If it is false, the component carrier will be created within the LteHelper - * this is to mantain the backwards compatibility with user script + * this is to maintain the backwards compatibility with user script */ bool m_useCa; diff --git a/src/lte/model/cqa-ff-mac-scheduler.h b/src/lte/model/cqa-ff-mac-scheduler.h index ba895769c3b..dfa5cc86d79 100644 --- a/src/lte/model/cqa-ff-mac-scheduler.h +++ b/src/lte/model/cqa-ff-mac-scheduler.h @@ -375,12 +375,12 @@ class CqaFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs // HARQ attributes - bool m_harqOn; ///< m_harqOn when false inhibit te HARQ mechanisms (by default active) + bool m_harqOn; ///< m_harqOn when false inhibit the HARQ mechanisms (by default active) std::map m_dlHarqCurrentProcessId; ///< DL HARQ process ID //HARQ status // 0: process Id available diff --git a/src/lte/model/epc-s1ap-sap.h b/src/lte/model/epc-s1ap-sap.h index f7ff7e30905..5feb8658045 100644 --- a/src/lte/model/epc-s1ap-sap.h +++ b/src/lte/model/epc-s1ap-sap.h @@ -34,7 +34,7 @@ namespace ns3 { /** * \ingroup lte * - * Base class that definces EPC S1-AP Service Access Point (SAP) interface. + * Base class that defines EPC S1-AP Service Access Point (SAP) interface. */ class EpcS1apSap { diff --git a/src/lte/model/epc-x2-header.h b/src/lte/model/epc-x2-header.h index 59cdaaa856b..25ea28449fd 100644 --- a/src/lte/model/epc-x2-header.h +++ b/src/lte/model/epc-x2-header.h @@ -184,7 +184,7 @@ class EpcX2HandoverRequestHeader : public Header void SetBearers (std::vector bearers); /** - * Get UE Aggregrate Max Bit Rate Downlink function + * Get UE Aggregate Max Bit Rate Downlink function * \returns the UE aggregate max bit rate downlink */ uint64_t GetUeAggregateMaxBitRateDownlink () const; @@ -224,8 +224,8 @@ class EpcX2HandoverRequestHeader : public Header uint16_t m_cause; ///< cause uint16_t m_targetCellId; ///< target cell ID uint32_t m_mmeUeS1apId; ///< MME UE S1 AP ID - uint64_t m_ueAggregateMaxBitRateDownlink; ///< aggregrate max bit rate downlink - uint64_t m_ueAggregateMaxBitRateUplink; ///< aggregrate max bit rate upink + uint64_t m_ueAggregateMaxBitRateDownlink; ///< aggregate max bit rate downlink + uint64_t m_ueAggregateMaxBitRateUplink; ///< aggregate max bit rate uplink std::vector m_erabsToBeSetupList; ///< ERAB to be setup list }; @@ -361,7 +361,7 @@ class EpcX2HandoverPreparationFailureHeader : public Header /** * Get criticality diagnostics function - * \returns the criticality diagnsotics + * \returns the criticality diagnostics */ uint16_t GetCriticalityDiagnostics () const; /** diff --git a/src/lte/model/epc-x2-sap.h b/src/lte/model/epc-x2-sap.h index d675d578fb9..329fd32eb4d 100644 --- a/src/lte/model/epc-x2-sap.h +++ b/src/lte/model/epc-x2-sap.h @@ -181,7 +181,7 @@ class EpcX2Sap */ struct CompositeAvailCapacity { - uint16_t cellCapacityClassValue; ///< cell cparacity class value + uint16_t cellCapacityClassValue; ///< cell capacity class value uint16_t capacityValue; ///< capacity value }; @@ -656,7 +656,7 @@ class EpcX2SpecificEpcX2SapUser : public EpcX2SapUser virtual void RecvLoadInformation (LoadInformationParams params); /** - * Receive resource status update functiion + * Receive resource status update function * \param params the receive resource status update */ virtual void RecvResourceStatusUpdate (ResourceStatusUpdateParams params); diff --git a/src/lte/model/eps-bearer.h b/src/lte/model/eps-bearer.h index cd77022e56a..297329c7adf 100644 --- a/src/lte/model/eps-bearer.h +++ b/src/lte/model/eps-bearer.h @@ -33,7 +33,7 @@ namespace ns3 { struct GbrQosInformation { /** - * Default constructor, inizializes member variables to zero or equivalent + * Default constructor, initializes member variables to zero or equivalent */ GbrQosInformation (); @@ -51,7 +51,7 @@ struct GbrQosInformation struct AllocationRetentionPriority { /** - * Default constructor, inizializes member variables to zero or equivalent + * Default constructor, initializes member variables to zero or equivalent */ AllocationRetentionPriority (); uint8_t priorityLevel; ///< 1-15; 1 = highest diff --git a/src/lte/model/fdbet-ff-mac-scheduler.h b/src/lte/model/fdbet-ff-mac-scheduler.h index 8527e56818e..80311240dba 100644 --- a/src/lte/model/fdbet-ff-mac-scheduler.h +++ b/src/lte/model/fdbet-ff-mac-scheduler.h @@ -135,7 +135,7 @@ class FdBetFfMacScheduler : public FfMacScheduler /** * Csched LC config request function - * \param params the CSched LC config requst parameters + * \param params the CSched LC config request parameters */ void DoCschedLcConfigReq (const struct FfMacCschedSapProvider::CschedLcConfigReqParameters& params); @@ -200,7 +200,7 @@ class FdBetFfMacScheduler : public FfMacScheduler void DoSchedUlTriggerReq (const struct FfMacSchedSapProvider::SchedUlTriggerReqParameters& params); /** - * Sched UL noise inteference request function + * Sched UL noise interference request function * \param params the Sched UL noise interference request parameters */ void DoSchedUlNoiseInterferenceReq (const struct FfMacSchedSapProvider::SchedUlNoiseInterferenceReqParameters& params); @@ -364,7 +364,7 @@ class FdBetFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/fdmt-ff-mac-scheduler.h b/src/lte/model/fdmt-ff-mac-scheduler.h index bedac4e303e..97f7864a41c 100644 --- a/src/lte/model/fdmt-ff-mac-scheduler.h +++ b/src/lte/model/fdmt-ff-mac-scheduler.h @@ -357,7 +357,7 @@ class FdMtFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/fdtbfq-ff-mac-scheduler.h b/src/lte/model/fdtbfq-ff-mac-scheduler.h index 3d83c38c1e8..b57fe373685 100644 --- a/src/lte/model/fdtbfq-ff-mac-scheduler.h +++ b/src/lte/model/fdtbfq-ff-mac-scheduler.h @@ -396,7 +396,7 @@ class FdTbfqFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/lte-amc.h b/src/lte/model/lte-amc.h index a298e7f2ad8..bb3811bf1e7 100644 --- a/src/lte/model/lte-amc.h +++ b/src/lte/model/lte-amc.h @@ -104,7 +104,7 @@ class LteAmc : public Object uint8_t rbgSize = 0); /** - * \brief Get a proper CQI for the spectrale efficiency value. + * \brief Get a proper CQI for the spectral efficiency value. * In order to assure a fewer block error rate, the AMC chooses the lower CQI value * for a given spectral efficiency * \param s the spectral efficiency diff --git a/src/lte/model/lte-control-messages.h b/src/lte/model/lte-control-messages.h index 29afec9d68c..2a2ac394bbf 100644 --- a/src/lte/model/lte-control-messages.h +++ b/src/lte/model/lte-control-messages.h @@ -49,7 +49,7 @@ class LteControlMessage : public SimpleRefCount * LteEnbPhy::ReceiveLteControlMessageList in order to remove the ones * that has been already handoff by the eNB for avoiding propagation of * spurious messages. When new messaged have to been added, consider to - * update the switch statement implementing teh filtering. + * update the switch statement implementing the filtering. */ enum MessageType { diff --git a/src/lte/model/lte-enb-component-carrier-manager.h b/src/lte/model/lte-enb-component-carrier-manager.h index cb19b927be3..216e0e82bff 100644 --- a/src/lte/model/lte-enb-component-carrier-manager.h +++ b/src/lte/model/lte-enb-component-carrier-manager.h @@ -172,7 +172,7 @@ class LteEnbComponentCarrierManager : public Object std::map > m_ueAttached;//!< The map that contains the rnti, lcid, SAP of the RLC instance std::map > m_rlcLcInstantiated; //!< This map contains logical channel configuration per flow Id (rnti, lcid). - std::map m_enabledComponentCarrier; //!< This map tells for each rnti the number of enabled component carrier.s + std::map m_enabledComponentCarrier; //!< This map tells for each RNTI the number of enabled component carriers. std::map m_ueState; //!< Map of RRC states per UE (rnti, state), e.g. CONNECTED_NORMALLY uint16_t m_noOfComponentCarriers; //!< The number component of carriers that are supported by this eNb. // pointer to RRC object for direct function calls, e.g. when CCM needs to obtain diff --git a/src/lte/model/lte-enb-cphy-sap.h b/src/lte/model/lte-enb-cphy-sap.h index 392c085229a..a4e9c308200 100644 --- a/src/lte/model/lte-enb-cphy-sap.h +++ b/src/lte/model/lte-enb-cphy-sap.h @@ -73,7 +73,7 @@ class LteEnbCphySapProvider virtual void AddUe (uint16_t rnti) = 0; /** - * Remove an UE from the the cell + * Remove an UE from the cell * * \param rnti the UE id relative to this cell */ diff --git a/src/lte/model/lte-enb-mac.h b/src/lte/model/lte-enb-mac.h index aaf9634f4a1..89dd5a50f74 100644 --- a/src/lte/model/lte-enb-mac.h +++ b/src/lte/model/lte-enb-mac.h @@ -64,7 +64,7 @@ class LteEnbMac : public Object friend class EnbMacMemberFfMacCschedSapUser; /// allow EnbMacMemberLteEnbPhySapUser class friend access friend class EnbMacMemberLteEnbPhySapUser; - /// allow MemberLteCcmMacSapProvider class friend ccess + /// allow MemberLteCcmMacSapProvider class friend access friend class MemberLteCcmMacSapProvider; public: @@ -442,7 +442,7 @@ class LteEnbMac : public Object }; /** - * map storing as key the random acccess preamble IDs allocated for + * map storing as key the random access preamble IDs allocated for * non-contention based access, and as value the associated info * */ diff --git a/src/lte/model/lte-ffr-soft-algorithm.h b/src/lte/model/lte-ffr-soft-algorithm.h index e02ac6b0280..4ba4bd466c9 100644 --- a/src/lte/model/lte-ffr-soft-algorithm.h +++ b/src/lte/model/lte-ffr-soft-algorithm.h @@ -121,7 +121,7 @@ class LteFfrSoftAlgorithm : public LteFfrAlgorithm uint8_t m_dlEdgeSubBandOffset; ///< DL edge subband offset uint8_t m_dlEdgeSubBandwidth; ///< DL edge subbandwidth - uint8_t m_ulCommonSubBandwidth; ///< UL commmon subbandwidth + uint8_t m_ulCommonSubBandwidth; ///< UL common subbandwidth uint8_t m_ulEdgeSubBandOffset; ///< UL edge subband offset uint8_t m_ulEdgeSubBandwidth; ///< UL edge subbandwidth diff --git a/src/lte/model/lte-handover-algorithm.h b/src/lte/model/lte-handover-algorithm.h index 909066da721..0cc85f2e230 100644 --- a/src/lte/model/lte-handover-algorithm.h +++ b/src/lte/model/lte-handover-algorithm.h @@ -36,7 +36,7 @@ class LteHandoverManagementSapProvider; * \brief The abstract base class of a handover algorithm that operates using * the Handover Management SAP interface. * - * Handover algorithm receives measurement reports from an eNode RRC instance + * Handover algorithm receives measurement reports from an eNodeB RRC instance * and tells the eNodeB RRC instance when to do a handover. * * This class is an abstract class intended to be inherited by subclasses that diff --git a/src/lte/model/lte-harq-phy.h b/src/lte/model/lte-harq-phy.h index 172038a3570..f45ef2bec99 100644 --- a/src/lte/model/lte-harq-phy.h +++ b/src/lte/model/lte-harq-phy.h @@ -50,7 +50,7 @@ typedef std::vector HarqProcessInfoList_t; ///< HarqP /** * \ingroup lte * \brief The LteHarqPhy class implements the HARQ functionalities related to PHY layer - *(i.e., decodification buffers for incremental redundancy managment) + *(i.e., decodification buffers for incremental redundancy management) * */ class LteHarqPhy : public SimpleRefCount @@ -67,7 +67,7 @@ class LteHarqPhy : public SimpleRefCount void SubframeIndication (uint32_t frameNo, uint32_t subframeNo); /** - * \brief Return the cumulated MI of the HARQ procId in case of retranmissions + * \brief Return the cumulated MI of the HARQ procId in case of retransmissions * for DL (asynchronous) * \param harqProcId the HARQ proc id * \param layer layer no. (for MIMO spatial multiplexing) @@ -76,16 +76,16 @@ class LteHarqPhy : public SimpleRefCount double GetAccumulatedMiDl (uint8_t harqProcId, uint8_t layer); /** - * \brief Return the info of the HARQ procId in case of retranmissions + * \brief Return the info of the HARQ procId in case of retransmissions * for DL (asynchronous) * \param harqProcId the HARQ proc id - * \param layer layer no. (for MIMO spatail multiplexing) + * \param layer layer no. (for MIMO spatial multiplexing) * \return the vector of the info related to HARQ proc Id */ HarqProcessInfoList_t GetHarqProcessInfoDl (uint8_t harqProcId, uint8_t layer); /** - * \brief Return the cumulated MI of the HARQ procId in case of retranmissions + * \brief Return the cumulated MI of the HARQ procId in case of retransmissions * for UL (synchronous) * \param rnti the RNTI of the transmitter * \return the MI accumulated @@ -93,7 +93,7 @@ class LteHarqPhy : public SimpleRefCount double GetAccumulatedMiUl (uint16_t rnti); /** - * \brief Return the info of the HARQ procId in case of retranmissions + * \brief Return the info of the HARQ procId in case of retransmissions * for UL (asynchronous) * \param rnti the RNTI of the transmitter * \param harqProcId the HARQ proc id @@ -105,7 +105,7 @@ class LteHarqPhy : public SimpleRefCount * \brief Update the Info associated to the decodification of an HARQ process * for DL (asynchronous) * \param id the HARQ proc id - * \param layer layer no. (for MIMO spatail multiplexing) + * \param layer layer no. (for MIMO spatial multiplexing) * \param mi the new MI * \param infoBytes the no. of bytes of info * \param codeBytes the total no. of bytes txed diff --git a/src/lte/model/lte-rlc-am.h b/src/lte/model/lte-rlc-am.h index fdd42958e6a..383c64332b8 100644 --- a/src/lte/model/lte-rlc-am.h +++ b/src/lte/model/lte-rlc-am.h @@ -197,7 +197,7 @@ class LteRlcAm : public LteRlc uint16_t m_pollPdu; ///< poll PDU uint16_t m_pollByte; ///< poll byte - bool m_txOpportunityForRetxAlwaysBigEnough; ///< transmit opportinity for retransmit? + bool m_txOpportunityForRetxAlwaysBigEnough; ///< transmit opportunity for retransmit? bool m_pollRetransmitTimerJustExpired; ///< poll retransmit timer just expired? /** diff --git a/src/lte/model/lte-rlc-sap.h b/src/lte/model/lte-rlc-sap.h index 7e23cc2f72e..8b42fcc22d6 100644 --- a/src/lte/model/lte-rlc-sap.h +++ b/src/lte/model/lte-rlc-sap.h @@ -62,7 +62,7 @@ class LteRlcSapProvider * See 3GPP 36.322 Radio Link Control (RLC) protocol specification * * This is the RLC SAP User - * (i.e. the part of the SAP that contains the PDCP methos called by the RLC) + * (i.e. the part of the SAP that contains the PDCP methods called by the RLC) */ class LteRlcSapUser { diff --git a/src/lte/model/lte-rrc-sap.h b/src/lte/model/lte-rrc-sap.h index 106c343b29f..5e4abc4d10f 100644 --- a/src/lte/model/lte-rrc-sap.h +++ b/src/lte/model/lte-rrc-sap.h @@ -504,7 +504,7 @@ class LteRrcSap RESET } type; ///< action type MobilityStateParameters mobilityStateParameters; ///< mobility state parameters - SpeedStateScaleFactors timeToTriggerSf; ///< time to triffer scale factors + SpeedStateScaleFactors timeToTriggerSf; ///< time to trigger scale factors }; /// MeasConfig structure @@ -522,8 +522,8 @@ class LteRrcSap MeasGapConfig measGapConfig; ///< measure gap config bool haveSmeasure; ///< have S measure? uint8_t sMeasure; ///< S measure - bool haveSpeedStatePars; ///< have speed state pars? - SpeedStatePars speedStatePars; ///< spped state pars + bool haveSpeedStatePars; ///< have speed state parameters? + SpeedStatePars speedStatePars; ///< speed state parameters }; /// CarrierFreqEutra structure @@ -787,7 +787,7 @@ class LteRrcSap bool haveUlConfiguration; ///< have UL configuration? bool haveAntennaInfoUlDedicated; ///< have antenna info UL dedicated? AntennaInfoDedicated antennaInfoUl; ///< antenna info UL - PuschConfigDedicatedSCell pushConfigDedicatedSCell; ///< PUSCH configu dedicated SCell + PuschConfigDedicatedSCell pushConfigDedicatedSCell; ///< PUSCH config dedicated SCell UlPowerControlDedicatedSCell ulPowerControlDedicatedSCell; ///< UL power control dedicated SCell bool haveSoundingRsUlConfigDedicated; ///< have sounding RS UL config dedicated? SoundingRsUlConfigDedicated soundingRsUlConfigDedicated; ///< sounding RS UL config dedicated @@ -813,7 +813,7 @@ class LteRrcSap { uint32_t sCellIndex; ///< SCell index CellIdentification cellIdentification; ///< cell identification - RadioResourceConfigCommonSCell radioResourceConfigCommonSCell; ///< radio resurce config common SCell + RadioResourceConfigCommonSCell radioResourceConfigCommonSCell; ///< radio resource config common SCell bool haveRadioResourceConfigDedicatedSCell; ///< have radio resource config dedicated SCell? RadioResourceConfigDedicatedSCell radioResourceConfigDedicateSCell; ///< radio resource config dedicated SCell }; diff --git a/src/lte/model/lte-ue-phy.h b/src/lte/model/lte-ue-phy.h index c0227fa58e5..36fe460989f 100644 --- a/src/lte/model/lte-ue-phy.h +++ b/src/lte/model/lte-ue-phy.h @@ -519,7 +519,7 @@ class LteUePhy : public LtePhy /// \todo Can be removed. uint8_t m_subframeNo; - bool m_rsReceivedPowerUpdated; ///< RS reveive power updated? + bool m_rsReceivedPowerUpdated; ///< RS receive power updated? SpectrumValue m_rsReceivedPower; ///< RS receive power bool m_rsInterferencePowerUpdated; ///< RS interference power updated? diff --git a/src/lte/model/pf-ff-mac-scheduler.h b/src/lte/model/pf-ff-mac-scheduler.h index bcff993d96f..07398886da0 100644 --- a/src/lte/model/pf-ff-mac-scheduler.h +++ b/src/lte/model/pf-ff-mac-scheduler.h @@ -381,7 +381,7 @@ class PfFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/pss-ff-mac-scheduler.h b/src/lte/model/pss-ff-mac-scheduler.h index 8078246f46f..b6c3405db07 100644 --- a/src/lte/model/pss-ff-mac-scheduler.h +++ b/src/lte/model/pss-ff-mac-scheduler.h @@ -389,7 +389,7 @@ class PssFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/rem-spectrum-phy.h b/src/lte/model/rem-spectrum-phy.h index 8a90a1a75cc..b8444a76658 100644 --- a/src/lte/model/rem-spectrum-phy.h +++ b/src/lte/model/rem-spectrum-phy.h @@ -37,7 +37,7 @@ namespace ns3 { /** * - * This minimal SpectrumPhy implemetation calculates the SINR with + * This minimal SpectrumPhy implementation calculates the SINR with * respect to the strongest signal for a given point. The original * purpose of this class is to be used to generate a * Radio Environment Map (REM) by locating several instances in a grid @@ -45,7 +45,7 @@ namespace ns3 { * amount of time. * * The assumption on which this class works is that the system - * being considered is an infrastructured radio access network using + * being considered is an infrastructure radio access network using * FDD, hence all signals will be transmitted simultaneously. */ class RemSpectrumPhy : public SpectrumPhy diff --git a/src/lte/model/rr-ff-mac-scheduler.h b/src/lte/model/rr-ff-mac-scheduler.h index fb1979a6951..79705b7c2fd 100644 --- a/src/lte/model/rr-ff-mac-scheduler.h +++ b/src/lte/model/rr-ff-mac-scheduler.h @@ -318,7 +318,7 @@ class RrFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiDl; ///< RNTI of the next user to be served next scheduling in DL uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/tdbet-ff-mac-scheduler.h b/src/lte/model/tdbet-ff-mac-scheduler.h index 96f04f54a22..5e8809e0113 100644 --- a/src/lte/model/tdbet-ff-mac-scheduler.h +++ b/src/lte/model/tdbet-ff-mac-scheduler.h @@ -360,7 +360,7 @@ class TdBetFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/tdmt-ff-mac-scheduler.h b/src/lte/model/tdmt-ff-mac-scheduler.h index cfe98a7a839..da6a982fc60 100644 --- a/src/lte/model/tdmt-ff-mac-scheduler.h +++ b/src/lte/model/tdmt-ff-mac-scheduler.h @@ -349,7 +349,7 @@ class TdMtFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/tdtbfq-ff-mac-scheduler.h b/src/lte/model/tdtbfq-ff-mac-scheduler.h index 4815cccf1cb..def8d0091ce 100644 --- a/src/lte/model/tdtbfq-ff-mac-scheduler.h +++ b/src/lte/model/tdtbfq-ff-mac-scheduler.h @@ -364,7 +364,7 @@ class TdTbfqFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/model/tta-ff-mac-scheduler.h b/src/lte/model/tta-ff-mac-scheduler.h index 54736fdbf3a..67feca9b069 100644 --- a/src/lte/model/tta-ff-mac-scheduler.h +++ b/src/lte/model/tta-ff-mac-scheduler.h @@ -349,7 +349,7 @@ class TtaFfMacScheduler : public FfMacScheduler uint16_t m_nextRntiUl; ///< RNTI of the next user to be served next scheduling in UL - uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI canbe considered valid + uint32_t m_cqiTimersThreshold; ///< # of TTIs for which a CQI can be considered valid std::map m_uesTxMode; ///< txMode of the UEs diff --git a/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc b/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc index 0b49bc98da7..a82d300e1b1 100644 --- a/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-cqa-ff-mac-scheduler.cc @@ -313,7 +313,7 @@ LenaCqaFfMacSchedulerTestCase1::DoRun (void) //Config::SetDefault ("ns3::LteEnbRrc::EpsBearerToRlcMapping", EnumValue (LteHelper::RLC_UM_ALWAYS)); // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestCqaFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestCqaFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); @@ -550,7 +550,7 @@ LenaCqaFfMacSchedulerTestCase2::DoRun (void) // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestCqaFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestCqaFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); diff --git a/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc b/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc index 501b7f14841..23a8a9454c6 100644 --- a/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-fdtbfq-ff-mac-scheduler.cc @@ -309,7 +309,7 @@ LenaFdTbfqFfMacSchedulerTestCase1::DoRun (void) //Config::SetDefault ("ns3::LteEnbRrc::EpsBearerToRlcMapping", EnumValue (LteHelper::RLC_UM_ALWAYS)); // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestFdTbfqFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestFdTbfqFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); @@ -549,7 +549,7 @@ LenaFdTbfqFfMacSchedulerTestCase2::DoRun (void) // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestFdTbfqFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestFdTbfqFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); diff --git a/src/lte/test/lte-test-pss-ff-mac-scheduler.cc b/src/lte/test/lte-test-pss-ff-mac-scheduler.cc index 6871384c8b8..fe8d1a1b514 100644 --- a/src/lte/test/lte-test-pss-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-pss-ff-mac-scheduler.cc @@ -310,7 +310,7 @@ LenaPssFfMacSchedulerTestCase1::DoRun (void) //Config::SetDefault ("ns3::LteEnbRrc::EpsBearerToRlcMapping", EnumValue (LteHelper::RLC_UM_ALWAYS)); // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestPssFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestPssFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); @@ -550,7 +550,7 @@ LenaPssFfMacSchedulerTestCase2::DoRun (void) // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestPssFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestPssFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); diff --git a/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc b/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc index bb84dfccb4b..c47f52b286a 100644 --- a/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc +++ b/src/lte/test/lte-test-tdtbfq-ff-mac-scheduler.cc @@ -309,7 +309,7 @@ LenaTdTbfqFfMacSchedulerTestCase1::DoRun (void) //Config::SetDefault ("ns3::LteEnbRrc::EpsBearerToRlcMapping", EnumValue (LteHelper::RLC_UM_ALWAYS)); // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestTdTbfqFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestTdTbfqFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); @@ -549,7 +549,7 @@ LenaTdTbfqFfMacSchedulerTestCase2::DoRun (void) // LogComponentDisableAll (LOG_LEVEL_ALL); - //LogComponentEnable ("LenaTestTdTbfqFfMacCheduler", LOG_LEVEL_ALL); + //LogComponentEnable ("LenaTestTdTbfqFfMacScheduler", LOG_LEVEL_ALL); lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisSpectrumPropagationLossModel")); diff --git a/src/lte/test/test-lte-handover-target.cc b/src/lte/test/test-lte-handover-target.cc index a717f27277b..013532c4ab8 100644 --- a/src/lte/test/test-lte-handover-target.cc +++ b/src/lte/test/test-lte-handover-target.cc @@ -135,11 +135,11 @@ class LteHandoverTargetTestCase : public TestCase uint8_t m_gridSizeX; ///< X grid size uint8_t m_gridSizeY; ///< Y grid size uint16_t m_sourceCellId; ///< source cell ID - uint16_t m_targetCellId; ///< target celll ID + uint16_t m_targetCellId; ///< target cell ID std::string m_handoverAlgorithmType; ///< handover algorithm type Ptr m_sourceEnbDev; ///< source ENB device - bool m_hasHandoverOccurred; ///< has handover occured? + bool m_hasHandoverOccurred; ///< has handover occurred? }; // end of class LteHandoverTargetTestCase @@ -191,11 +191,11 @@ LteHandoverTargetTestCase::HandoverStartCallback (std::string context, uint64_t uint64_t timeNowMs = Simulator::Now ().GetMilliSeconds (); NS_TEST_ASSERT_MSG_GT (timeNowMs, 500, - "Handover occured but too early"); + "Handover occurred but too early"); NS_TEST_ASSERT_MSG_EQ (sourceCellId, m_sourceCellId, - "Handover occured but with wrong source cell"); + "Handover occurred but with wrong source cell"); NS_TEST_ASSERT_MSG_EQ (targetCellId, m_targetCellId, - "Handover occured but with wrong target cell"); + "Handover occurred but with wrong target cell"); m_hasHandoverOccurred = true; } From 06508602410394bacfe1e8f23f75c8a2d41ea5dc Mon Sep 17 00:00:00 2001 From: Federico Guerra Date: Wed, 16 Aug 2017 16:47:41 -0700 Subject: [PATCH 217/551] mobility: Allow WaypointMobilityModel to be subclassed --- src/mobility/model/waypoint-mobility-model.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/mobility/model/waypoint-mobility-model.h b/src/mobility/model/waypoint-mobility-model.h index a16f4cd8173..6f54318152c 100644 --- a/src/mobility/model/waypoint-mobility-model.h +++ b/src/mobility/model/waypoint-mobility-model.h @@ -134,7 +134,7 @@ class WaypointMobilityModel : public MobilityModel /** * Update the underlying state corresponding to the stored waypoints */ - void Update (void) const; + virtual void Update (void) const; /** * \brief The dispose method. * @@ -157,6 +157,7 @@ class WaypointMobilityModel : public MobilityModel */ virtual Vector DoGetVelocity (void) const; +protected: /** * \brief This variable is set to true if there are no waypoints in the std::deque */ From 1352cf85db9562e653f08e9d5f264d6047ad23cf Mon Sep 17 00:00:00 2001 From: Federico Guerra Date: Wed, 16 Aug 2017 16:52:11 -0700 Subject: [PATCH 218/551] uan: (fixes #2299) WOSS integration + FH-FSK Interference rev. --- src/uan/model/uan-channel.h | 11 +++++------ src/uan/model/uan-net-device.cc | 11 +++++++++++ src/uan/model/uan-net-device.h | 4 ++-- src/uan/model/uan-phy-gen.cc | 20 +++++++++++++------- src/uan/model/uan-phy-gen.h | 8 ++++++++ src/uan/model/uan-prop-model.h | 7 +++++++ 6 files changed, 46 insertions(+), 15 deletions(-) diff --git a/src/uan/model/uan-channel.h b/src/uan/model/uan-channel.h index 144734eecfc..dd0b9b9b093 100644 --- a/src/uan/model/uan-channel.h +++ b/src/uan/model/uan-channel.h @@ -72,8 +72,8 @@ class UanChannel : public Channel * \param txPowerDb Transmission power in dB. * \param txmode UanTxMode defining modulation of transmitted packet. */ - void TxPacket (Ptr src, Ptr packet, double txPowerDb, - UanTxMode txmode); + virtual void TxPacket (Ptr src, Ptr packet, double txPowerDb, + UanTxMode txmode); /** * Adds device to receiver list for this channel. @@ -111,12 +111,12 @@ class UanChannel : public Channel * Clear all pointer references. */ void Clear (void); -private: +protected: UanDeviceList m_devList; //!< The list of devices on this channel. Ptr m_prop; //!< The propagation model. Ptr m_noise; //!< The noise model. /** Has Clear ever been called on the channel. */ - bool m_cleared; + bool m_cleared; /** * Send a packet up to the receiving UanTransducer. @@ -128,8 +128,7 @@ class UanChannel : public Channel * \param pdp PDP of arriving signal. */ void SendUp (uint32_t i, Ptr packet, double rxPowerDb, UanTxMode txMode, UanPdp pdp); - -protected: + virtual void DoDispose (void); }; // class UanChannel diff --git a/src/uan/model/uan-net-device.cc b/src/uan/model/uan-net-device.cc index 10f83868f08..6f772c3c264 100644 --- a/src/uan/model/uan-net-device.cc +++ b/src/uan/model/uan-net-device.cc @@ -78,6 +78,17 @@ UanNetDevice::Clear () } } +void +UanNetDevice::DoInitialize (void) +{ + m_phy->Initialize (); + m_mac->Initialize (); + m_channel->Initialize (); + m_trans->Initialize (); + + NetDevice::DoInitialize (); +} + void UanNetDevice::DoDispose () { diff --git a/src/uan/model/uan-net-device.h b/src/uan/model/uan-net-device.h index ddaeb73a295..8cdfad35fb3 100644 --- a/src/uan/model/uan-net-device.h +++ b/src/uan/model/uan-net-device.h @@ -190,8 +190,8 @@ class UanNetDevice : public NetDevice bool m_cleared; protected: - virtual void DoDispose (); - + virtual void DoDispose (void); + virtual void DoInitialize (void); }; // class UanNetDevice } // namespace ns3 diff --git a/src/uan/model/uan-phy-gen.cc b/src/uan/model/uan-phy-gen.cc index 15b9ab38286..671296f7fd0 100644 --- a/src/uan/model/uan-phy-gen.cc +++ b/src/uan/model/uan-phy-gen.cc @@ -150,14 +150,17 @@ UanPhyCalcSinrFhFsk::CalcSinrDb (Ptr pkt, if (std::abs (pit->GetAmp ()) > maxAmp) { maxAmp = std::abs (pit->GetAmp ()); - maxTapDelay = pit->GetDelay ().GetSeconds (); + // Modified in order to subtract delay of first tap (maxTapDelay appears to be used later in code + // as delay from first reception, not from TX time) + maxTapDelay = pit->GetDelay ().GetSeconds () - pdp.GetTap(0).GetDelay().GetSeconds(); } } double effRxPowerDb = rxPowerDb + KpToDb (csp); - - double isiUpa = rxPowerDb * pdp.SumTapsFromMaxNc (Seconds (ts + clearingTime), Seconds (ts)); + //It appears to be just the first elements of the sum in Parrish paper, + // "System Design Considerations for Undersea Networks: Link and Multiple Access Protocols", eq. 14 + double isiUpa = DbToKp(rxPowerDb) * pdp.SumTapsFromMaxNc (Seconds (ts + clearingTime), Seconds (ts)); // added DpToKp() UanTransducer::ArrivalList::const_iterator it = arrivalList.begin (); double intKp = -DbToKp (effRxPowerDb); for (; it != arrivalList.end (); it++) @@ -178,20 +181,23 @@ UanPhyCalcSinrFhFsk::CalcSinrDb (Ptr pkt, } double intPower = 0.0; - if (tDelta < ts) + if (tDelta < ts) // Case where there is overlap of a symbol due to interferer arriving just after desired signal { + //Appears to be just the first two elements of the sum in Parrish paper, eq. 14 intPower += intPdp.SumTapsNc (Seconds (0), Seconds (ts - tDelta)); intPower += intPdp.SumTapsNc (Seconds (ts - tDelta + clearingTime), Seconds (2 * ts - tDelta + clearingTime)); } - else + else // Account for case where there's overlap of a symbol due to interferer arriving with a tDelta of a symbol + clearing time later { + // Appears to be just the first two elements of the sum in Parrish paper, eq. 14 Time start = Seconds (ts + clearingTime - tDelta); - Time end = start + Seconds (ts); + Time end = /*start +*/ Seconds (ts); // Should only sum over portion of ts that overlaps, not entire ts intPower += intPdp.SumTapsNc (start, end); start = start + Seconds (ts + clearingTime); - end = start + Seconds (ts); + //Should only sum over portion of ts that overlaps, not entire ts + end = end + Seconds (ts + clearingTime); //start + Seconds (ts); intPower += intPdp.SumTapsNc (start, end); } intKp += DbToKp (it->GetRxPowerDb ()) * intPower; diff --git a/src/uan/model/uan-phy-gen.h b/src/uan/model/uan-phy-gen.h index 36c165a8bfa..6cf0ec5140d 100644 --- a/src/uan/model/uan-phy-gen.h +++ b/src/uan/model/uan-phy-gen.h @@ -177,6 +177,14 @@ class UanPhyCalcSinrDefault : public UanPhyCalcSinr * clearing time between symbols transmitted on the same frequency. * This clearing time combats ISI from channel delay spread and also has * a byproduct of possibly reducing interference from other transmitted packets. + * + * Thanks to Randall Plate for the latest model revision based on the following + * papers: + *
            + *
          • Parrish, "System Design Considerations for Undersea Networks: Link and Multiple Access Protocols" + *
          • Siderius, "Effects of Ocean Thermocline Variability on Noncoherent Underwater Acoustic Communications" + *
          • Rao, "Channel Coding Techniques for Wireless Communications", ch 2 + *
          */ class UanPhyCalcSinrFhFsk : public UanPhyCalcSinr { diff --git a/src/uan/model/uan-prop-model.h b/src/uan/model/uan-prop-model.h index b13a832abaa..51e1426e14f 100644 --- a/src/uan/model/uan-prop-model.h +++ b/src/uan/model/uan-prop-model.h @@ -234,6 +234,13 @@ class UanPdp */ std::complex SumTapsFromMaxC (Time delay, Time duration) const; + /** + * Creates a new UanPdp normalized to its non coherent sum. + * \see SumTapsNc + * \returns the new PDP + */ + UanPdp NormalizeToSumNc (void); + /** * Get a unit impulse PDP at time 0. * From 189504501a73c8034a29061f74494749a9cc8c3a Mon Sep 17 00:00:00 2001 From: Federico Guerra Date: Wed, 16 Aug 2017 17:48:17 -0700 Subject: [PATCH 219/551] uan: (fixes #2492) RxGainDb moved (patch co-author Randall Plate) RxGainDb moved from UanPhy to UanTransducer in order to apply the gain to all received packets --- src/uan/model/uan-phy-dual.cc | 43 ------------------------------ src/uan/model/uan-phy-dual.h | 10 ------- src/uan/model/uan-phy-gen.cc | 20 ++------------ src/uan/model/uan-phy-gen.h | 5 +--- src/uan/model/uan-phy.h | 12 --------- src/uan/model/uan-transducer-hd.cc | 35 ++++++++++++++++++++++-- src/uan/model/uan-transducer-hd.h | 4 +++ src/uan/model/uan-transducer.h | 18 +++++++++++++ 8 files changed, 58 insertions(+), 89 deletions(-) diff --git a/src/uan/model/uan-phy-dual.cc b/src/uan/model/uan-phy-dual.cc index d2284081e8f..aae997bd0f9 100644 --- a/src/uan/model/uan-phy-dual.cc +++ b/src/uan/model/uan-phy-dual.cc @@ -182,16 +182,6 @@ UanPhyDual::GetTypeId (void) DoubleValue (190), MakeDoubleAccessor (&UanPhyDual::GetTxPowerDbPhy2, &UanPhyDual::SetTxPowerDbPhy2), MakeDoubleChecker ()) - .AddAttribute ("RxGainPhy1", - "Gain added to incoming signal at receiver of Phy1.", - DoubleValue (0), - MakeDoubleAccessor (&UanPhyDual::GetRxGainDbPhy1, &UanPhyDual::SetRxGainDbPhy1), - MakeDoubleChecker ()) - .AddAttribute ("RxGainPhy2", - "Gain added to incoming signal at receiver of Phy2.", - DoubleValue (0), - MakeDoubleAccessor (&UanPhyDual::GetRxGainDbPhy2, &UanPhyDual::SetRxGainDbPhy2), - MakeDoubleChecker ()) .AddAttribute ("SupportedModesPhy1", "List of modes supported by Phy1.", UanModesListValue (UanPhyGen::GetDefaultModes ()), @@ -302,23 +292,6 @@ UanPhyDual::SetReceiveErrorCallback (RxErrCallback cb) m_phy2->SetReceiveErrorCallback (cb); } -void -UanPhyDual::SetRxGainDb (double gain) -{ - m_phy1->SetRxGainDb (gain); - m_phy2->SetRxGainDb (gain); -} -void -UanPhyDual::SetRxGainDbPhy1 (double gain) -{ - m_phy1->SetRxGainDb (gain); -} - -void -UanPhyDual::SetRxGainDbPhy2 (double gain) -{ - m_phy2->SetRxGainDb (gain); -} void UanPhyDual::SetTxPowerDb (double txpwr) @@ -362,22 +335,6 @@ UanPhyDual::SetCcaThresholdPhy2 (double thresh) m_phy2->SetCcaThresholdDb (thresh); } -double -UanPhyDual::GetRxGainDb (void) -{ - NS_LOG_WARN ("Warning: UanPhyDual::GetRxGainDb returns RxGain of Phy 1"); - return m_phy1->GetRxGainDb (); -} -double -UanPhyDual::GetRxGainDbPhy1 (void) const -{ - return m_phy1->GetRxGainDb (); -} -double -UanPhyDual::GetRxGainDbPhy2 (void) const -{ - return m_phy2->GetRxGainDb (); -} double UanPhyDual::GetTxPowerDb (void) diff --git a/src/uan/model/uan-phy-dual.h b/src/uan/model/uan-phy-dual.h index 97a36ff412c..1338d6f42e8 100644 --- a/src/uan/model/uan-phy-dual.h +++ b/src/uan/model/uan-phy-dual.h @@ -112,11 +112,9 @@ class UanPhyDual : public UanPhy virtual void StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, UanPdp pdp); virtual void SetReceiveOkCallback (RxOkCallback cb); virtual void SetReceiveErrorCallback (RxErrCallback cb); - virtual void SetRxGainDb (double gain); virtual void SetTxPowerDb (double txpwr); virtual void SetRxThresholdDb (double thresh); virtual void SetCcaThresholdDb (double thresh); - virtual double GetRxGainDb (void); virtual double GetTxPowerDb (void); virtual double GetRxThresholdDb (void); virtual double GetCcaThresholdDb (void); @@ -178,14 +176,6 @@ class UanPhyDual : public UanPhy /** \copydoc UanPhy::SetTxPowerDb */ void SetTxPowerDbPhy2 (double txpwr); - /** \copydoc UanPhy::GetRxGainDb */ - double GetRxGainDbPhy1 (void) const; - /** \copydoc UanPhy::GetRxGainDb */ - double GetRxGainDbPhy2 (void) const; - /** \copydoc UanPhy::SetRxGainDb */ - void SetRxGainDbPhy1 (double gain); - /** \copydoc UanPhy::SetRxGainDb */ - void SetRxGainDbPhy2 (double gain); /** * Get the list of available modes. diff --git a/src/uan/model/uan-phy-gen.cc b/src/uan/model/uan-phy-gen.cc index 671296f7fd0..ada474282ab 100644 --- a/src/uan/model/uan-phy-gen.cc +++ b/src/uan/model/uan-phy-gen.cc @@ -359,7 +359,6 @@ UanPhyGen::UanPhyGen () m_transducer (0), m_device (0), m_mac (0), - m_rxGainDb (0), m_txPwrDb (0), m_rxThreshDb (0), m_ccaThreshDb (0), @@ -458,11 +457,6 @@ UanPhyGen::GetTypeId (void) DoubleValue (190), MakeDoubleAccessor (&UanPhyGen::m_txPwrDb), MakeDoubleChecker ()) - .AddAttribute ("RxGain", - "Gain added to incoming signal at receiver.", - DoubleValue (0), - MakeDoubleAccessor (&UanPhyGen::m_rxGainDb), - MakeDoubleChecker ()) .AddAttribute ("SupportedModes", "List of modes supported by this PHY.", UanModesListValue (UanPhyGen::GetDefaultModes ()), @@ -617,7 +611,6 @@ UanPhyGen::RegisterListener (UanPhyListener *listener) void UanPhyGen::StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, UanPdp pdp) { - rxPowerDb += GetRxGainDb (); NS_LOG_DEBUG ("PHY " << m_mac->GetAddress () << ": rx power after RX gain = " << rxPowerDb << " dB re uPa"); switch (m_state) @@ -788,12 +781,6 @@ UanPhyGen::IsStateCcaBusy (void) } -void -UanPhyGen::SetRxGainDb (double gain) -{ - m_rxGainDb = gain; - -} void UanPhyGen::SetTxPowerDb (double txpwr) { @@ -809,17 +796,14 @@ UanPhyGen::SetCcaThresholdDb (double thresh) { m_ccaThreshDb = thresh; } -double -UanPhyGen::GetRxGainDb (void) -{ - return m_rxGainDb; -} + double UanPhyGen::GetTxPowerDb (void) { return m_txPwrDb; } + double UanPhyGen::GetRxThresholdDb (void) { diff --git a/src/uan/model/uan-phy-gen.h b/src/uan/model/uan-phy-gen.h index 6cf0ec5140d..ec5d1b50b5d 100644 --- a/src/uan/model/uan-phy-gen.h +++ b/src/uan/model/uan-phy-gen.h @@ -261,11 +261,9 @@ class UanPhyGen : public UanPhy virtual bool IsStateRx (void); virtual bool IsStateTx (void); virtual bool IsStateCcaBusy (void); - virtual void SetRxGainDb (double gain); virtual void SetTxPowerDb (double txpwr); virtual void SetRxThresholdDb (double thresh); virtual void SetCcaThresholdDb (double thresh); - virtual double GetRxGainDb (void); virtual double GetTxPowerDb (void); virtual double GetRxThresholdDb (void); virtual double GetCcaThresholdDb (void); @@ -302,7 +300,6 @@ class UanPhyGen : public UanPhy Ptr m_per; //!< Error model. Ptr m_sinr; //!< SINR calculator. - double m_rxGainDb; //!< Receive gain. double m_txPwrDb; //!< Transmit power. double m_rxThreshDb; //!< Receive SINR threshold. double m_ccaThreshDb; //!< CCA busy threshold. @@ -312,7 +309,7 @@ class UanPhyGen : public UanPhy double m_minRxSinrDb; //!< Minimum receive SINR during packet reception. double m_rxRecvPwrDb; //!< Receiver power. Time m_pktRxArrTime; //!< Packet arrival time. - UanPdp m_pktRxPdp; //!< Power delay profile of pakket. + UanPdp m_pktRxPdp; //!< Power delay profile of packet. UanTxMode m_pktRxMode; //!< Packet transmission mode at receiver. bool m_cleared; //!< Flag when we've been cleared. diff --git a/src/uan/model/uan-phy.h b/src/uan/model/uan-phy.h index e31a16d2ab0..f9d3828fbdf 100644 --- a/src/uan/model/uan-phy.h +++ b/src/uan/model/uan-phy.h @@ -267,12 +267,6 @@ class UanPhy : public Object */ virtual void SetReceiveErrorCallback (RxErrCallback cb) = 0; - /** - * Set the receiver gain. - * - * \param gain Gain added at receiver, in dB. - */ - virtual void SetRxGainDb (double gain) = 0; /** * Set the transmit power. @@ -297,12 +291,6 @@ class UanPhy : public Object */ virtual void SetCcaThresholdDb (double thresh) = 0; - /** - * Get the receiver gain added to signal at receiver in dB. - * - * \return The gain. - */ - virtual double GetRxGainDb (void) = 0; /** * Get the current transmit power, in dB. diff --git a/src/uan/model/uan-transducer-hd.cc b/src/uan/model/uan-transducer-hd.cc index 4efc7aec184..08276376e19 100644 --- a/src/uan/model/uan-transducer-hd.cc +++ b/src/uan/model/uan-transducer-hd.cc @@ -25,7 +25,7 @@ #include "uan-channel.h" #include "ns3/log.h" #include "ns3/pointer.h" - +#include "ns3/double.h" namespace ns3 { @@ -37,7 +37,8 @@ UanTransducerHd::UanTransducerHd () : UanTransducer (), m_state (RX), m_endTxTime (Seconds (0)), - m_cleared (false) + m_cleared (false), + m_rxGainDb (0) { } @@ -91,6 +92,11 @@ UanTransducerHd::GetTypeId () .SetParent () .SetGroupName ("Uan") .AddConstructor () + .AddAttribute ("RxGainDb", + "Gain in Db added to incoming signal at receiver.", + DoubleValue (0), + MakeDoubleAccessor (&UanTransducerHd::m_rxGainDb), + MakeDoubleChecker ()) ; return tid; } @@ -121,12 +127,37 @@ UanTransducerHd::GetArrivalList (void) const return m_arrivalList; } +void +UanTransducerHd::SetRxGainDb (double gainDb) +{ + m_rxGainDb = gainDb; +} + +double +UanTransducerHd::GetRxGainDb (void) +{ + return m_rxGainDb; +} + +double +UanTransducerHd::ApplyRxGainDb (double rxPowerDb, UanTxMode mode) +{ + NS_LOG_FUNCTION (this << rxPowerDb << mode); + rxPowerDb += GetRxGainDb (); + NS_LOG_DEBUG ("Rx power after RX gain = " << rxPowerDb << " db re uPa"); + return rxPowerDb; +} + void UanTransducerHd::Receive (Ptr packet, double rxPowerDb, UanTxMode txMode, UanPdp pdp) { + NS_LOG_FUNCTION (this << packet << rxPowerDb << txMode << pdp); + //Apply receiver gain in dB + rxPowerDb = ApplyRxGainDb (rxPowerDb, txMode); + UanPacketArrival arrival (packet, rxPowerDb, txMode, diff --git a/src/uan/model/uan-transducer-hd.h b/src/uan/model/uan-transducer-hd.h index fad14f7cfbe..28c0df05332 100644 --- a/src/uan/model/uan-transducer-hd.h +++ b/src/uan/model/uan-transducer-hd.h @@ -52,6 +52,9 @@ class UanTransducerHd : public UanTransducer virtual bool IsRx (void) const; virtual bool IsTx (void) const; virtual const ArrivalList &GetArrivalList (void) const; + virtual double ApplyRxGainDb (double rxPowerDb, UanTxMode mode); + virtual void SetRxGainDb (double gainDb); + virtual double GetRxGainDb (void); virtual void Receive (Ptr packet, double rxPowerDb, UanTxMode txMode, UanPdp pdp); virtual void Transmit (Ptr src, Ptr packet, double txPowerDb, UanTxMode txMode); virtual void SetChannel (Ptr chan); @@ -68,6 +71,7 @@ class UanTransducerHd : public UanTransducer EventId m_endTxEvent; //!< Event scheduled for end of transmission. Time m_endTxTime; //!< Time at which transmission will be completed. bool m_cleared; //!< Flab when we've been cleared. + double m_rxGainDb; //!< Receive gain in dB. /** * Remove an entry from the arrival list. diff --git a/src/uan/model/uan-transducer.h b/src/uan/model/uan-transducer.h index b1aabcb3dd5..51da32e38ad 100644 --- a/src/uan/model/uan-transducer.h +++ b/src/uan/model/uan-transducer.h @@ -181,6 +181,24 @@ class UanTransducer : public Object * \return List of all packets currently crossing this node in the water. */ virtual const ArrivalList &GetArrivalList (void) const = 0; + /** + * Set the receiver gain. + * + * \param gainDb Gain added at receiver, in dB. + */ + virtual void SetRxGainDb (double gainDb) = 0; + /** + * Get the receiver gain added to signal at receiver in dB. + * + * \return The gain (in dB). + */ + virtual double GetRxGainDb (void) = 0; + /** + * Apply receiver gain in dB to the received power. + * + * \return Updated receive power (in dB) with gain applied. + */ + virtual double ApplyRxGainDb (double rxPowerDb, UanTxMode mode) = 0; /** * Notify this object that a new packet has arrived at this nodes location * From e4a837b78491913a9458a615dd411f11717ee3f6 Mon Sep 17 00:00:00 2001 From: Federico Guerra Date: Wed, 16 Aug 2017 21:49:25 -0700 Subject: [PATCH 220/551] uan: (fixes #2588) development of new PER models A new PER calculator class has been added in order to support standard PER computations. A stricter check has been also enforced on other PER calculations. A fatal error will be thrown in case of incompatible tx mode and PER calculator. --- src/uan/model/uan-phy-gen.cc | 194 ++++++++++++++++++++++++++++++----- src/uan/model/uan-phy-gen.h | 57 ++++++++-- 2 files changed, 215 insertions(+), 36 deletions(-) diff --git a/src/uan/model/uan-phy-gen.cc b/src/uan/model/uan-phy-gen.cc index ada474282ab..fa65180c725 100644 --- a/src/uan/model/uan-phy-gen.cc +++ b/src/uan/model/uan-phy-gen.cc @@ -46,6 +46,7 @@ NS_OBJECT_ENSURE_REGISTERED (UanPhyPerGenDefault); NS_OBJECT_ENSURE_REGISTERED (UanPhyCalcSinrDefault); NS_OBJECT_ENSURE_REGISTERED (UanPhyCalcSinrFhFsk); NS_OBJECT_ENSURE_REGISTERED (UanPhyPerUmodem); +NS_OBJECT_ENSURE_REGISTERED (UanPhyPerCommonModes); /*************** UanPhyCalcSinrDefault definition *****************/ @@ -130,13 +131,11 @@ UanPhyCalcSinrFhFsk::CalcSinrDb (Ptr pkt, UanPdp pdp, const UanTransducer::ArrivalList &arrivalList) const { - if (mode.GetModType () != UanTxMode::FSK) + if ((mode.GetModType () != UanTxMode::FSK) && (mode.GetConstellationSize () != 13)) { - NS_LOG_WARN ("Calculating SINR for unsupported mode type"); + NS_FATAL_ERROR ("Calculating SINR for unsupported mode type"); } - - double ts = 1.0 / mode.GetPhyRateSps (); double clearingTime = (m_hops - 1.0) * ts; double csp = pdp.SumTapsFromMaxNc (Seconds (0), Seconds (ts)); @@ -249,6 +248,142 @@ UanPhyPerGenDefault::CalcPer (Ptr pkt, double sinrDb, UanTxMode mode) } } +/*************** UanPhyPerCommonModes definition *****************/ +UanPhyPerCommonModes::UanPhyPerCommonModes () + : UanPhyPer () +{ + +} + +UanPhyPerCommonModes::~UanPhyPerCommonModes () +{ + +} + +TypeId +UanPhyPerCommonModes::GetTypeId (void) +{ + static TypeId tid = TypeId ("ns3::UanPhyPerCommonModes") + .SetParent () + .SetGroupName ("Uan") + .AddConstructor (); + + return tid; +} + +double +UanPhyPerCommonModes::CalcPer (Ptr pkt, double sinrDb, UanTxMode mode) +{ + NS_LOG_FUNCTION (this); + + double EbNo = std::pow (10.0, sinrDb / 10.0); + double BER = 1.0; + double PER = 0.0; + + switch (mode.GetModType ()) + { + case UanTxMode::PSK: + switch (mode.GetConstellationSize ()) + { + case 2: // BPSK + { + BER = 0.5 * erfc (sqrt (EbNo)); + break; + } + case 4: // QPSK, half BPSK EbNo + { + BER = 0.5 * erfc (sqrt (0.5 * EbNo)); + break; + } + + default: + NS_FATAL_ERROR ("constellation " << mode.GetConstellationSize () << " not supported"); + break; + } + + // taken from Ronell B. Sicat, "Bit Error Probability Computations for M-ary Quadrature Amplitude Modulation", + // EE 242 Digital Communications and Codings, 2009 + case UanTxMode::QAM: + { + // generic EbNo + EbNo *= mode.GetDataRateBps () / mode.GetBandwidthHz (); + + double M = (double) mode.GetConstellationSize (); + + // standard squared quantized QAM, even number of bits per symbol supported + int log2sqrtM = (int) ::std::log2 ( sqrt (M)); + + double log2M = ::std::log2 (M); + + if ((int)log2M % 2) + { + NS_FATAL_ERROR ("constellation " << M << " not supported"); + } + + double sqrtM = ::std::sqrt (M); + + NS_LOG_DEBUG ("M=" << M << "; log2sqrtM=" << log2sqrtM << "; log2M=" << log2M << "; sqrtM=" << sqrtM); + + BER = 0.0; + + // Eq (75) + for (int k = 0; k < log2sqrtM; k++) + { + int sum_items = (int) ((1.0 - ::std::pow ( 2.0, (-1.0) * (double) k)) * ::std::sqrt (M) - 1.0); + double pow2k = ::std::pow (2.0, (double) k - 1.0); + + NS_LOG_DEBUG ("k=" << k << "; sum_items=" << sum_items << "; pow2k=" << pow2k); + + double PbK = 0; + + // Eq (74) + for (int j = 0; j < sum_items; ++j) + { + PbK += ::std::pow (-1.0, (double) j * pow2k / sqrtM) + * (pow2k - ::std::floor ( (double) (j * pow2k / sqrtM) - 0.5)) + * erfc ((2.0 * (double)j + 1.0) * ::std::sqrt (3.0 * (log2M * EbNo) / (2.0 * (M - 1.0)))); + + NS_LOG_DEBUG ("j=" << j << "; PbK=" << PbK); + + } + PbK *= 1.0 / sqrtM; + + BER += PbK; + + NS_LOG_DEBUG ("k=" << k << "; PbK=" << PbK << "; BER=" << BER); + } + + BER *= 1.0 / (double) log2sqrtM; + + break; + } + + case UanTxMode::FSK: + switch (mode.GetConstellationSize ()) + { + case 2: + { + BER = 0.5 * erfc (sqrt (0.5 * EbNo)); + break; + } + + default: + NS_FATAL_ERROR ("constellation " << mode.GetConstellationSize () << " not supported"); + break; + } + + default: // OTHER and error + NS_FATAL_ERROR ("Mode " << mode.GetModType () << " not supported"); + break; + } + + PER = (1.0 - pow (1.0 - BER, (double) pkt->GetSize () * 8.0)); + + NS_LOG_DEBUG ("BER=" << BER << "; PER=" << PER); + + return PER; +} + /*************** UanPhyPerUmodem definition *****************/ UanPhyPerUmodem::UanPhyPerUmodem () { @@ -305,6 +440,10 @@ UanPhyPerUmodem::CalcPer (Ptr pkt, double sinr, UanTxMode mode) double perror = 1.0 / (2.0 + ebno); double P[9]; + if ((mode.GetModType () != UanTxMode::FSK) && (mode.GetConstellationSize () != 13)) + { + NS_FATAL_ERROR ("Calculating SINR for unsupported mode type"); + } if (sinr >= 10) { return 0; @@ -430,10 +569,13 @@ UanModesList UanPhyGen::GetDefaultModes (void) { UanModesList l; - l.AppendMode (UanTxModeFactory::CreateMode (UanTxMode::FSK,80,80,22000,4000,13,"FSK")); - l.AppendMode (UanTxModeFactory::CreateMode (UanTxMode::PSK,200, 200, 22000, 4000, 4, "QPSK")); + l.AppendMode (UanTxModeFactory::CreateMode (UanTxMode::FSK, 80, 80, 22000, 4000, 13, "FH-FSK")); // micromodem only + l.AppendMode (UanTxModeFactory::CreateMode (UanTxMode::PSK, 200, 200, 22000, 4000, 4, "QPSK")); + l.AppendMode (UanTxModeFactory::CreateMode (UanTxMode::PSK, 5000, 5000, 25000, 5000, 4, "QPSK")); // micromodem2 + return l; } + TypeId UanPhyGen::GetTypeId (void) { @@ -513,15 +655,15 @@ UanPhyGen::EnergyDepletionHandler () NS_LOG_FUNCTION (this); NS_LOG_DEBUG ("Energy depleted at node " << m_device->GetNode ()->GetId () << ", stopping rx/tx activities"); - + m_state = DISABLED; - if(m_txEndEvent.IsRunning ()) + if (m_txEndEvent.IsRunning ()) { Simulator::Cancel (m_txEndEvent); NotifyTxDrop (m_pktTx); m_pktTx = 0; } - if(m_rxEndEvent.IsRunning ()) + if (m_rxEndEvent.IsRunning ()) { Simulator::Cancel (m_rxEndEvent); NotifyRxDrop (m_pktRx); @@ -602,7 +744,7 @@ UanPhyGen::TxEndEvent () } void -UanPhyGen::RegisterListener (UanPhyListener *listener) +UanPhyGen::RegisterListener (UanPhyListener * listener) { m_listeners.push_back (listener); } @@ -617,10 +759,10 @@ UanPhyGen::StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, U { case DISABLED: NS_LOG_DEBUG ("Energy depleted, node cannot receive any packet. Dropping."); - NotifyRxDrop(pkt); // traced source netanim + NotifyRxDrop (pkt); // traced source netanim return; case TX: - NotifyRxDrop(pkt); // traced source netanim + NotifyRxDrop (pkt); // traced source netanim NS_ASSERT (false); break; case RX: @@ -629,7 +771,7 @@ UanPhyGen::StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, U double newSinrDb = CalculateSinrDb (m_pktRx, m_pktRxArrTime, m_rxRecvPwrDb, m_pktRxMode, m_pktRxPdp); m_minRxSinrDb = (newSinrDb < m_minRxSinrDb) ? newSinrDb : m_minRxSinrDb; NS_LOG_DEBUG ("PHY " << m_mac->GetAddress () << ": Starting RX in RX mode. SINR of pktRx = " << m_minRxSinrDb); - NotifyRxBegin(pkt); // traced source netanim + NotifyRxBegin (pkt); // traced source netanim } break; @@ -658,7 +800,7 @@ UanPhyGen::StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, U { m_state = RX; UpdatePowerConsumption (RX); - NotifyRxBegin(pkt); // traced source netanim + NotifyRxBegin (pkt); // traced source netanim m_rxRecvPwrDb = rxPowerDb; m_minRxSinrDb = newsinr; m_pktRx = pkt; @@ -674,7 +816,7 @@ UanPhyGen::StartRxPacket (Ptr pkt, double rxPowerDb, UanTxMode txMode, U break; case SLEEP: NS_LOG_DEBUG ("Sleep mode. Dropping packet."); - NotifyRxDrop(pkt); // traced source netanim + NotifyRxDrop (pkt); // traced source netanim break; } @@ -698,11 +840,11 @@ UanPhyGen::RxEndEvent (Ptr pkt, double rxPowerDb, UanTxMode txMode) { NS_LOG_DEBUG ("Sleep mode or dead. Dropping packet"); m_pktRx = 0; - NotifyRxDrop(pkt); // traced source netanim + NotifyRxDrop (pkt); // traced source netanim return; } - NotifyRxEnd(pkt); // traced source netanim + NotifyRxEnd (pkt); // traced source netanim if (GetInterferenceDb ( (Ptr) 0) > m_ccaThreshDb) { m_state = CCABUSY; @@ -858,16 +1000,16 @@ UanPhyGen::SetTransducer (Ptr trans) } void -UanPhyGen::SetSleepMode (bool sleep) +UanPhyGen::SetSleepMode (bool sleep ) { - if (sleep) - { - m_state = SLEEP; - if (!m_energyCallback.IsNull ()) - { - m_energyCallback (SLEEP); - } - } + if (sleep ) + { + m_state = SLEEP; + if (!m_energyCallback.IsNull ()) + { + m_energyCallback (SLEEP); + } + } else if (m_state == SLEEP) { if (GetInterferenceDb ((Ptr) 0) > m_ccaThreshDb) diff --git a/src/uan/model/uan-phy-gen.h b/src/uan/model/uan-phy-gen.h index ec5d1b50b5d..935fd8edd79 100644 --- a/src/uan/model/uan-phy-gen.h +++ b/src/uan/model/uan-phy-gen.h @@ -54,19 +54,18 @@ class UanPhyPerGenDefault : public UanPhyPer * \return The TypeId. */ static TypeId GetTypeId (void); - + virtual double CalcPer (Ptr pkt, double sinrDb, UanTxMode mode); private: - double m_thresh; //!< SINR threshold. }; // class UanPhyPerGenDefault - + /** * \ingroup uan * - * Packet error rate calculation assuming WHOI Micromodem-like PHY. + * Packet error rate calculation assuming WHOI Micromodem-like PHY (FH-FSK) * * Calculates PER assuming rate 1/2 convolutional code with * constraint length 9 with soft decision viterbi decoding and @@ -116,6 +115,45 @@ class UanPhyPerUmodem : public UanPhyPer }; // class UanPhyPerUmodem +/** + * \ingroup uan + * + * Packet error rate calculation for common tx modes based on UanPhyPerUmodem + * + * Calculates PER for common UanTxMode modulations, by deriving + * PER from the BER taken from well known literature's formulas. + */ +class UanPhyPerCommonModes : public UanPhyPer +{ +public: + /** Constructor */ + UanPhyPerCommonModes (); + /** Destructor */ + virtual ~UanPhyPerCommonModes (); + + /** + * Register this type. + * \return The TypeId. + */ + static TypeId GetTypeId (void); + + /** + * Calculate the Packet ERror probability based on + * SINR at the receiver and a tx mode. + * + * This implementation calculates PER for common UanTxMode modulations, + * by deriving PER from the BER taken from literature's formulas. + * + * \param pkt Packet which is under consideration. + * \param sinrDb SINR at receiver. + * \param mode TX mode used to transmit packet. + * \return Probability of packet error. + */ + virtual double CalcPer (Ptr pkt, double sinrDb, UanTxMode mode); + +}; // class UanPhyPerCommonModes + + /** * \ingroup uan * @@ -133,13 +171,13 @@ class UanPhyCalcSinrDefault : public UanPhyCalcSinr UanPhyCalcSinrDefault (); /** Destructor */ virtual ~UanPhyCalcSinrDefault (); - + /** * Register this type. * \return The TypeId. */ static TypeId GetTypeId (void); - + /** * Calculate the SINR value for a packet. * @@ -194,7 +232,7 @@ class UanPhyCalcSinrFhFsk : public UanPhyCalcSinr UanPhyCalcSinrFhFsk (); /** Destructor */ virtual ~UanPhyCalcSinrFhFsk (); - + /** * Register this type. * \return The TypeId. @@ -239,7 +277,6 @@ class UanPhyGen : public UanPhy */ static UanModesList GetDefaultModes (void); - /** * Register this type. * \return The TypeId. @@ -313,7 +350,7 @@ class UanPhyGen : public UanPhy UanTxMode m_pktRxMode; //!< Packet transmission mode at receiver. bool m_cleared; //!< Flag when we've been cleared. - + EventId m_txEndEvent; //!< Tx event EventId m_rxEndEvent; //!< Rx event @@ -390,7 +427,7 @@ class UanPhyGen : public UanPhy /** Call UanListener::NotifyRxStart on all listeners. */ - void NotifyListenersRxStart (void); + void NotifyListenersRxStart (void); /** Call UanListener::NotifyRxEndOk on all listeners. */ void NotifyListenersRxGood (void); /** Call UanListener::NotifyRxEndError on all listeners. */ From 931059cca4d9fd0a9d815bd7360772f558edc75d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Thu, 17 Aug 2017 08:15:32 -0700 Subject: [PATCH 221/551] uan: Rescan python bindings --- src/uan/bindings/modulegen__gcc_ILP32.py | 1645 +++++++++++++++------- src/uan/bindings/modulegen__gcc_LP64.py | 1645 +++++++++++++++------- 2 files changed, 2350 insertions(+), 940 deletions(-) diff --git a/src/uan/bindings/modulegen__gcc_ILP32.py b/src/uan/bindings/modulegen__gcc_ILP32.py index dd353893413..1cd338f3a1a 100644 --- a/src/uan/bindings/modulegen__gcc_ILP32.py +++ b/src/uan/bindings/modulegen__gcc_ILP32.py @@ -44,6 +44,24 @@ def register_types(module): module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList::Iterator']) ## callback.h (module 'core'): ns3::CallbackBase [class] module.add_class('CallbackBase', import_from_module='ns.core') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer [class] module.add_class('DeviceEnergyModelContainer', import_from_module='ns.energy') ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper [class] @@ -84,8 +102,8 @@ def register_types(module): module.add_class('PacketMetadata', import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) ## packet.h (module 'network'): ns3::PacketTagIterator [class] @@ -150,9 +168,9 @@ def register_types(module): module.add_class('Vector3D', import_from_module='ns.core') ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper [class] module.add_class('AcousticModemEnergyModelHelper', parent=root_module['ns3::DeviceEnergyModelHelper']) @@ -244,6 +262,8 @@ def register_types(module): module.add_class('UanPhyGen', parent=root_module['ns3::UanPhy']) ## uan-phy.h (module 'uan'): ns3::UanPhyPer [class] module.add_class('UanPhyPer', parent=root_module['ns3::Object']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes [class] + module.add_class('UanPhyPerCommonModes', parent=root_module['ns3::UanPhyPer']) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault [class] module.add_class('UanPhyPerGenDefault', parent=root_module['ns3::UanPhyPer']) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem [class] @@ -398,6 +418,42 @@ def register_types(module): module.add_class('AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) ## address.h (module 'network'): ns3::AddressValue [class] module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'double', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::UanAddress', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::UanAddress &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Time', 'ns3::Time', 'unsigned int', 'unsigned int', 'double', 'unsigned int', 'double', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress >', container_type=u'list') module.add_container('std::vector< ns3::Tap >', 'ns3::Tap', container_type=u'vector') module.add_container('std::vector< std::complex< double > >', 'std::complex< double >', container_type=u'vector') @@ -407,14 +463,14 @@ def register_types(module): module.add_container('std::list< ns3::Ptr< ns3::UanPhy > >', 'ns3::Ptr< ns3::UanPhy >', container_type=u'list') module.add_container('std::vector< std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > > >', 'std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > >', container_type=u'vector') module.add_container('std::list< ns3::Ptr< ns3::UanTransducer > >', 'ns3::Ptr< ns3::UanTransducer >', container_type=u'list') - typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') - typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') - typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') - module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') module.add_typedef(root_module['ns3::Vector3D'], 'Vector') + typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') + typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') + typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') + module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') @@ -453,12 +509,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -481,36 +537,36 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -528,6 +584,15 @@ def register_methods(root_module): register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator']) register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item']) register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3DeviceEnergyModelContainer_methods(root_module, root_module['ns3::DeviceEnergyModelContainer']) register_Ns3DeviceEnergyModelHelper_methods(root_module, root_module['ns3::DeviceEnergyModelHelper']) register_Ns3EnergySourceHelper_methods(root_module, root_module['ns3::EnergySourceHelper']) @@ -614,6 +679,7 @@ def register_methods(root_module): register_Ns3UanPhyDual_methods(root_module, root_module['ns3::UanPhyDual']) register_Ns3UanPhyGen_methods(root_module, root_module['ns3::UanPhyGen']) register_Ns3UanPhyPer_methods(root_module, root_module['ns3::UanPhyPer']) + register_Ns3UanPhyPerCommonModes_methods(root_module, root_module['ns3::UanPhyPerCommonModes']) register_Ns3UanPhyPerGenDefault_methods(root_module, root_module['ns3::UanPhyPerGenDefault']) register_Ns3UanPhyPerUmodem_methods(root_module, root_module['ns3::UanPhyPerUmodem']) register_Ns3UanPropModel_methods(root_module, root_module['ns3::UanPropModel']) @@ -689,6 +755,24 @@ def register_methods(root_module): register_Ns3AcousticModemEnergyModel_methods(root_module, root_module['ns3::AcousticModemEnergyModel']) register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanAddress_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3UanAddress___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Unsigned_int_Unsigned_int_Double_Unsigned_int_Double_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Time, ns3::Time, unsigned int, unsigned int, double, unsigned int, double, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation']) register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a']) register_Ns3HashFunctionHash32_methods(root_module, root_module['ns3::Hash::Function::Hash32']) @@ -697,15 +781,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -767,25 +851,25 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -795,7 +879,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -806,14 +890,14 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', @@ -886,7 +970,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -1046,7 +1130,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -1060,7 +1144,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -1087,7 +1171,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -1121,7 +1205,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -1140,7 +1224,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -1157,7 +1241,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -1171,8 +1255,116 @@ def register_Ns3CallbackBase_methods(root_module, cls): visibility='protected') return +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): - ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [copy constructor] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelContainer const &', 'arg0')]) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer() [constructor] cls.add_constructor([]) @@ -1194,18 +1386,18 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'modelName')]) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::Begin() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Clear() [member function] cls.add_method('Clear', 'void', []) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::End() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): ns3::Ptr ns3::DeviceEnergyModelContainer::Get(uint32_t i) const [member function] @@ -1223,7 +1415,7 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::DeviceEnergyModelHelper::Install(ns3::Ptr device, ns3::Ptr source) const [member function] cls.add_method('Install', @@ -1250,7 +1442,7 @@ def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): def register_Ns3EnergySourceHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(ns3::Ptr node) const [member function] cls.add_method('Install', @@ -1285,9 +1477,9 @@ def register_Ns3EnergySourceHelper_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -1330,7 +1522,7 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -1359,11 +1551,11 @@ def register_Ns3Hasher_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -1477,10 +1669,10 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -1540,17 +1732,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -1617,7 +1809,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -1739,9 +1931,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -1750,7 +1942,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -1797,11 +1989,11 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -1869,7 +2061,7 @@ def register_Ns3Mac48Address_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -1891,14 +2083,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -1914,7 +2106,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -1942,9 +2134,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -1955,9 +2147,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -1980,7 +2172,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -2041,7 +2233,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -2052,7 +2244,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -2089,7 +2281,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -2167,7 +2359,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -2181,10 +2373,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -2200,7 +2394,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2214,7 +2408,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -2231,7 +2425,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -2265,7 +2459,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -2280,7 +2474,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): return def register_Ns3Reservation_methods(root_module, cls): - ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(ns3::Reservation const & arg0) [copy constructor] + ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(ns3::Reservation const & arg0) [constructor] cls.add_constructor([param('ns3::Reservation const &', 'arg0')]) ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation() [constructor] cls.add_constructor([]) @@ -2342,7 +2536,7 @@ def register_Ns3Reservation_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -2352,7 +2546,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -2434,7 +2628,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -2464,7 +2658,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -2508,14 +2702,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -2527,7 +2721,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): return def register_Ns3Tap_methods(root_module, cls): - ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Tap const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Tap const & arg0) [constructor] cls.add_constructor([param('ns3::Tap const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap() [constructor] cls.add_constructor([]) @@ -2547,7 +2741,7 @@ def register_Ns3Tap_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -2556,11 +2750,15 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TracedValue__Double_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< double > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(double const & v) [constructor] cls.add_constructor([param('double const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -2568,7 +2766,7 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -2588,33 +2786,32 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -2630,7 +2827,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -2640,9 +2837,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -2709,12 +2906,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -2724,12 +2921,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -2739,7 +2936,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -2764,13 +2961,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -2789,7 +2985,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -2807,10 +3003,10 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3UanAddress_methods(root_module, cls): cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(ns3::UanAddress const & arg0) [copy constructor] + ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(ns3::UanAddress const & arg0) [constructor] cls.add_constructor([param('ns3::UanAddress const &', 'arg0')]) ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress() [constructor] cls.add_constructor([]) @@ -2852,7 +3048,7 @@ def register_Ns3UanAddress_methods(root_module, cls): return def register_Ns3UanHelper_methods(root_module, cls): - ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper(ns3::UanHelper const & arg0) [copy constructor] + ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper(ns3::UanHelper const & arg0) [constructor] cls.add_constructor([param('ns3::UanHelper const &', 'arg0')]) ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper() [constructor] cls.add_constructor([]) @@ -2911,7 +3107,7 @@ def register_Ns3UanHelper_methods(root_module, cls): def register_Ns3UanModesList_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList(ns3::UanModesList const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList(ns3::UanModesList const & arg0) [constructor] cls.add_constructor([param('ns3::UanModesList const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList() [constructor] cls.add_constructor([]) @@ -2931,7 +3127,7 @@ def register_Ns3UanModesList_methods(root_module, cls): return def register_Ns3UanPacketArrival_methods(root_module, cls): - ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::UanPacketArrival const & arg0) [copy constructor] + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::UanPacketArrival const & arg0) [constructor] cls.add_constructor([param('ns3::UanPacketArrival const &', 'arg0')]) ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival() [constructor] cls.add_constructor([]) @@ -2966,29 +3162,29 @@ def register_Ns3UanPacketArrival_methods(root_module, cls): def register_Ns3UanPdp_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(ns3::UanPdp const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(ns3::UanPdp const & arg0) [constructor] cls.add_constructor([param('ns3::UanPdp const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp() [constructor] cls.add_constructor([]) ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > taps, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< ns3::Tap >', 'taps'), param('ns3::Time', 'resolution')]) - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector,std::allocator > > arrivals, ns3::Time resolution) [constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector, std::allocator > > arrivals, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< std::complex< double > >', 'arrivals'), param('ns3::Time', 'resolution')]) - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > arrivals, ns3::Time resolution) [constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > arrivals, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< double >', 'arrivals'), param('ns3::Time', 'resolution')]) ## uan-prop-model.h (module 'uan'): static ns3::UanPdp ns3::UanPdp::CreateImpulsePdp() [member function] cls.add_method('CreateImpulsePdp', 'ns3::UanPdp', [], is_static=True) - ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetBegin() const [member function] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::Iterator ns3::UanPdp::GetBegin() const [member function] cls.add_method('GetBegin', - '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + 'ns3::UanPdp::Iterator', [], is_const=True) - ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetEnd() const [member function] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::Iterator ns3::UanPdp::GetEnd() const [member function] cls.add_method('GetEnd', - '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + 'ns3::UanPdp::Iterator', [], is_const=True) ## uan-prop-model.h (module 'uan'): uint32_t ns3::UanPdp::GetNTaps() const [member function] @@ -3006,6 +3202,10 @@ def register_Ns3UanPdp_methods(root_module, cls): 'ns3::Tap const &', [param('uint32_t', 'i')], is_const=True) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp ns3::UanPdp::NormalizeToSumNc() [member function] + cls.add_method('NormalizeToSumNc', + 'ns3::UanPdp', + []) ## uan-prop-model.h (module 'uan'): void ns3::UanPdp::SetNTaps(uint32_t nTaps) [member function] cls.add_method('SetNTaps', 'void', @@ -3043,7 +3243,7 @@ def register_Ns3UanPdp_methods(root_module, cls): def register_Ns3UanPhyListener_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener(ns3::UanPhyListener const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener(ns3::UanPhyListener const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyListener const &', 'arg0')]) ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyCcaEnd() [member function] cls.add_method('NotifyCcaEnd', @@ -3079,7 +3279,7 @@ def register_Ns3UanPhyListener_methods(root_module, cls): def register_Ns3UanTxMode_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode(ns3::UanTxMode const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode(ns3::UanTxMode const & arg0) [constructor] cls.add_constructor([param('ns3::UanTxMode const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode() [constructor] cls.add_constructor([]) @@ -3126,7 +3326,7 @@ def register_Ns3UanTxMode_methods(root_module, cls): return def register_Ns3UanTxModeFactory_methods(root_module, cls): - ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory(ns3::UanTxModeFactory const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory(ns3::UanTxModeFactory const & arg0) [constructor] cls.add_constructor([param('ns3::UanTxModeFactory const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory() [constructor] cls.add_constructor([]) @@ -3148,14 +3348,21 @@ def register_Ns3UanTxModeFactory_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -3163,14 +3370,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -3182,79 +3396,79 @@ def register_Ns3Vector3D_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): - ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper(ns3::AcousticModemEnergyModelHelper const & arg0) [copy constructor] + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper(ns3::AcousticModemEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AcousticModemEnergyModelHelper const &', 'arg0')]) ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper() [constructor] cls.add_constructor([]) @@ -3263,7 +3477,7 @@ def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], is_virtual=True) - ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::SetDepletionCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::SetDepletionCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyDepletionCallback callback) [member function] cls.add_method('SetDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -3277,7 +3491,7 @@ def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -3300,7 +3514,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -3364,7 +3578,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -3385,7 +3599,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -3394,7 +3608,7 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) @@ -3486,7 +3700,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3498,7 +3712,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3510,7 +3724,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3522,7 +3736,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3534,7 +3748,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3546,7 +3760,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3558,7 +3772,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3570,7 +3784,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3582,7 +3796,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3592,22 +3806,22 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -3790,7 +4004,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -3820,7 +4034,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -3893,7 +4107,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): return def register_Ns3UanHeaderCommon_methods(root_module, cls): - ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanHeaderCommon const & arg0) [copy constructor] + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanHeaderCommon const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderCommon const &', 'arg0')]) ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon() [constructor] cls.add_constructor([]) @@ -3959,7 +4173,7 @@ def register_Ns3UanHeaderCommon_methods(root_module, cls): return def register_Ns3UanHeaderRcAck_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck(ns3::UanHeaderRcAck const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck(ns3::UanHeaderRcAck const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcAck const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck() [constructor] cls.add_constructor([]) @@ -4019,7 +4233,7 @@ def register_Ns3UanHeaderRcAck_methods(root_module, cls): return def register_Ns3UanHeaderRcCts_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(ns3::UanHeaderRcCts const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(ns3::UanHeaderRcCts const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcCts const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts() [constructor] cls.add_constructor([]) @@ -4103,7 +4317,7 @@ def register_Ns3UanHeaderRcCts_methods(root_module, cls): return def register_Ns3UanHeaderRcCtsGlobal_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::UanHeaderRcCtsGlobal const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::UanHeaderRcCtsGlobal const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcCtsGlobal const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal() [constructor] cls.add_constructor([]) @@ -4178,7 +4392,7 @@ def register_Ns3UanHeaderRcCtsGlobal_methods(root_module, cls): return def register_Ns3UanHeaderRcData_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(ns3::UanHeaderRcData const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(ns3::UanHeaderRcData const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcData const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData() [constructor] cls.add_constructor([]) @@ -4235,7 +4449,7 @@ def register_Ns3UanHeaderRcData_methods(root_module, cls): return def register_Ns3UanHeaderRcRts_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(ns3::UanHeaderRcRts const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(ns3::UanHeaderRcRts const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcRts const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts() [constructor] cls.add_constructor([]) @@ -4321,7 +4535,7 @@ def register_Ns3UanHeaderRcRts_methods(root_module, cls): def register_Ns3UanMac_methods(root_module, cls): ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac() [constructor] cls.add_constructor([]) - ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac(ns3::UanMac const & arg0) [copy constructor] + ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac(ns3::UanMac const & arg0) [constructor] cls.add_constructor([param('ns3::UanMac const &', 'arg0')]) ## uan-mac.h (module 'uan'): int64_t ns3::UanMac::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', @@ -4363,7 +4577,7 @@ def register_Ns3UanMac_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_pure_virtual=True, is_virtual=True) - ## uan-mac.h (module 'uan'): void ns3::UanMac::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac.h (module 'uan'): void ns3::UanMac::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4371,7 +4585,7 @@ def register_Ns3UanMac_methods(root_module, cls): return def register_Ns3UanMacAloha_methods(root_module, cls): - ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha(ns3::UanMacAloha const & arg0) [copy constructor] + ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha(ns3::UanMacAloha const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacAloha const &', 'arg0')]) ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha() [constructor] cls.add_constructor([]) @@ -4415,7 +4629,7 @@ def register_Ns3UanMacAloha_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4428,7 +4642,7 @@ def register_Ns3UanMacAloha_methods(root_module, cls): return def register_Ns3UanMacCw_methods(root_module, cls): - ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw(ns3::UanMacCw const & arg0) [copy constructor] + ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw(ns3::UanMacCw const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacCw const &', 'arg0')]) ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw() [constructor] cls.add_constructor([]) @@ -4517,7 +4731,7 @@ def register_Ns3UanMacCw_methods(root_module, cls): 'void', [param('uint32_t', 'cw')], is_virtual=True) - ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4535,7 +4749,7 @@ def register_Ns3UanMacCw_methods(root_module, cls): return def register_Ns3UanMacRc_methods(root_module, cls): - ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc(ns3::UanMacRc const & arg0) [copy constructor] + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc(ns3::UanMacRc const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacRc const &', 'arg0')]) ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc() [constructor] cls.add_constructor([]) @@ -4579,7 +4793,7 @@ def register_Ns3UanMacRc_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4592,7 +4806,7 @@ def register_Ns3UanMacRc_methods(root_module, cls): return def register_Ns3UanMacRcGw_methods(root_module, cls): - ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw(ns3::UanMacRcGw const & arg0) [copy constructor] + ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw(ns3::UanMacRcGw const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacRcGw const &', 'arg0')]) ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw() [constructor] cls.add_constructor([]) @@ -4636,7 +4850,7 @@ def register_Ns3UanMacRcGw_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4651,7 +4865,7 @@ def register_Ns3UanMacRcGw_methods(root_module, cls): def register_Ns3UanNoiseModel_methods(root_module, cls): ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel() [constructor] cls.add_constructor([]) - ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel(ns3::UanNoiseModel const & arg0) [copy constructor] + ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel(ns3::UanNoiseModel const & arg0) [constructor] cls.add_constructor([param('ns3::UanNoiseModel const &', 'arg0')]) ## uan-noise-model.h (module 'uan'): void ns3::UanNoiseModel::Clear() [member function] cls.add_method('Clear', @@ -4676,7 +4890,7 @@ def register_Ns3UanNoiseModel_methods(root_module, cls): return def register_Ns3UanNoiseModelDefault_methods(root_module, cls): - ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault(ns3::UanNoiseModelDefault const & arg0) [copy constructor] + ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault(ns3::UanNoiseModelDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanNoiseModelDefault const &', 'arg0')]) ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault() [constructor] cls.add_constructor([]) @@ -4695,7 +4909,7 @@ def register_Ns3UanNoiseModelDefault_methods(root_module, cls): def register_Ns3UanPhy_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy(ns3::UanPhy const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy(ns3::UanPhy const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhy const &', 'arg0')]) ## uan-phy.h (module 'uan'): int64_t ns3::UanPhy::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', @@ -4747,11 +4961,6 @@ def register_Ns3UanPhy_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_pure_virtual=True, is_virtual=True) ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -4861,7 +5070,7 @@ def register_Ns3UanPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetEnergyModelCallback(ns3::Callback callback) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback callback) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], @@ -4871,21 +5080,16 @@ def register_Ns3UanPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanMac >', 'mac')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_pure_virtual=True, is_virtual=True) ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -4916,12 +5120,12 @@ def register_Ns3UanPhy_methods(root_module, cls): def register_Ns3UanPhyCalcSinr_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr(ns3::UanPhyCalcSinr const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr(ns3::UanPhyCalcSinr const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinr const &', 'arg0')]) - ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_pure_virtual=True, is_const=True, is_virtual=True) ## uan-phy.h (module 'uan'): void ns3::UanPhyCalcSinr::Clear() [member function] cls.add_method('Clear', @@ -4951,14 +5155,14 @@ def register_Ns3UanPhyCalcSinr_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrDefault_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault(ns3::UanPhyCalcSinrDefault const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault(ns3::UanPhyCalcSinrDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrDefault const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault() [constructor] cls.add_constructor([]) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrDefault::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrDefault::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDefault::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4968,14 +5172,14 @@ def register_Ns3UanPhyCalcSinrDefault_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrDual_methods(root_module, cls): - ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual(ns3::UanPhyCalcSinrDual const & arg0) [copy constructor] + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual(ns3::UanPhyCalcSinrDual const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrDual const &', 'arg0')]) ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual() [constructor] cls.add_constructor([]) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyCalcSinrDual::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyCalcSinrDual::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-dual.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDual::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4985,14 +5189,14 @@ def register_Ns3UanPhyCalcSinrDual_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk(ns3::UanPhyCalcSinrFhFsk const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk(ns3::UanPhyCalcSinrFhFsk const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrFhFsk const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk() [constructor] cls.add_constructor([]) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrFhFsk::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrFhFsk::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrFhFsk::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -5002,7 +5206,7 @@ def register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, cls): return def register_Ns3UanPhyDual_methods(root_module, cls): - ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual(ns3::UanPhyDual const & arg0) [copy constructor] + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual(ns3::UanPhyDual const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyDual const &', 'arg0')]) ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual() [constructor] cls.add_constructor([]) @@ -5096,21 +5300,6 @@ def register_Ns3UanPhyDual_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_const=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_virtual=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy1() const [member function] - cls.add_method('GetRxGainDbPhy1', - 'double', - [], - is_const=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy2() const [member function] - cls.add_method('GetRxGainDbPhy2', - 'double', - [], - is_const=True) ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -5248,7 +5437,7 @@ def register_Ns3UanPhyDual_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetEnergyModelCallback(ns3::Callback callback) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback callback) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], @@ -5274,29 +5463,16 @@ def register_Ns3UanPhyDual_methods(root_module, cls): cls.add_method('SetPerModelPhy2', 'void', [param('ns3::Ptr< ns3::UanPhyPer >', 'per')]) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy1(double gain) [member function] - cls.add_method('SetRxGainDbPhy1', - 'void', - [param('double', 'gain')]) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy2(double gain) [member function] - cls.add_method('SetRxGainDbPhy2', - 'void', - [param('double', 'gain')]) ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -5346,7 +5522,7 @@ def register_Ns3UanPhyDual_methods(root_module, cls): return def register_Ns3UanPhyGen_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen(ns3::UanPhyGen const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen(ns3::UanPhyGen const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyGen const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen() [constructor] cls.add_constructor([]) @@ -5405,11 +5581,6 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_const=True, is_virtual=True) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_virtual=True) ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -5495,7 +5666,7 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetEnergyModelCallback(ns3::Callback cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback cb) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -5505,21 +5676,16 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanMac >', 'mac')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_virtual=True) ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -5555,7 +5721,7 @@ def register_Ns3UanPhyGen_methods(root_module, cls): def register_Ns3UanPhyPer_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer(ns3::UanPhyPer const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer(ns3::UanPhyPer const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPer const &', 'arg0')]) ## uan-phy.h (module 'uan'): double ns3::UanPhyPer::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] cls.add_method('CalcPer', @@ -5579,8 +5745,25 @@ def register_Ns3UanPhyPer_methods(root_module, cls): visibility='protected', is_virtual=True) return +def register_Ns3UanPhyPerCommonModes_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes::UanPhyPerCommonModes(ns3::UanPhyPerCommonModes const & arg0) [constructor] + cls.add_constructor([param('ns3::UanPhyPerCommonModes const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes::UanPhyPerCommonModes() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyPerCommonModes::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] + cls.add_method('CalcPer', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'sinrDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyPerCommonModes::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + def register_Ns3UanPhyPerGenDefault_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault(ns3::UanPhyPerGenDefault const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault(ns3::UanPhyPerGenDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPerGenDefault const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault() [constructor] cls.add_constructor([]) @@ -5597,7 +5780,7 @@ def register_Ns3UanPhyPerGenDefault_methods(root_module, cls): return def register_Ns3UanPhyPerUmodem_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem(ns3::UanPhyPerUmodem const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem(ns3::UanPhyPerUmodem const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPerUmodem const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem() [constructor] cls.add_constructor([]) @@ -5616,7 +5799,7 @@ def register_Ns3UanPhyPerUmodem_methods(root_module, cls): def register_Ns3UanPropModel_methods(root_module, cls): ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel() [constructor] cls.add_constructor([]) - ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel(ns3::UanPropModel const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel(ns3::UanPropModel const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModel const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): void ns3::UanPropModel::Clear() [member function] cls.add_method('Clear', @@ -5651,7 +5834,7 @@ def register_Ns3UanPropModel_methods(root_module, cls): return def register_Ns3UanPropModelIdeal_methods(root_module, cls): - ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal(ns3::UanPropModelIdeal const & arg0) [copy constructor] + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal(ns3::UanPropModelIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModelIdeal const &', 'arg0')]) ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal() [constructor] cls.add_constructor([]) @@ -5678,7 +5861,7 @@ def register_Ns3UanPropModelIdeal_methods(root_module, cls): return def register_Ns3UanPropModelThorp_methods(root_module, cls): - ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp(ns3::UanPropModelThorp const & arg0) [copy constructor] + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp(ns3::UanPropModelThorp const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModelThorp const &', 'arg0')]) ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp() [constructor] cls.add_constructor([]) @@ -5707,21 +5890,26 @@ def register_Ns3UanPropModelThorp_methods(root_module, cls): def register_Ns3UanTransducer_methods(root_module, cls): ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer() [constructor] cls.add_constructor([]) - ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer(ns3::UanTransducer const & arg0) [copy constructor] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer(ns3::UanTransducer const & arg0) [constructor] cls.add_constructor([param('ns3::UanTransducer const &', 'arg0')]) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::AddPhy(ns3::Ptr phy) [member function] cls.add_method('AddPhy', 'void', [param('ns3::Ptr< ns3::UanPhy >', 'phy')], is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): double ns3::UanTransducer::ApplyRxGainDb(double rxPowerDb, ns3::UanTxMode mode) [member function] + cls.add_method('ApplyRxGainDb', + 'double', + [param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'mode')], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Clear() [member function] cls.add_method('Clear', 'void', [], is_pure_virtual=True, is_virtual=True) - ## uan-transducer.h (module 'uan'): std::list > const & ns3::UanTransducer::GetArrivalList() const [member function] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::ArrivalList const & ns3::UanTransducer::GetArrivalList() const [member function] cls.add_method('GetArrivalList', - 'std::list< ns3::UanPacketArrival > const &', + 'ns3::UanTransducer::ArrivalList const &', [], is_pure_virtual=True, is_const=True, is_virtual=True) ## uan-transducer.h (module 'uan'): ns3::Ptr ns3::UanTransducer::GetChannel() const [member function] @@ -5729,11 +5917,16 @@ def register_Ns3UanTransducer_methods(root_module, cls): 'ns3::Ptr< ns3::UanChannel >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## uan-transducer.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducer::GetPhyList() const [member function] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanPhyList const & ns3::UanTransducer::GetPhyList() const [member function] cls.add_method('GetPhyList', - 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + 'ns3::UanTransducer::UanPhyList const &', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): double ns3::UanTransducer::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducer::GetState() const [member function] cls.add_method('GetState', 'ns3::UanTransducer::State', @@ -5764,6 +5957,11 @@ def register_Ns3UanTransducer_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanChannel >', 'chan')], is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::SetRxGainDb(double gainDb) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gainDb')], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] cls.add_method('Transmit', 'void', @@ -5772,7 +5970,7 @@ def register_Ns3UanTransducer_methods(root_module, cls): return def register_Ns3UanTransducerHd_methods(root_module, cls): - ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd(ns3::UanTransducerHd const & arg0) [copy constructor] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd(ns3::UanTransducerHd const & arg0) [constructor] cls.add_constructor([param('ns3::UanTransducerHd const &', 'arg0')]) ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd() [constructor] cls.add_constructor([]) @@ -5781,14 +5979,19 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanPhy >', 'arg0')], is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): double ns3::UanTransducerHd::ApplyRxGainDb(double rxPowerDb, ns3::UanTxMode mode) [member function] + cls.add_method('ApplyRxGainDb', + 'double', + [param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Clear() [member function] cls.add_method('Clear', 'void', [], is_virtual=True) - ## uan-transducer-hd.h (module 'uan'): std::list > const & ns3::UanTransducerHd::GetArrivalList() const [member function] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::ArrivalList const & ns3::UanTransducerHd::GetArrivalList() const [member function] cls.add_method('GetArrivalList', - 'std::list< ns3::UanPacketArrival > const &', + 'ns3::UanTransducer::ArrivalList const &', [], is_const=True, is_virtual=True) ## uan-transducer-hd.h (module 'uan'): ns3::Ptr ns3::UanTransducerHd::GetChannel() const [member function] @@ -5796,11 +5999,16 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'ns3::Ptr< ns3::UanChannel >', [], is_const=True, is_virtual=True) - ## uan-transducer-hd.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducerHd::GetPhyList() const [member function] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::UanPhyList const & ns3::UanTransducerHd::GetPhyList() const [member function] cls.add_method('GetPhyList', - 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + 'ns3::UanTransducer::UanPhyList const &', [], is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): double ns3::UanTransducerHd::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducerHd::GetState() const [member function] cls.add_method('GetState', 'ns3::UanTransducer::State', @@ -5831,6 +6039,11 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanChannel >', 'chan')], is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::SetRxGainDb(double gainDb) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gainDb')], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] cls.add_method('Transmit', 'void', @@ -5996,7 +6209,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -6023,7 +6236,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -6065,7 +6278,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -6074,12 +6287,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6089,13 +6302,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -6106,7 +6319,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6116,7 +6329,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6130,21 +6343,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -6154,10 +6367,95 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'double']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanAddress']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanAddress const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanTxMode']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Time']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'int']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -6168,12 +6466,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6185,7 +6483,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -6269,7 +6567,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): return def register_Ns3DeviceEnergyModel_methods(root_module, cls): - ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [copy constructor] + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModel const &', 'arg0')]) ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel() [constructor] cls.add_constructor([]) @@ -6318,16 +6616,16 @@ def register_Ns3DeviceEnergyModel_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6337,7 +6635,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6383,7 +6681,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -6410,7 +6708,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -6447,7 +6745,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -6456,12 +6754,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6469,7 +6767,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnergyHarvester_methods(root_module, cls): - ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [copy constructor] + ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [constructor] cls.add_constructor([param('ns3::EnergyHarvester const &', 'arg0')]) ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester() [constructor] cls.add_constructor([]) @@ -6514,7 +6812,7 @@ def register_Ns3EnergyHarvester_methods(root_module, cls): return def register_Ns3EnergySource_methods(root_module, cls): - ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [copy constructor] + ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySource const &', 'arg0')]) ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource() [constructor] cls.add_constructor([]) @@ -6609,7 +6907,7 @@ def register_Ns3EnergySource_methods(root_module, cls): return def register_Ns3EnergySourceContainer_methods(root_module, cls): - ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [copy constructor] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceContainer const &', 'arg0')]) ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer() [constructor] cls.add_constructor([]) @@ -6631,14 +6929,14 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'sourceName')]) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::Begin() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::End() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) ## energy-source-container.h (module 'energy'): ns3::Ptr ns3::EnergySourceContainer::Get(uint32_t i) const [member function] @@ -6669,7 +6967,7 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -6714,7 +7012,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -6725,7 +7023,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6735,7 +7033,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6785,7 +7083,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -6887,16 +7185,16 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6906,7 +7204,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6920,23 +7218,23 @@ def register_Ns3IntegerValue_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6946,7 +7244,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6960,23 +7258,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6986,7 +7284,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7000,23 +7298,23 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7026,7 +7324,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7040,23 +7338,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7066,7 +7364,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7118,23 +7416,23 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7144,7 +7442,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7156,7 +7454,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): return def register_Ns3MobilityModel_methods(root_module, cls): - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor] + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [constructor] cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] cls.add_constructor([]) @@ -7223,7 +7521,7 @@ def register_Ns3MobilityModel_methods(root_module, cls): def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -7335,12 +7633,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback,ns3::Ptr,short unsigned int,const ns3::Address&,const ns3::Address&,ns3::NetDevice::PacketType,ns3::empty,ns3::empty,ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', - [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -7356,7 +7654,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -7397,7 +7695,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -7456,19 +7754,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -7532,23 +7830,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7558,7 +7856,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7573,7 +7871,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -7766,7 +8064,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -7805,7 +8103,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -7815,7 +8113,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -7826,7 +8124,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7836,7 +8134,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7850,16 +8148,16 @@ def register_Ns3PointerValue_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7869,7 +8167,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7883,23 +8181,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7909,7 +8207,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7921,7 +8219,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): return def register_Ns3UanChannel_methods(root_module, cls): - ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel(ns3::UanChannel const & arg0) [copy constructor] + ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel(ns3::UanChannel const & arg0) [constructor] cls.add_constructor([param('ns3::UanChannel const &', 'arg0')]) ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel() [constructor] cls.add_constructor([]) @@ -7963,34 +8261,40 @@ def register_Ns3UanChannel_methods(root_module, cls): ## uan-channel.h (module 'uan'): void ns3::UanChannel::TxPacket(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txmode) [member function] cls.add_method('TxPacket', 'void', - [param('ns3::Ptr< ns3::UanTransducer >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txmode')]) + [param('ns3::Ptr< ns3::UanTransducer >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txmode')], + is_virtual=True) ## uan-channel.h (module 'uan'): void ns3::UanChannel::DoDispose() [member function] cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## uan-channel.h (module 'uan'): void ns3::UanChannel::SendUp(uint32_t i, ns3::Ptr packet, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('SendUp', + 'void', + [param('uint32_t', 'i'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + visibility='protected') return def register_Ns3UanModesListChecker_methods(root_module, cls): ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker() [constructor] cls.add_constructor([]) - ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker(ns3::UanModesListChecker const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker(ns3::UanModesListChecker const & arg0) [constructor] cls.add_constructor([param('ns3::UanModesListChecker const &', 'arg0')]) return def register_Ns3UanModesListValue_methods(root_module, cls): ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue() [constructor] cls.add_constructor([]) - ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesListValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UanModesListValue const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesList const & value) [constructor] cls.add_constructor([param('ns3::UanModesList const &', 'value')]) + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesListValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UanModesListValue const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::Ptr ns3::UanModesListValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uan-tx-mode.h (module 'uan'): bool ns3::UanModesListValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uan-tx-mode.h (module 'uan'): bool ns3::UanModesListValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8000,7 +8304,7 @@ def register_Ns3UanModesListValue_methods(root_module, cls): 'ns3::UanModesList', [], is_const=True) - ## uan-tx-mode.h (module 'uan'): std::string ns3::UanModesListValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uan-tx-mode.h (module 'uan'): std::string ns3::UanModesListValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8012,7 +8316,7 @@ def register_Ns3UanModesListValue_methods(root_module, cls): return def register_Ns3UanNetDevice_methods(root_module, cls): - ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice(ns3::UanNetDevice const & arg0) [copy constructor] + ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice(ns3::UanNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::UanNetDevice const &', 'arg0')]) ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice() [constructor] cls.add_constructor([]) @@ -8157,12 +8461,12 @@ def register_Ns3UanNetDevice_methods(root_module, cls): cls.add_method('SetPhy', 'void', [param('ns3::Ptr< ns3::UanPhy >', 'phy')]) - ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetPromiscReceiveCallback(ns3::Callback,ns3::Ptr,short unsigned int,const ns3::Address&,const ns3::Address&,ns3::NetDevice::PacketType,ns3::empty,ns3::empty,ns3::empty> cb) [member function] + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', - [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -8185,6 +8489,11 @@ def register_Ns3UanNetDevice_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::DoInitialize() [member function] + cls.add_method('DoInitialize', + 'void', + [], + visibility='protected', is_virtual=True) ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::ForwardUp(ns3::Ptr pkt, ns3::UanAddress const & src) [member function] cls.add_method('ForwardUp', 'void', @@ -8195,16 +8504,16 @@ def register_Ns3UanNetDevice_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8214,7 +8523,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8228,23 +8537,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8254,7 +8563,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8268,23 +8577,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8294,7 +8603,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8306,7 +8615,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): return def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): - ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel(ns3::AcousticModemEnergyModel const & arg0) [copy constructor] + ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel(ns3::AcousticModemEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::AcousticModemEnergyModel const &', 'arg0')]) ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel() [constructor] cls.add_constructor([]) @@ -8365,11 +8674,11 @@ def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): 'void', [], is_virtual=True) - ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyDepletionCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyDepletionCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyDepletionCallback callback) [member function] cls.add_method('SetEnergyDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyRechargeCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyRechargeCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyRechargeCallback callback) [member function] cls.add_method('SetEnergyRechargeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -8414,23 +8723,23 @@ def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8440,7 +8749,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8451,8 +8760,404 @@ def register_Ns3AddressValue_methods(root_module, cls): [param('ns3::Address const &', 'value')]) return +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(double arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('double', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(int arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('int', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::MobilityModel const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::MobilityModel const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::UanTxMode arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('double', 'arg1'), param('ns3::UanTxMode', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanAddress_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanAddress arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::UanAddress', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanTxMode arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::UanTxMode', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3UanAddress___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanAddress const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::UanAddress const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::UanTxMode arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1'), param('ns3::UanTxMode', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Unsigned_int_Unsigned_int_Double_Unsigned_int_Double_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Time, ns3::Time, unsigned int, unsigned int, double, unsigned int, double, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::Time arg0, ns3::Time arg1, unsigned int arg2, unsigned int arg3, double arg4, unsigned int arg5, double arg6) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Time', 'arg0'), param('ns3::Time', 'arg1'), param('unsigned int', 'arg2'), param('unsigned int', 'arg3'), param('double', 'arg4'), param('unsigned int', 'arg5'), param('double', 'arg6')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -8474,7 +9179,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -8496,7 +9201,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -8513,7 +9218,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -8535,7 +9240,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -8558,7 +9263,7 @@ def register_Ns3HashFunctionMurmur3_methods(root_module, cls): def register_functions(root_module): module = root_module - ## uan-tx-mode.h (module 'uan'): extern ns3::Ptr ns3::MakeUanModesListChecker() [free function] + ## uan-tx-mode.h (module 'uan'): ns3::Ptr ns3::MakeUanModesListChecker() [free function] module.add_function('MakeUanModesListChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) diff --git a/src/uan/bindings/modulegen__gcc_LP64.py b/src/uan/bindings/modulegen__gcc_LP64.py index dd353893413..1cd338f3a1a 100644 --- a/src/uan/bindings/modulegen__gcc_LP64.py +++ b/src/uan/bindings/modulegen__gcc_LP64.py @@ -44,6 +44,24 @@ def register_types(module): module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList::Iterator']) ## callback.h (module 'core'): ns3::CallbackBase [class] module.add_class('CallbackBase', import_from_module='ns.core') + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeChecker']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::AttributeValue']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::EventImpl']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Hash::Implementation']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::NixVector']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::Packet']) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter [struct] + module.add_class('DefaultDeleter', import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor']) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer [class] module.add_class('DeviceEnergyModelContainer', import_from_module='ns.energy') ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper [class] @@ -84,8 +102,8 @@ def register_types(module): module.add_class('PacketMetadata', import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [struct] module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item [enumeration] - module.add_enum('', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::ItemType [enumeration] + module.add_enum('ItemType', ['PAYLOAD', 'HEADER', 'TRAILER'], outer_class=root_module['ns3::PacketMetadata::Item'], import_from_module='ns.network') ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator [class] module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata']) ## packet.h (module 'network'): ns3::PacketTagIterator [class] @@ -150,9 +168,9 @@ def register_types(module): module.add_class('Vector3D', import_from_module='ns.core') ## empty.h (module 'core'): ns3::empty [class] module.add_class('empty', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t [class] + ## int64x64-128.h (module 'core'): ns3::int64x64_t [class] module.add_class('int64x64_t', import_from_module='ns.core') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::impl_type [enumeration] module.add_enum('impl_type', ['int128_impl', 'cairo_impl', 'ld_impl'], outer_class=root_module['ns3::int64x64_t'], import_from_module='ns.core') ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper [class] module.add_class('AcousticModemEnergyModelHelper', parent=root_module['ns3::DeviceEnergyModelHelper']) @@ -244,6 +262,8 @@ def register_types(module): module.add_class('UanPhyGen', parent=root_module['ns3::UanPhy']) ## uan-phy.h (module 'uan'): ns3::UanPhyPer [class] module.add_class('UanPhyPer', parent=root_module['ns3::Object']) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes [class] + module.add_class('UanPhyPerCommonModes', parent=root_module['ns3::UanPhyPer']) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault [class] module.add_class('UanPhyPerGenDefault', parent=root_module['ns3::UanPhyPer']) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem [class] @@ -398,6 +418,42 @@ def register_types(module): module.add_class('AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker']) ## address.h (module 'network'): ns3::AddressValue [class] module.add_class('AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['ns3::ObjectBase *', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'double', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::UanAddress', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'unsigned short', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'const ns3::Address &', 'const ns3::Address &', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'const ns3::UanAddress &', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::UanTxMode', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Ptr', 'double', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::Time', 'ns3::Time', 'unsigned int', 'unsigned int', 'double', 'unsigned int', 'double', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) + ## callback.h (module 'core'): ns3::CallbackImpl [class] + module.add_class('CallbackImpl', import_from_module='ns.core', template_parameters=['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'], parent=root_module['ns3::CallbackImplBase']) module.add_container('std::list< std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress > >', 'std::pair< ns3::Ptr< ns3::Packet >, ns3::UanAddress >', container_type=u'list') module.add_container('std::vector< ns3::Tap >', 'ns3::Tap', container_type=u'vector') module.add_container('std::vector< std::complex< double > >', 'std::complex< double >', container_type=u'vector') @@ -407,14 +463,14 @@ def register_types(module): module.add_container('std::list< ns3::Ptr< ns3::UanPhy > >', 'ns3::Ptr< ns3::UanPhy >', container_type=u'list') module.add_container('std::vector< std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > > >', 'std::pair< ns3::Ptr< ns3::UanNetDevice >, ns3::Ptr< ns3::UanTransducer > >', container_type=u'vector') module.add_container('std::list< ns3::Ptr< ns3::UanTransducer > >', 'ns3::Ptr< ns3::UanTransducer >', container_type=u'list') - typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') - typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') - typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') - module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') typehandlers.add_type_alias(u'ns3::Vector3D', u'ns3::Vector') typehandlers.add_type_alias(u'ns3::Vector3D*', u'ns3::Vector*') typehandlers.add_type_alias(u'ns3::Vector3D&', u'ns3::Vector&') module.add_typedef(root_module['ns3::Vector3D'], 'Vector') + typehandlers.add_type_alias(u'ns3::Vector3DValue', u'ns3::VectorValue') + typehandlers.add_type_alias(u'ns3::Vector3DValue*', u'ns3::VectorValue*') + typehandlers.add_type_alias(u'ns3::Vector3DValue&', u'ns3::VectorValue&') + module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue') typehandlers.add_type_alias(u'ns3::Vector3DChecker', u'ns3::VectorChecker') typehandlers.add_type_alias(u'ns3::Vector3DChecker*', u'ns3::VectorChecker*') typehandlers.add_type_alias(u'ns3::Vector3DChecker&', u'ns3::VectorChecker&') @@ -453,12 +509,12 @@ def register_types_ns3_Hash(module): ## hash-function.h (module 'core'): ns3::Hash::Implementation [class] module.add_class('Implementation', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter >']) - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash32Function_ptr') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash32Function_ptr*') - typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash32Function_ptr&') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *', u'ns3::Hash::Hash64Function_ptr') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) **', u'ns3::Hash::Hash64Function_ptr*') - typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t ) *&', u'ns3::Hash::Hash64Function_ptr&') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash32Function_ptr') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash32Function_ptr*') + typehandlers.add_type_alias(u'uint32_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash32Function_ptr&') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )', u'ns3::Hash::Hash64Function_ptr') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )*', u'ns3::Hash::Hash64Function_ptr*') + typehandlers.add_type_alias(u'uint64_t ( * ) ( char const *, size_t const )&', u'ns3::Hash::Hash64Function_ptr&') ## Register a nested module for the namespace Function @@ -481,36 +537,36 @@ def register_types_ns3_Hash_Function(module): def register_types_ns3_TracedValueCallback(module): root_module = module.get_root() - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *', u'ns3::TracedValueCallback::Int8') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) **', u'ns3::TracedValueCallback::Int8*') - typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t ) *&', u'ns3::TracedValueCallback::Int8&') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *', u'ns3::TracedValueCallback::Uint8') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) **', u'ns3::TracedValueCallback::Uint8*') - typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t ) *&', u'ns3::TracedValueCallback::Uint8&') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *', u'ns3::TracedValueCallback::Double') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) **', u'ns3::TracedValueCallback::Double*') - typehandlers.add_type_alias(u'void ( * ) ( double, double ) *&', u'ns3::TracedValueCallback::Double&') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *', u'ns3::TracedValueCallback::Uint32') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) **', u'ns3::TracedValueCallback::Uint32*') - typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t ) *&', u'ns3::TracedValueCallback::Uint32&') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *', u'ns3::TracedValueCallback::Time') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) **', u'ns3::TracedValueCallback::Time*') - typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time ) *&', u'ns3::TracedValueCallback::Time&') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *', u'ns3::TracedValueCallback::Bool') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) **', u'ns3::TracedValueCallback::Bool*') - typehandlers.add_type_alias(u'void ( * ) ( bool, bool ) *&', u'ns3::TracedValueCallback::Bool&') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *', u'ns3::TracedValueCallback::Int16') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) **', u'ns3::TracedValueCallback::Int16*') - typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t ) *&', u'ns3::TracedValueCallback::Int16&') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *', u'ns3::TracedValueCallback::Int32') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) **', u'ns3::TracedValueCallback::Int32*') - typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t ) *&', u'ns3::TracedValueCallback::Int32&') - typehandlers.add_type_alias(u'void ( * ) ( ) *', u'ns3::TracedValueCallback::Void') - typehandlers.add_type_alias(u'void ( * ) ( ) **', u'ns3::TracedValueCallback::Void*') - typehandlers.add_type_alias(u'void ( * ) ( ) *&', u'ns3::TracedValueCallback::Void&') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *', u'ns3::TracedValueCallback::Uint16') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) **', u'ns3::TracedValueCallback::Uint16*') - typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t ) *&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )', u'ns3::TracedValueCallback::Time') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )*', u'ns3::TracedValueCallback::Time*') + typehandlers.add_type_alias(u'void ( * ) ( ns3::Time, ns3::Time )&', u'ns3::TracedValueCallback::Time&') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )', u'ns3::TracedValueCallback::Bool') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )*', u'ns3::TracedValueCallback::Bool*') + typehandlers.add_type_alias(u'void ( * ) ( bool, bool )&', u'ns3::TracedValueCallback::Bool&') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )', u'ns3::TracedValueCallback::Int8') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )*', u'ns3::TracedValueCallback::Int8*') + typehandlers.add_type_alias(u'void ( * ) ( int8_t, int8_t )&', u'ns3::TracedValueCallback::Int8&') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )', u'ns3::TracedValueCallback::Uint8') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )*', u'ns3::TracedValueCallback::Uint8*') + typehandlers.add_type_alias(u'void ( * ) ( uint8_t, uint8_t )&', u'ns3::TracedValueCallback::Uint8&') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )', u'ns3::TracedValueCallback::Int16') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )*', u'ns3::TracedValueCallback::Int16*') + typehandlers.add_type_alias(u'void ( * ) ( int16_t, int16_t )&', u'ns3::TracedValueCallback::Int16&') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )', u'ns3::TracedValueCallback::Uint16') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )*', u'ns3::TracedValueCallback::Uint16*') + typehandlers.add_type_alias(u'void ( * ) ( uint16_t, uint16_t )&', u'ns3::TracedValueCallback::Uint16&') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )', u'ns3::TracedValueCallback::Int32') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )*', u'ns3::TracedValueCallback::Int32*') + typehandlers.add_type_alias(u'void ( * ) ( int32_t, int32_t )&', u'ns3::TracedValueCallback::Int32&') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )', u'ns3::TracedValueCallback::Uint32') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )*', u'ns3::TracedValueCallback::Uint32*') + typehandlers.add_type_alias(u'void ( * ) ( uint32_t, uint32_t )&', u'ns3::TracedValueCallback::Uint32&') + typehandlers.add_type_alias(u'void ( * ) ( double, double )', u'ns3::TracedValueCallback::Double') + typehandlers.add_type_alias(u'void ( * ) ( double, double )*', u'ns3::TracedValueCallback::Double*') + typehandlers.add_type_alias(u'void ( * ) ( double, double )&', u'ns3::TracedValueCallback::Double&') + typehandlers.add_type_alias(u'void ( * ) ( )', u'ns3::TracedValueCallback::Void') + typehandlers.add_type_alias(u'void ( * ) ( )*', u'ns3::TracedValueCallback::Void*') + typehandlers.add_type_alias(u'void ( * ) ( )&', u'ns3::TracedValueCallback::Void&') def register_types_ns3_internal(module): root_module = module.get_root() @@ -528,6 +584,15 @@ def register_methods(root_module): register_Ns3ByteTagListIterator_methods(root_module, root_module['ns3::ByteTagList::Iterator']) register_Ns3ByteTagListIteratorItem_methods(root_module, root_module['ns3::ByteTagList::Iterator::Item']) register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase']) + register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeAccessor >']) + register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeChecker >']) + register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, root_module['ns3::DefaultDeleter< ns3::AttributeValue >']) + register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, root_module['ns3::DefaultDeleter< ns3::CallbackImplBase >']) + register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, root_module['ns3::DefaultDeleter< ns3::EventImpl >']) + register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Hash::Implementation >']) + register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, root_module['ns3::DefaultDeleter< ns3::NixVector >']) + register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, root_module['ns3::DefaultDeleter< ns3::Packet >']) + register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::DefaultDeleter< ns3::TraceSourceAccessor >']) register_Ns3DeviceEnergyModelContainer_methods(root_module, root_module['ns3::DeviceEnergyModelContainer']) register_Ns3DeviceEnergyModelHelper_methods(root_module, root_module['ns3::DeviceEnergyModelHelper']) register_Ns3EnergySourceHelper_methods(root_module, root_module['ns3::EnergySourceHelper']) @@ -614,6 +679,7 @@ def register_methods(root_module): register_Ns3UanPhyDual_methods(root_module, root_module['ns3::UanPhyDual']) register_Ns3UanPhyGen_methods(root_module, root_module['ns3::UanPhyGen']) register_Ns3UanPhyPer_methods(root_module, root_module['ns3::UanPhyPer']) + register_Ns3UanPhyPerCommonModes_methods(root_module, root_module['ns3::UanPhyPerCommonModes']) register_Ns3UanPhyPerGenDefault_methods(root_module, root_module['ns3::UanPhyPerGenDefault']) register_Ns3UanPhyPerUmodem_methods(root_module, root_module['ns3::UanPhyPerUmodem']) register_Ns3UanPropModel_methods(root_module, root_module['ns3::UanPropModel']) @@ -689,6 +755,24 @@ def register_methods(root_module): register_Ns3AcousticModemEnergyModel_methods(root_module, root_module['ns3::AcousticModemEnergyModel']) register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker']) register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue']) + register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< bool, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanAddress_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3UanAddress___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Ptr, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Unsigned_int_Unsigned_int_Double_Unsigned_int_Double_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::Time, ns3::Time, unsigned int, unsigned int, double, unsigned int, double, ns3::empty, ns3::empty >']) + register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, root_module['ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >']) register_Ns3HashImplementation_methods(root_module, root_module['ns3::Hash::Implementation']) register_Ns3HashFunctionFnv1a_methods(root_module, root_module['ns3::Hash::Function::Fnv1a']) register_Ns3HashFunctionHash32_methods(root_module, root_module['ns3::Hash::Function::Hash32']) @@ -697,15 +781,15 @@ def register_methods(root_module): return def register_Ns3Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') ## address.h (module 'network'): ns3::Address::Address() [constructor] cls.add_constructor([]) ## address.h (module 'network'): ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor] cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')]) - ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [copy constructor] + ## address.h (module 'network'): ns3::Address::Address(ns3::Address const & address) [constructor] cls.add_constructor([param('ns3::Address const &', 'address')]) ## address.h (module 'network'): bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function] cls.add_method('CheckCompatible', @@ -767,25 +851,25 @@ def register_Ns3Address_methods(root_module, cls): return def register_Ns3AttributeConstructionList_methods(root_module, cls): - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] + ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr checker, ns3::Ptr value) [member function] cls.add_method('Add', 'void', [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')]) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::Begin() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::Begin() const [member function] cls.add_method('Begin', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): std::_List_const_iterator ns3::AttributeConstructionList::End() const [member function] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::CIterator ns3::AttributeConstructionList::End() const [member function] cls.add_method('End', - 'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', + 'ns3::AttributeConstructionList::CIterator', [], is_const=True) - ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] + ## attribute-construction-list.h (module 'core'): ns3::Ptr ns3::AttributeConstructionList::Find(ns3::Ptr checker) const [member function] cls.add_method('Find', 'ns3::Ptr< ns3::AttributeValue >', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -795,7 +879,7 @@ def register_Ns3AttributeConstructionList_methods(root_module, cls): def register_Ns3AttributeConstructionListItem_methods(root_module, cls): ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor] cls.add_constructor([]) - ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor] + ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeConstructionList::Item const &', 'arg0')]) ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) @@ -806,14 +890,14 @@ def register_Ns3AttributeConstructionListItem_methods(root_module, cls): return def register_Ns3Buffer_methods(root_module, cls): + ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [constructor] + cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer() [constructor] cls.add_constructor([]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize')]) ## buffer.h (module 'network'): ns3::Buffer::Buffer(uint32_t dataSize, bool initialize) [constructor] cls.add_constructor([param('uint32_t', 'dataSize'), param('bool', 'initialize')]) - ## buffer.h (module 'network'): ns3::Buffer::Buffer(ns3::Buffer const & o) [copy constructor] - cls.add_constructor([param('ns3::Buffer const &', 'o')]) ## buffer.h (module 'network'): void ns3::Buffer::AddAtEnd(uint32_t end) [member function] cls.add_method('AddAtEnd', 'void', @@ -886,7 +970,7 @@ def register_Ns3Buffer_methods(root_module, cls): return def register_Ns3BufferIterator_methods(root_module, cls): - ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [copy constructor] + ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator(ns3::Buffer::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::Buffer::Iterator const &', 'arg0')]) ## buffer.h (module 'network'): ns3::Buffer::Iterator::Iterator() [constructor] cls.add_constructor([]) @@ -1046,7 +1130,7 @@ def register_Ns3BufferIterator_methods(root_module, cls): return def register_Ns3ByteTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -1060,7 +1144,7 @@ def register_Ns3ByteTagIterator_methods(root_module, cls): return def register_Ns3ByteTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetEnd() const [member function] cls.add_method('GetEnd', @@ -1087,7 +1171,7 @@ def register_Ns3ByteTagIteratorItem_methods(root_module, cls): def register_Ns3ByteTagList_methods(root_module, cls): ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList() [constructor] cls.add_constructor([]) - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::ByteTagList(ns3::ByteTagList const & o) [constructor] cls.add_constructor([param('ns3::ByteTagList const &', 'o')]) ## byte-tag-list.h (module 'network'): ns3::TagBuffer ns3::ByteTagList::Add(ns3::TypeId tid, uint32_t bufferSize, int32_t start, int32_t end) [member function] cls.add_method('Add', @@ -1121,7 +1205,7 @@ def register_Ns3ByteTagList_methods(root_module, cls): return def register_Ns3ByteTagListIterator_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Iterator(ns3::ByteTagList::Iterator const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator const &', 'arg0')]) ## byte-tag-list.h (module 'network'): uint32_t ns3::ByteTagList::Iterator::GetOffsetStart() const [member function] cls.add_method('GetOffsetStart', @@ -1140,7 +1224,7 @@ def register_Ns3ByteTagListIterator_methods(root_module, cls): return def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): - ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [copy constructor] + ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::ByteTagList::Iterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::ByteTagList::Iterator::Item const &', 'arg0')]) ## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::Item(ns3::TagBuffer buf) [constructor] cls.add_constructor([param('ns3::TagBuffer', 'buf')]) @@ -1157,7 +1241,7 @@ def register_Ns3ByteTagListIteratorItem_methods(root_module, cls): return def register_Ns3CallbackBase_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor] cls.add_constructor([]) @@ -1171,8 +1255,116 @@ def register_Ns3CallbackBase_methods(root_module, cls): visibility='protected') return +def register_Ns3DefaultDeleter__Ns3AttributeAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeAccessor *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeChecker_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeChecker > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeChecker * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeChecker *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3AttributeValue_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::AttributeValue > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::AttributeValue * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::AttributeValue *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3CallbackImplBase_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::CallbackImplBase > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::CallbackImplBase * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::CallbackImplBase *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3EventImpl_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::EventImpl > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::EventImpl * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::EventImpl *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3HashImplementation_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Hash::Implementation > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Hash::Implementation * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Hash::Implementation *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3NixVector_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::NixVector > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::NixVector * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::NixVector *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3Packet_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::Packet > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::Packet * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::Packet *', 'object')], + is_static=True) + return + +def register_Ns3DefaultDeleter__Ns3TraceSourceAccessor_methods(root_module, cls): + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter() [constructor] + cls.add_constructor([]) + ## default-deleter.h (module 'core'): ns3::DefaultDeleter::DefaultDeleter(ns3::DefaultDeleter const & arg0) [constructor] + cls.add_constructor([param('ns3::DefaultDeleter< ns3::TraceSourceAccessor > const &', 'arg0')]) + ## default-deleter.h (module 'core'): static void ns3::DefaultDeleter::Delete(ns3::TraceSourceAccessor * object) [member function] + cls.add_method('Delete', + 'void', + [param('ns3::TraceSourceAccessor *', 'object')], + is_static=True) + return + def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): - ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [copy constructor] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer(ns3::DeviceEnergyModelContainer const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelContainer const &', 'arg0')]) ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::DeviceEnergyModelContainer() [constructor] cls.add_constructor([]) @@ -1194,18 +1386,18 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'modelName')]) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::Begin() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): void ns3::DeviceEnergyModelContainer::Clear() [member function] cls.add_method('Clear', 'void', []) - ## device-energy-model-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::DeviceEnergyModelContainer::End() const [member function] + ## device-energy-model-container.h (module 'energy'): ns3::DeviceEnergyModelContainer::Iterator ns3::DeviceEnergyModelContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::DeviceEnergyModel > const, std::vector< ns3::Ptr< ns3::DeviceEnergyModel > > >', + 'ns3::DeviceEnergyModelContainer::Iterator', [], is_const=True) ## device-energy-model-container.h (module 'energy'): ns3::Ptr ns3::DeviceEnergyModelContainer::Get(uint32_t i) const [member function] @@ -1223,7 +1415,7 @@ def register_Ns3DeviceEnergyModelContainer_methods(root_module, cls): def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelHelper::DeviceEnergyModelHelper(ns3::DeviceEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModelHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::DeviceEnergyModelContainer ns3::DeviceEnergyModelHelper::Install(ns3::Ptr device, ns3::Ptr source) const [member function] cls.add_method('Install', @@ -1250,7 +1442,7 @@ def register_Ns3DeviceEnergyModelHelper_methods(root_module, cls): def register_Ns3EnergySourceHelper_methods(root_module, cls): ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper() [constructor] cls.add_constructor([]) - ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [copy constructor] + ## energy-model-helper.h (module 'energy'): ns3::EnergySourceHelper::EnergySourceHelper(ns3::EnergySourceHelper const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceHelper const &', 'arg0')]) ## energy-model-helper.h (module 'energy'): ns3::EnergySourceContainer ns3::EnergySourceHelper::Install(ns3::Ptr node) const [member function] cls.add_method('Install', @@ -1285,9 +1477,9 @@ def register_Ns3EnergySourceHelper_methods(root_module, cls): return def register_Ns3EventId_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_binary_comparison_operator('==') - ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## event-id.h (module 'core'): ns3::EventId::EventId(ns3::EventId const & arg0) [constructor] cls.add_constructor([param('ns3::EventId const &', 'arg0')]) ## event-id.h (module 'core'): ns3::EventId::EventId() [constructor] cls.add_constructor([]) @@ -1330,7 +1522,7 @@ def register_Ns3EventId_methods(root_module, cls): return def register_Ns3Hasher_methods(root_module, cls): - ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [copy constructor] + ## hash.h (module 'core'): ns3::Hasher::Hasher(ns3::Hasher const & arg0) [constructor] cls.add_constructor([param('ns3::Hasher const &', 'arg0')]) ## hash.h (module 'core'): ns3::Hasher::Hasher() [constructor] cls.add_constructor([]) @@ -1359,11 +1551,11 @@ def register_Ns3Hasher_methods(root_module, cls): return def register_Ns3Ipv4Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') + ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(ns3::Ipv4Address const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor] cls.add_constructor([]) @@ -1477,10 +1669,10 @@ def register_Ns3Ipv4Address_methods(root_module, cls): return def register_Ns3Ipv4Mask_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') - ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [copy constructor] + cls.add_binary_comparison_operator('!=') + ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(ns3::Ipv4Mask const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor] cls.add_constructor([]) @@ -1540,17 +1732,17 @@ def register_Ns3Ipv4Mask_methods(root_module, cls): return def register_Ns3Ipv6Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(char const * address) [constructor] cls.add_constructor([param('char const *', 'address')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(uint8_t * address) [constructor] cls.add_constructor([param('uint8_t *', 'address')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const & addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'addr')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Address::Ipv6Address(ns3::Ipv6Address const * addr) [constructor] cls.add_constructor([param('ns3::Ipv6Address const *', 'addr')]) @@ -1617,7 +1809,7 @@ def register_Ns3Ipv6Address_methods(root_module, cls): cls.add_method('IsAllHostsMulticast', 'bool', [], - deprecated=True, is_const=True) + is_const=True) ## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function] cls.add_method('IsAllNodesMulticast', 'bool', @@ -1739,9 +1931,9 @@ def register_Ns3Ipv6Address_methods(root_module, cls): return def register_Ns3Ipv6Prefix_methods(root_module, cls): - cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix() [constructor] cls.add_constructor([]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t * prefix) [constructor] @@ -1750,7 +1942,7 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): cls.add_constructor([param('char const *', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(uint8_t prefix) [constructor] cls.add_constructor([param('uint8_t', 'prefix')]) - ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const & prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'prefix')]) ## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(ns3::Ipv6Prefix const * prefix) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const *', 'prefix')]) @@ -1797,11 +1989,11 @@ def register_Ns3Ipv6Prefix_methods(root_module, cls): return def register_Ns3Mac48Address_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(ns3::Mac48Address const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor] cls.add_constructor([]) @@ -1869,7 +2061,7 @@ def register_Ns3Mac48Address_methods(root_module, cls): return def register_Ns3NetDeviceContainer_methods(root_module, cls): - ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')]) ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor] cls.add_constructor([]) @@ -1891,14 +2083,14 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'deviceName')]) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::Begin() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) - ## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NetDeviceContainer::End() const [member function] + ## net-device-container.h (module 'network'): ns3::NetDeviceContainer::Iterator ns3::NetDeviceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::NetDevice > const, std::vector< ns3::Ptr< ns3::NetDevice > > >', + 'ns3::NetDeviceContainer::Iterator', [], is_const=True) ## net-device-container.h (module 'network'): ns3::Ptr ns3::NetDeviceContainer::Get(uint32_t i) const [member function] @@ -1914,7 +2106,7 @@ def register_Ns3NetDeviceContainer_methods(root_module, cls): return def register_Ns3NodeContainer_methods(root_module, cls): - ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor] + ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [constructor] cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')]) ## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor] cls.add_constructor([]) @@ -1942,9 +2134,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'nodeName')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::Begin() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): void ns3::NodeContainer::Create(uint32_t n) [member function] @@ -1955,9 +2147,9 @@ def register_Ns3NodeContainer_methods(root_module, cls): cls.add_method('Create', 'void', [param('uint32_t', 'n'), param('uint32_t', 'systemId')]) - ## node-container.h (module 'network'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::NodeContainer::End() const [member function] + ## node-container.h (module 'network'): ns3::NodeContainer::Iterator ns3::NodeContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Node > const, std::vector< ns3::Ptr< ns3::Node > > >', + 'ns3::NodeContainer::Iterator', [], is_const=True) ## node-container.h (module 'network'): ns3::Ptr ns3::NodeContainer::Get(uint32_t i) const [member function] @@ -1980,7 +2172,7 @@ def register_Ns3NodeContainer_methods(root_module, cls): def register_Ns3ObjectBase_methods(root_module, cls): ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor] cls.add_constructor([]) - ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor] + ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectBase const &', 'arg0')]) ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function] cls.add_method('GetAttribute', @@ -2041,7 +2233,7 @@ def register_Ns3ObjectBase_methods(root_module, cls): def register_Ns3ObjectDeleter_methods(root_module, cls): ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor] cls.add_constructor([]) - ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectDeleter const &', 'arg0')]) ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function] cls.add_method('Delete', @@ -2052,7 +2244,7 @@ def register_Ns3ObjectDeleter_methods(root_module, cls): def register_Ns3ObjectFactory_methods(root_module, cls): cls.add_output_stream_operator() - ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(ns3::ObjectFactory const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor] cls.add_constructor([]) @@ -2089,7 +2281,7 @@ def register_Ns3ObjectFactory_methods(root_module, cls): def register_Ns3PacketMetadata_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(uint64_t uid, uint32_t size) [constructor] cls.add_constructor([param('uint64_t', 'uid'), param('uint32_t', 'size')]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::PacketMetadata(ns3::PacketMetadata const & o) [constructor] cls.add_constructor([param('ns3::PacketMetadata const &', 'o')]) ## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddAtEnd(ns3::PacketMetadata const & o) [member function] cls.add_method('AddAtEnd', @@ -2167,7 +2359,7 @@ def register_Ns3PacketMetadata_methods(root_module, cls): def register_Ns3PacketMetadataItem_methods(root_module, cls): ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item() [constructor] cls.add_constructor([]) - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::Item(ns3::PacketMetadata::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::Item const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::current [variable] cls.add_instance_attribute('current', 'ns3::Buffer::Iterator', is_const=False) @@ -2181,10 +2373,12 @@ def register_Ns3PacketMetadataItem_methods(root_module, cls): cls.add_instance_attribute('isFragment', 'bool', is_const=False) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::tid [variable] cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False) + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::type [variable] + cls.add_instance_attribute('type', 'ns3::PacketMetadata::Item::ItemType', is_const=False) return def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): - ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy constructor] + ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketMetadata::ItemIterator const &', 'arg0')]) ## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata const * metadata, ns3::Buffer buffer) [constructor] cls.add_constructor([param('ns3::PacketMetadata const *', 'metadata'), param('ns3::Buffer', 'buffer')]) @@ -2200,7 +2394,7 @@ def register_Ns3PacketMetadataItemIterator_methods(root_module, cls): return def register_Ns3PacketTagIterator_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')]) ## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function] cls.add_method('HasNext', @@ -2214,7 +2408,7 @@ def register_Ns3PacketTagIterator_methods(root_module, cls): return def register_Ns3PacketTagIteratorItem_methods(root_module, cls): - ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy constructor] + ## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagIterator::Item const &', 'arg0')]) ## packet.h (module 'network'): void ns3::PacketTagIterator::Item::GetTag(ns3::Tag & tag) const [member function] cls.add_method('GetTag', @@ -2231,7 +2425,7 @@ def register_Ns3PacketTagIteratorItem_methods(root_module, cls): def register_Ns3PacketTagList_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::PacketTagList(ns3::PacketTagList const & o) [constructor] cls.add_constructor([param('ns3::PacketTagList const &', 'o')]) ## packet-tag-list.h (module 'network'): void ns3::PacketTagList::Add(ns3::Tag const & tag) const [member function] cls.add_method('Add', @@ -2265,7 +2459,7 @@ def register_Ns3PacketTagList_methods(root_module, cls): def register_Ns3PacketTagListTagData_methods(root_module, cls): ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData() [constructor] cls.add_constructor([]) - ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [copy constructor] + ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::TagData(ns3::PacketTagList::TagData const & arg0) [constructor] cls.add_constructor([param('ns3::PacketTagList::TagData const &', 'arg0')]) ## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::count [variable] cls.add_instance_attribute('count', 'uint32_t', is_const=False) @@ -2280,7 +2474,7 @@ def register_Ns3PacketTagListTagData_methods(root_module, cls): return def register_Ns3Reservation_methods(root_module, cls): - ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(ns3::Reservation const & arg0) [copy constructor] + ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation(ns3::Reservation const & arg0) [constructor] cls.add_constructor([param('ns3::Reservation const &', 'arg0')]) ## uan-mac-rc.h (module 'uan'): ns3::Reservation::Reservation() [constructor] cls.add_constructor([]) @@ -2342,7 +2536,7 @@ def register_Ns3Reservation_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount::SimpleRefCount(ns3::SimpleRefCount const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount::Cleanup() [member function] cls.add_method('Cleanup', @@ -2352,7 +2546,7 @@ def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods return def register_Ns3Simulator_methods(root_module, cls): - ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy constructor] + ## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [constructor] cls.add_constructor([param('ns3::Simulator const &', 'arg0')]) ## simulator.h (module 'core'): static void ns3::Simulator::Cancel(ns3::EventId const & id) [member function] cls.add_method('Cancel', @@ -2434,7 +2628,7 @@ def register_Ns3Simulator_methods(root_module, cls): def register_Ns3Tag_methods(root_module, cls): ## tag.h (module 'network'): ns3::Tag::Tag() [constructor] cls.add_constructor([]) - ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [copy constructor] + ## tag.h (module 'network'): ns3::Tag::Tag(ns3::Tag const & arg0) [constructor] cls.add_constructor([param('ns3::Tag const &', 'arg0')]) ## tag.h (module 'network'): void ns3::Tag::Deserialize(ns3::TagBuffer i) [member function] cls.add_method('Deserialize', @@ -2464,7 +2658,7 @@ def register_Ns3Tag_methods(root_module, cls): return def register_Ns3TagBuffer_methods(root_module, cls): - ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy constructor] + ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [constructor] cls.add_constructor([param('ns3::TagBuffer const &', 'arg0')]) ## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(uint8_t * start, uint8_t * end) [constructor] cls.add_constructor([param('uint8_t *', 'start'), param('uint8_t *', 'end')]) @@ -2508,14 +2702,14 @@ def register_Ns3TagBuffer_methods(root_module, cls): cls.add_method('WriteDouble', 'void', [param('double', 'v')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t data) [member function] + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU16(uint16_t v) [member function] cls.add_method('WriteU16', 'void', - [param('uint16_t', 'data')]) - ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function] + [param('uint16_t', 'v')]) + ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t v) [member function] cls.add_method('WriteU32', 'void', - [param('uint32_t', 'data')]) + [param('uint32_t', 'v')]) ## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function] cls.add_method('WriteU64', 'void', @@ -2527,7 +2721,7 @@ def register_Ns3TagBuffer_methods(root_module, cls): return def register_Ns3Tap_methods(root_module, cls): - ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Tap const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap(ns3::Tap const & arg0) [constructor] cls.add_constructor([param('ns3::Tap const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): ns3::Tap::Tap() [constructor] cls.add_constructor([]) @@ -2547,7 +2741,7 @@ def register_Ns3Tap_methods(root_module, cls): def register_Ns3TimeWithUnit_methods(root_module, cls): cls.add_output_stream_operator() - ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [copy constructor] + ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::TimeWithUnit const & arg0) [constructor] cls.add_constructor([param('ns3::TimeWithUnit const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeWithUnit::TimeWithUnit(ns3::Time const time, ns3::Time::Unit const unit) [constructor] cls.add_constructor([param('ns3::Time const', 'time'), param('ns3::Time::Unit const', 'unit')]) @@ -2556,11 +2750,15 @@ def register_Ns3TimeWithUnit_methods(root_module, cls): def register_Ns3TracedValue__Double_methods(root_module, cls): ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue() [constructor] cls.add_constructor([]) - ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [copy constructor] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & o) [constructor] cls.add_constructor([param('ns3::TracedValue< double > const &', 'o')]) ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(double const & v) [constructor] cls.add_constructor([param('double const &', 'v')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): ns3::TracedValue::TracedValue(ns3::TracedValue const & other) [constructor] + cls.add_constructor([param('ns3::TracedValue< double > const &', 'other')]) + ## traced-value.h (module 'core'): void ns3::TracedValue::Connect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Connect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -2568,7 +2766,7 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): cls.add_method('ConnectWithoutContext', 'void', [param('ns3::CallbackBase const &', 'cb')]) - ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::basic_string,std::allocator > path) [member function] + ## traced-value.h (module 'core'): void ns3::TracedValue::Disconnect(ns3::CallbackBase const & cb, std::string path) [member function] cls.add_method('Disconnect', 'void', [param('ns3::CallbackBase const &', 'cb'), param('std::string', 'path')]) @@ -2588,33 +2786,32 @@ def register_Ns3TracedValue__Double_methods(root_module, cls): return def register_Ns3TypeId_methods(root_module, cls): - cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('<') ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor] cls.add_constructor([param('char const *', 'name')]) ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'o')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, uint32_t flags, ns3::AttributeValue const & initialValue, ns3::Ptr accessor, ns3::Ptr checker, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddAttribute', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('uint32_t', 'flags'), param('ns3::AttributeValue const &', 'initialValue'), param('ns3::Ptr< ns3::AttributeAccessor const >', 'accessor'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor) [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')], - deprecated=True) - ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SUPPORTED, std::string const & supportMsg="") [member function] + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')]) + ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr accessor, std::string callback, ns3::TypeId::SupportLevel supportLevel=::ns3::TypeId::SupportLevel::SUPPORTED, std::string const & supportMsg="") [member function] cls.add_method('AddTraceSource', 'ns3::TypeId', - [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) + [param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor'), param('std::string', 'callback'), param('ns3::TypeId::SupportLevel', 'supportLevel', default_value='::ns3::TypeId::SupportLevel::SUPPORTED'), param('std::string const &', 'supportMsg', default_value='""')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation ns3::TypeId::GetAttribute(uint32_t i) const [member function] cls.add_method('GetAttribute', 'ns3::TypeId::AttributeInformation', @@ -2630,7 +2827,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'uint32_t', [], is_const=True) - ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] + ## type-id.h (module 'core'): ns3::Callback ns3::TypeId::GetConstructor() const [member function] cls.add_method('GetConstructor', 'ns3::Callback< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', [], @@ -2640,9 +2837,9 @@ def register_Ns3TypeId_methods(root_module, cls): 'std::string', [], is_const=True) - ## type-id.h (module 'core'): uint32_t ns3::TypeId::GetHash() const [member function] + ## type-id.h (module 'core'): ns3::TypeId::hash_t ns3::TypeId::GetHash() const [member function] cls.add_method('GetHash', - 'uint32_t', + 'ns3::TypeId::hash_t', [], is_const=True) ## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function] @@ -2709,12 +2906,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info', transfer_ownership=False)], is_const=True) - ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(uint32_t hash) [member function] + ## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByHash(ns3::TypeId::hash_t hash) [member function] cls.add_method('LookupByHash', 'ns3::TypeId', [param('uint32_t', 'hash')], is_static=True) - ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(uint32_t hash, ns3::TypeId * tid) [member function] + ## type-id.h (module 'core'): static bool ns3::TypeId::LookupByHashFailSafe(ns3::TypeId::hash_t hash, ns3::TypeId * tid) [member function] cls.add_method('LookupByHashFailSafe', 'bool', [param('uint32_t', 'hash'), param('ns3::TypeId *', 'tid')], @@ -2724,12 +2921,12 @@ def register_Ns3TypeId_methods(root_module, cls): 'ns3::TypeId', [param('std::string', 'name')], is_static=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name')], is_const=True) - ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] + ## type-id.h (module 'core'): ns3::Ptr ns3::TypeId::LookupTraceSourceByName(std::string name, ns3::TypeId::TraceSourceInformation * info) const [member function] cls.add_method('LookupTraceSourceByName', 'ns3::Ptr< ns3::TraceSourceAccessor const >', [param('std::string', 'name'), param('ns3::TypeId::TraceSourceInformation *', 'info')], @@ -2739,7 +2936,7 @@ def register_Ns3TypeId_methods(root_module, cls): 'bool', [], is_const=True) - ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] + ## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr initialValue) [member function] cls.add_method('SetAttributeInitialValue', 'bool', [param('uint32_t', 'i'), param('ns3::Ptr< ns3::AttributeValue const >', 'initialValue')]) @@ -2764,13 +2961,12 @@ def register_Ns3TypeId_methods(root_module, cls): def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::AttributeInformation(ns3::TypeId::AttributeInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::AttributeInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::AttributeAccessor const >', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::checker [variable] cls.add_instance_attribute('checker', 'ns3::Ptr< ns3::AttributeChecker const >', is_const=False) - ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::flags [variable] cls.add_instance_attribute('flags', 'uint32_t', is_const=False) ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::help [variable] cls.add_instance_attribute('help', 'std::string', is_const=False) @@ -2789,7 +2985,7 @@ def register_Ns3TypeIdAttributeInformation_methods(root_module, cls): def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::TraceSourceInformation(ns3::TypeId::TraceSourceInformation const & arg0) [constructor] cls.add_constructor([param('ns3::TypeId::TraceSourceInformation const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::accessor [variable] cls.add_instance_attribute('accessor', 'ns3::Ptr< ns3::TraceSourceAccessor const >', is_const=False) @@ -2807,10 +3003,10 @@ def register_Ns3TypeIdTraceSourceInformation_methods(root_module, cls): def register_Ns3UanAddress_methods(root_module, cls): cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('!=') cls.add_output_stream_operator() - cls.add_binary_comparison_operator('==') - ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(ns3::UanAddress const & arg0) [copy constructor] + ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress(ns3::UanAddress const & arg0) [constructor] cls.add_constructor([param('ns3::UanAddress const &', 'arg0')]) ## uan-address.h (module 'uan'): ns3::UanAddress::UanAddress() [constructor] cls.add_constructor([]) @@ -2852,7 +3048,7 @@ def register_Ns3UanAddress_methods(root_module, cls): return def register_Ns3UanHelper_methods(root_module, cls): - ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper(ns3::UanHelper const & arg0) [copy constructor] + ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper(ns3::UanHelper const & arg0) [constructor] cls.add_constructor([param('ns3::UanHelper const &', 'arg0')]) ## uan-helper.h (module 'uan'): ns3::UanHelper::UanHelper() [constructor] cls.add_constructor([]) @@ -2911,7 +3107,7 @@ def register_Ns3UanHelper_methods(root_module, cls): def register_Ns3UanModesList_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList(ns3::UanModesList const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList(ns3::UanModesList const & arg0) [constructor] cls.add_constructor([param('ns3::UanModesList const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanModesList::UanModesList() [constructor] cls.add_constructor([]) @@ -2931,7 +3127,7 @@ def register_Ns3UanModesList_methods(root_module, cls): return def register_Ns3UanPacketArrival_methods(root_module, cls): - ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::UanPacketArrival const & arg0) [copy constructor] + ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival(ns3::UanPacketArrival const & arg0) [constructor] cls.add_constructor([param('ns3::UanPacketArrival const &', 'arg0')]) ## uan-transducer.h (module 'uan'): ns3::UanPacketArrival::UanPacketArrival() [constructor] cls.add_constructor([]) @@ -2966,29 +3162,29 @@ def register_Ns3UanPacketArrival_methods(root_module, cls): def register_Ns3UanPdp_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(ns3::UanPdp const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(ns3::UanPdp const & arg0) [constructor] cls.add_constructor([param('ns3::UanPdp const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp() [constructor] cls.add_constructor([]) ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > taps, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< ns3::Tap >', 'taps'), param('ns3::Time', 'resolution')]) - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector,std::allocator > > arrivals, ns3::Time resolution) [constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector, std::allocator > > arrivals, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< std::complex< double > >', 'arrivals'), param('ns3::Time', 'resolution')]) - ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > arrivals, ns3::Time resolution) [constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::UanPdp(std::vector > arrivals, ns3::Time resolution) [constructor] cls.add_constructor([param('std::vector< double >', 'arrivals'), param('ns3::Time', 'resolution')]) ## uan-prop-model.h (module 'uan'): static ns3::UanPdp ns3::UanPdp::CreateImpulsePdp() [member function] cls.add_method('CreateImpulsePdp', 'ns3::UanPdp', [], is_static=True) - ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetBegin() const [member function] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::Iterator ns3::UanPdp::GetBegin() const [member function] cls.add_method('GetBegin', - '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + 'ns3::UanPdp::Iterator', [], is_const=True) - ## uan-prop-model.h (module 'uan'): __gnu_cxx::__normal_iterator > > ns3::UanPdp::GetEnd() const [member function] + ## uan-prop-model.h (module 'uan'): ns3::UanPdp::Iterator ns3::UanPdp::GetEnd() const [member function] cls.add_method('GetEnd', - '__gnu_cxx::__normal_iterator< ns3::Tap const *, std::vector< ns3::Tap > >', + 'ns3::UanPdp::Iterator', [], is_const=True) ## uan-prop-model.h (module 'uan'): uint32_t ns3::UanPdp::GetNTaps() const [member function] @@ -3006,6 +3202,10 @@ def register_Ns3UanPdp_methods(root_module, cls): 'ns3::Tap const &', [param('uint32_t', 'i')], is_const=True) + ## uan-prop-model.h (module 'uan'): ns3::UanPdp ns3::UanPdp::NormalizeToSumNc() [member function] + cls.add_method('NormalizeToSumNc', + 'ns3::UanPdp', + []) ## uan-prop-model.h (module 'uan'): void ns3::UanPdp::SetNTaps(uint32_t nTaps) [member function] cls.add_method('SetNTaps', 'void', @@ -3043,7 +3243,7 @@ def register_Ns3UanPdp_methods(root_module, cls): def register_Ns3UanPhyListener_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener(ns3::UanPhyListener const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyListener::UanPhyListener(ns3::UanPhyListener const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyListener const &', 'arg0')]) ## uan-phy.h (module 'uan'): void ns3::UanPhyListener::NotifyCcaEnd() [member function] cls.add_method('NotifyCcaEnd', @@ -3079,7 +3279,7 @@ def register_Ns3UanPhyListener_methods(root_module, cls): def register_Ns3UanTxMode_methods(root_module, cls): cls.add_output_stream_operator() - ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode(ns3::UanTxMode const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode(ns3::UanTxMode const & arg0) [constructor] cls.add_constructor([param('ns3::UanTxMode const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanTxMode::UanTxMode() [constructor] cls.add_constructor([]) @@ -3126,7 +3326,7 @@ def register_Ns3UanTxMode_methods(root_module, cls): return def register_Ns3UanTxModeFactory_methods(root_module, cls): - ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory(ns3::UanTxModeFactory const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory(ns3::UanTxModeFactory const & arg0) [constructor] cls.add_constructor([param('ns3::UanTxModeFactory const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanTxModeFactory::UanTxModeFactory() [constructor] cls.add_constructor([]) @@ -3148,14 +3348,21 @@ def register_Ns3UanTxModeFactory_methods(root_module, cls): return def register_Ns3Vector2D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector2D'], root_module['ns3::Vector2D'], param('ns3::Vector2D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector2D::Vector2D(ns3::Vector2D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D(double _x, double _y) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y')]) ## vector.h (module 'core'): ns3::Vector2D::Vector2D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector2D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector2D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector2D::y [variable] @@ -3163,14 +3370,21 @@ def register_Ns3Vector2D_methods(root_module, cls): return def register_Ns3Vector3D_methods(root_module, cls): - cls.add_binary_comparison_operator('<') cls.add_output_stream_operator() - ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [copy constructor] + cls.add_binary_numeric_operator('-', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_numeric_operator('+', root_module['ns3::Vector3D'], root_module['ns3::Vector3D'], param('ns3::Vector3D const &', u'right')) + cls.add_binary_comparison_operator('<') + ## vector.h (module 'core'): ns3::Vector3D::Vector3D(ns3::Vector3D const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D(double _x, double _y, double _z) [constructor] cls.add_constructor([param('double', '_x'), param('double', '_y'), param('double', '_z')]) ## vector.h (module 'core'): ns3::Vector3D::Vector3D() [constructor] cls.add_constructor([]) + ## vector.h (module 'core'): double ns3::Vector3D::GetLength() const [member function] + cls.add_method('GetLength', + 'double', + [], + is_const=True) ## vector.h (module 'core'): ns3::Vector3D::x [variable] cls.add_instance_attribute('x', 'double', is_const=False) ## vector.h (module 'core'): ns3::Vector3D::y [variable] @@ -3182,79 +3396,79 @@ def register_Ns3Vector3D_methods(root_module, cls): def register_Ns3Empty_methods(root_module, cls): ## empty.h (module 'core'): ns3::empty::empty() [constructor] cls.add_constructor([]) - ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [copy constructor] + ## empty.h (module 'core'): ns3::empty::empty(ns3::empty const & arg0) [constructor] cls.add_constructor([param('ns3::empty const &', 'arg0')]) return def register_Ns3Int64x64_t_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) - cls.add_unary_numeric_operator('-') + cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right')) + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_output_stream_operator() + cls.add_binary_comparison_operator('==') cls.add_binary_comparison_operator('<') cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') - cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right')) + cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', u'right')) cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right')) - cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] - cls.add_constructor([]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(double v) [constructor] - cls.add_constructor([param('double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long double v) [constructor] - cls.add_constructor([param('long double', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int v) [constructor] - cls.add_constructor([param('int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long int v) [constructor] - cls.add_constructor([param('long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int v) [constructor] - cls.add_constructor([param('long long int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int v) [constructor] - cls.add_constructor([param('unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int v) [constructor] - cls.add_constructor([param('long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int v) [constructor] - cls.add_constructor([param('long long unsigned int', 'v')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t hi, uint64_t lo) [constructor] - cls.add_constructor([param('int64_t', 'hi'), param('uint64_t', 'lo')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [copy constructor] + cls.add_unary_numeric_operator('-') + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor] + cls.add_constructor([]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(double const value) [constructor] + cls.add_constructor([param('double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long double const value) [constructor] + cls.add_constructor([param('long double const', 'value')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int const v) [constructor] + cls.add_constructor([param('int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long int const v) [constructor] + cls.add_constructor([param('long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long int const v) [constructor] + cls.add_constructor([param('long long int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(unsigned int const v) [constructor] + cls.add_constructor([param('unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long unsigned int const v) [constructor] + cls.add_constructor([param('long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(long long unsigned int const v) [constructor] + cls.add_constructor([param('long long unsigned int const', 'v')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(int64_t const hi, uint64_t const lo) [constructor] + cls.add_constructor([param('int64_t const', 'hi'), param('uint64_t const', 'lo')]) + ## int64x64-128.h (module 'core'): ns3::int64x64_t::int64x64_t(ns3::int64x64_t const & o) [constructor] cls.add_constructor([param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] + ## int64x64-128.h (module 'core'): double ns3::int64x64_t::GetDouble() const [member function] cls.add_method('GetDouble', 'double', [], is_const=True) - ## int64x64-double.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] + ## int64x64-128.h (module 'core'): int64_t ns3::int64x64_t::GetHigh() const [member function] cls.add_method('GetHigh', 'int64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] + ## int64x64-128.h (module 'core'): uint64_t ns3::int64x64_t::GetLow() const [member function] cls.add_method('GetLow', 'uint64_t', [], is_const=True) - ## int64x64-double.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t v) [member function] + ## int64x64-128.h (module 'core'): static ns3::int64x64_t ns3::int64x64_t::Invert(uint64_t const v) [member function] cls.add_method('Invert', 'ns3::int64x64_t', - [param('uint64_t', 'v')], + [param('uint64_t const', 'v')], is_static=True) - ## int64x64-double.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] + ## int64x64-128.h (module 'core'): void ns3::int64x64_t::MulByInvert(ns3::int64x64_t const & o) [member function] cls.add_method('MulByInvert', 'void', [param('ns3::int64x64_t const &', 'o')]) - ## int64x64-double.h (module 'core'): ns3::int64x64_t::implementation [variable] + ## int64x64-128.h (module 'core'): ns3::int64x64_t::implementation [variable] cls.add_static_attribute('implementation', 'ns3::int64x64_t::impl_type const', is_const=True) return def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): - ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper(ns3::AcousticModemEnergyModelHelper const & arg0) [copy constructor] + ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper(ns3::AcousticModemEnergyModelHelper const & arg0) [constructor] cls.add_constructor([param('ns3::AcousticModemEnergyModelHelper const &', 'arg0')]) ## acoustic-modem-energy-model-helper.h (module 'uan'): ns3::AcousticModemEnergyModelHelper::AcousticModemEnergyModelHelper() [constructor] cls.add_constructor([]) @@ -3263,7 +3477,7 @@ def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): 'void', [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')], is_virtual=True) - ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::SetDepletionCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model-helper.h (module 'uan'): void ns3::AcousticModemEnergyModelHelper::SetDepletionCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyDepletionCallback callback) [member function] cls.add_method('SetDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -3277,7 +3491,7 @@ def register_Ns3AcousticModemEnergyModelHelper_methods(root_module, cls): def register_Ns3Chunk_methods(root_module, cls): ## chunk.h (module 'network'): ns3::Chunk::Chunk() [constructor] cls.add_constructor([]) - ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [copy constructor] + ## chunk.h (module 'network'): ns3::Chunk::Chunk(ns3::Chunk const & arg0) [constructor] cls.add_constructor([param('ns3::Chunk const &', 'arg0')]) ## chunk.h (module 'network'): uint32_t ns3::Chunk::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -3300,7 +3514,7 @@ def register_Ns3Header_methods(root_module, cls): cls.add_output_stream_operator() ## header.h (module 'network'): ns3::Header::Header() [constructor] cls.add_constructor([]) - ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [copy constructor] + ## header.h (module 'network'): ns3::Header::Header(ns3::Header const & arg0) [constructor] cls.add_constructor([param('ns3::Header const &', 'arg0')]) ## header.h (module 'network'): uint32_t ns3::Header::Deserialize(ns3::Buffer::Iterator start) [member function] cls.add_method('Deserialize', @@ -3364,7 +3578,7 @@ def register_Ns3Object_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor] + ## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [constructor] cls.add_constructor([param('ns3::Object const &', 'o')], visibility='protected') ## object.h (module 'core'): void ns3::Object::DoDispose() [member function] @@ -3385,7 +3599,7 @@ def register_Ns3Object_methods(root_module, cls): return def register_Ns3ObjectAggregateIterator_methods(root_module, cls): - ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor] + ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [constructor] cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')]) ## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor] cls.add_constructor([]) @@ -3394,7 +3608,7 @@ def register_Ns3ObjectAggregateIterator_methods(root_module, cls): 'bool', [], is_const=True) - ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] + ## object.h (module 'core'): ns3::Ptr ns3::Object::AggregateIterator::Next() [member function] cls.add_method('Next', 'ns3::Ptr< ns3::Object const >', []) @@ -3486,7 +3700,7 @@ def register_Ns3SequentialRandomVariable_methods(root_module, cls): def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter< ns3::AttributeAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3498,7 +3712,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter_ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter< ns3::AttributeChecker > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3510,7 +3724,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter< ns3::AttributeValue > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3522,7 +3736,7 @@ def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter< ns3::CallbackImplBase > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3534,7 +3748,7 @@ def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter< ns3::EventImpl > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3546,7 +3760,7 @@ def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter__lt__ns3HashImplementation__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Hash::Implementation, ns3::empty, ns3::DefaultDeleter< ns3::Hash::Implementation > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3558,7 +3772,7 @@ def register_Ns3SimpleRefCount__Ns3HashImplementation_Ns3Empty_Ns3DefaultDeleter def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter< ns3::NixVector > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3570,7 +3784,7 @@ def register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3 def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter< ns3::Packet > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3582,7 +3796,7 @@ def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Pac def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls): ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount() [constructor] cls.add_constructor([]) - ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [copy constructor] + ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount >::SimpleRefCount(ns3::SimpleRefCount > const & o) [constructor] cls.add_constructor([param('ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter< ns3::TraceSourceAccessor > > const &', 'o')]) ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount >::Cleanup() [member function] cls.add_method('Cleanup', @@ -3592,22 +3806,22 @@ def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDelete return def register_Ns3Time_methods(root_module, cls): - cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) + cls.add_binary_comparison_operator('==') + cls.add_binary_comparison_operator('!=') + cls.add_binary_comparison_operator('<=') + cls.add_binary_comparison_operator('>=') + cls.add_binary_comparison_operator('<') + cls.add_binary_comparison_operator('>') cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', u'right')) + cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) cls.add_binary_numeric_operator('/', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right')) - cls.add_binary_comparison_operator('<') - cls.add_binary_comparison_operator('>') - cls.add_binary_comparison_operator('!=') cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right')) cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right')) cls.add_output_stream_operator() - cls.add_binary_comparison_operator('<=') - cls.add_binary_comparison_operator('==') - cls.add_binary_comparison_operator('>=') ## nstime.h (module 'core'): ns3::Time::Time() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [copy constructor] + ## nstime.h (module 'core'): ns3::Time::Time(ns3::Time const & o) [constructor] cls.add_constructor([param('ns3::Time const &', 'o')]) ## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor] cls.add_constructor([param('double', 'v')]) @@ -3790,7 +4004,7 @@ def register_Ns3Time_methods(root_module, cls): return def register_Ns3TraceSourceAccessor_methods(root_module, cls): - ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor] + ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')]) ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor] cls.add_constructor([]) @@ -3820,7 +4034,7 @@ def register_Ns3Trailer_methods(root_module, cls): cls.add_output_stream_operator() ## trailer.h (module 'network'): ns3::Trailer::Trailer() [constructor] cls.add_constructor([]) - ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [copy constructor] + ## trailer.h (module 'network'): ns3::Trailer::Trailer(ns3::Trailer const & arg0) [constructor] cls.add_constructor([param('ns3::Trailer const &', 'arg0')]) ## trailer.h (module 'network'): uint32_t ns3::Trailer::Deserialize(ns3::Buffer::Iterator end) [member function] cls.add_method('Deserialize', @@ -3893,7 +4107,7 @@ def register_Ns3TriangularRandomVariable_methods(root_module, cls): return def register_Ns3UanHeaderCommon_methods(root_module, cls): - ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanHeaderCommon const & arg0) [copy constructor] + ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon(ns3::UanHeaderCommon const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderCommon const &', 'arg0')]) ## uan-header-common.h (module 'uan'): ns3::UanHeaderCommon::UanHeaderCommon() [constructor] cls.add_constructor([]) @@ -3959,7 +4173,7 @@ def register_Ns3UanHeaderCommon_methods(root_module, cls): return def register_Ns3UanHeaderRcAck_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck(ns3::UanHeaderRcAck const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck(ns3::UanHeaderRcAck const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcAck const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcAck::UanHeaderRcAck() [constructor] cls.add_constructor([]) @@ -4019,7 +4233,7 @@ def register_Ns3UanHeaderRcAck_methods(root_module, cls): return def register_Ns3UanHeaderRcCts_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(ns3::UanHeaderRcCts const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts(ns3::UanHeaderRcCts const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcCts const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCts::UanHeaderRcCts() [constructor] cls.add_constructor([]) @@ -4103,7 +4317,7 @@ def register_Ns3UanHeaderRcCts_methods(root_module, cls): return def register_Ns3UanHeaderRcCtsGlobal_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::UanHeaderRcCtsGlobal const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal(ns3::UanHeaderRcCtsGlobal const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcCtsGlobal const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcCtsGlobal::UanHeaderRcCtsGlobal() [constructor] cls.add_constructor([]) @@ -4178,7 +4392,7 @@ def register_Ns3UanHeaderRcCtsGlobal_methods(root_module, cls): return def register_Ns3UanHeaderRcData_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(ns3::UanHeaderRcData const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData(ns3::UanHeaderRcData const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcData const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcData::UanHeaderRcData() [constructor] cls.add_constructor([]) @@ -4235,7 +4449,7 @@ def register_Ns3UanHeaderRcData_methods(root_module, cls): return def register_Ns3UanHeaderRcRts_methods(root_module, cls): - ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(ns3::UanHeaderRcRts const & arg0) [copy constructor] + ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts(ns3::UanHeaderRcRts const & arg0) [constructor] cls.add_constructor([param('ns3::UanHeaderRcRts const &', 'arg0')]) ## uan-header-rc.h (module 'uan'): ns3::UanHeaderRcRts::UanHeaderRcRts() [constructor] cls.add_constructor([]) @@ -4321,7 +4535,7 @@ def register_Ns3UanHeaderRcRts_methods(root_module, cls): def register_Ns3UanMac_methods(root_module, cls): ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac() [constructor] cls.add_constructor([]) - ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac(ns3::UanMac const & arg0) [copy constructor] + ## uan-mac.h (module 'uan'): ns3::UanMac::UanMac(ns3::UanMac const & arg0) [constructor] cls.add_constructor([param('ns3::UanMac const &', 'arg0')]) ## uan-mac.h (module 'uan'): int64_t ns3::UanMac::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', @@ -4363,7 +4577,7 @@ def register_Ns3UanMac_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_pure_virtual=True, is_virtual=True) - ## uan-mac.h (module 'uan'): void ns3::UanMac::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac.h (module 'uan'): void ns3::UanMac::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4371,7 +4585,7 @@ def register_Ns3UanMac_methods(root_module, cls): return def register_Ns3UanMacAloha_methods(root_module, cls): - ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha(ns3::UanMacAloha const & arg0) [copy constructor] + ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha(ns3::UanMacAloha const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacAloha const &', 'arg0')]) ## uan-mac-aloha.h (module 'uan'): ns3::UanMacAloha::UanMacAloha() [constructor] cls.add_constructor([]) @@ -4415,7 +4629,7 @@ def register_Ns3UanMacAloha_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-aloha.h (module 'uan'): void ns3::UanMacAloha::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4428,7 +4642,7 @@ def register_Ns3UanMacAloha_methods(root_module, cls): return def register_Ns3UanMacCw_methods(root_module, cls): - ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw(ns3::UanMacCw const & arg0) [copy constructor] + ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw(ns3::UanMacCw const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacCw const &', 'arg0')]) ## uan-mac-cw.h (module 'uan'): ns3::UanMacCw::UanMacCw() [constructor] cls.add_constructor([]) @@ -4517,7 +4731,7 @@ def register_Ns3UanMacCw_methods(root_module, cls): 'void', [param('uint32_t', 'cw')], is_virtual=True) - ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-cw.h (module 'uan'): void ns3::UanMacCw::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4535,7 +4749,7 @@ def register_Ns3UanMacCw_methods(root_module, cls): return def register_Ns3UanMacRc_methods(root_module, cls): - ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc(ns3::UanMacRc const & arg0) [copy constructor] + ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc(ns3::UanMacRc const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacRc const &', 'arg0')]) ## uan-mac-rc.h (module 'uan'): ns3::UanMacRc::UanMacRc() [constructor] cls.add_constructor([]) @@ -4579,7 +4793,7 @@ def register_Ns3UanMacRc_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-rc.h (module 'uan'): void ns3::UanMacRc::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4592,7 +4806,7 @@ def register_Ns3UanMacRc_methods(root_module, cls): return def register_Ns3UanMacRcGw_methods(root_module, cls): - ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw(ns3::UanMacRcGw const & arg0) [copy constructor] + ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw(ns3::UanMacRcGw const & arg0) [constructor] cls.add_constructor([param('ns3::UanMacRcGw const &', 'arg0')]) ## uan-mac-rc-gw.h (module 'uan'): ns3::UanMacRcGw::UanMacRcGw() [constructor] cls.add_constructor([]) @@ -4636,7 +4850,7 @@ def register_Ns3UanMacRcGw_methods(root_module, cls): 'void', [param('ns3::UanAddress', 'addr')], is_virtual=True) - ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetForwardUpCb(ns3::Callback, ns3::UanAddress const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-mac-rc-gw.h (module 'uan'): void ns3::UanMacRcGw::SetForwardUpCb(ns3::Callback, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] cls.add_method('SetForwardUpCb', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -4651,7 +4865,7 @@ def register_Ns3UanMacRcGw_methods(root_module, cls): def register_Ns3UanNoiseModel_methods(root_module, cls): ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel() [constructor] cls.add_constructor([]) - ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel(ns3::UanNoiseModel const & arg0) [copy constructor] + ## uan-noise-model.h (module 'uan'): ns3::UanNoiseModel::UanNoiseModel(ns3::UanNoiseModel const & arg0) [constructor] cls.add_constructor([param('ns3::UanNoiseModel const &', 'arg0')]) ## uan-noise-model.h (module 'uan'): void ns3::UanNoiseModel::Clear() [member function] cls.add_method('Clear', @@ -4676,7 +4890,7 @@ def register_Ns3UanNoiseModel_methods(root_module, cls): return def register_Ns3UanNoiseModelDefault_methods(root_module, cls): - ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault(ns3::UanNoiseModelDefault const & arg0) [copy constructor] + ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault(ns3::UanNoiseModelDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanNoiseModelDefault const &', 'arg0')]) ## uan-noise-model-default.h (module 'uan'): ns3::UanNoiseModelDefault::UanNoiseModelDefault() [constructor] cls.add_constructor([]) @@ -4695,7 +4909,7 @@ def register_Ns3UanNoiseModelDefault_methods(root_module, cls): def register_Ns3UanPhy_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy(ns3::UanPhy const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhy::UanPhy(ns3::UanPhy const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhy const &', 'arg0')]) ## uan-phy.h (module 'uan'): int64_t ns3::UanPhy::AssignStreams(int64_t stream) [member function] cls.add_method('AssignStreams', @@ -4747,11 +4961,6 @@ def register_Ns3UanPhy_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_pure_virtual=True, is_virtual=True) ## uan-phy.h (module 'uan'): double ns3::UanPhy::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -4861,7 +5070,7 @@ def register_Ns3UanPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetEnergyModelCallback(ns3::Callback callback) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback callback) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], @@ -4871,21 +5080,16 @@ def register_Ns3UanPhy_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanMac >', 'mac')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_pure_virtual=True, is_virtual=True) ## uan-phy.h (module 'uan'): void ns3::UanPhy::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -4916,12 +5120,12 @@ def register_Ns3UanPhy_methods(root_module, cls): def register_Ns3UanPhyCalcSinr_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr(ns3::UanPhyCalcSinr const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyCalcSinr::UanPhyCalcSinr(ns3::UanPhyCalcSinr const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinr const &', 'arg0')]) - ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy.h (module 'uan'): double ns3::UanPhyCalcSinr::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_pure_virtual=True, is_const=True, is_virtual=True) ## uan-phy.h (module 'uan'): void ns3::UanPhyCalcSinr::Clear() [member function] cls.add_method('Clear', @@ -4951,14 +5155,14 @@ def register_Ns3UanPhyCalcSinr_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrDefault_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault(ns3::UanPhyCalcSinrDefault const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault(ns3::UanPhyCalcSinrDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrDefault const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrDefault::UanPhyCalcSinrDefault() [constructor] cls.add_constructor([]) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrDefault::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrDefault::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDefault::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4968,14 +5172,14 @@ def register_Ns3UanPhyCalcSinrDefault_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrDual_methods(root_module, cls): - ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual(ns3::UanPhyCalcSinrDual const & arg0) [copy constructor] + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual(ns3::UanPhyCalcSinrDual const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrDual const &', 'arg0')]) ## uan-phy-dual.h (module 'uan'): ns3::UanPhyCalcSinrDual::UanPhyCalcSinrDual() [constructor] cls.add_constructor([]) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyCalcSinrDual::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyCalcSinrDual::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-dual.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrDual::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -4985,14 +5189,14 @@ def register_Ns3UanPhyCalcSinrDual_methods(root_module, cls): return def register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk(ns3::UanPhyCalcSinrFhFsk const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk(ns3::UanPhyCalcSinrFhFsk const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyCalcSinrFhFsk const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyCalcSinrFhFsk::UanPhyCalcSinrFhFsk() [constructor] cls.add_constructor([]) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrFhFsk::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, std::list > const & arrivalList) const [member function] + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyCalcSinrFhFsk::CalcSinrDb(ns3::Ptr pkt, ns3::Time arrTime, double rxPowerDb, double ambNoiseDb, ns3::UanTxMode mode, ns3::UanPdp pdp, ns3::UanTransducer::ArrivalList const & arrivalList) const [member function] cls.add_method('CalcSinrDb', 'double', - [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('std::list< ns3::UanPacketArrival > const &', 'arrivalList')], + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('ns3::Time', 'arrTime'), param('double', 'rxPowerDb'), param('double', 'ambNoiseDb'), param('ns3::UanTxMode', 'mode'), param('ns3::UanPdp', 'pdp'), param('ns3::UanTransducer::ArrivalList const &', 'arrivalList')], is_const=True, is_virtual=True) ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyCalcSinrFhFsk::GetTypeId() [member function] cls.add_method('GetTypeId', @@ -5002,7 +5206,7 @@ def register_Ns3UanPhyCalcSinrFhFsk_methods(root_module, cls): return def register_Ns3UanPhyDual_methods(root_module, cls): - ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual(ns3::UanPhyDual const & arg0) [copy constructor] + ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual(ns3::UanPhyDual const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyDual const &', 'arg0')]) ## uan-phy-dual.h (module 'uan'): ns3::UanPhyDual::UanPhyDual() [constructor] cls.add_constructor([]) @@ -5096,21 +5300,6 @@ def register_Ns3UanPhyDual_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_const=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_virtual=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy1() const [member function] - cls.add_method('GetRxGainDbPhy1', - 'double', - [], - is_const=True) - ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxGainDbPhy2() const [member function] - cls.add_method('GetRxGainDbPhy2', - 'double', - [], - is_const=True) ## uan-phy-dual.h (module 'uan'): double ns3::UanPhyDual::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -5248,7 +5437,7 @@ def register_Ns3UanPhyDual_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetEnergyModelCallback(ns3::Callback callback) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback callback) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')], @@ -5274,29 +5463,16 @@ def register_Ns3UanPhyDual_methods(root_module, cls): cls.add_method('SetPerModelPhy2', 'void', [param('ns3::Ptr< ns3::UanPhyPer >', 'per')]) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_virtual=True) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy1(double gain) [member function] - cls.add_method('SetRxGainDbPhy1', - 'void', - [param('double', 'gain')]) - ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxGainDbPhy2(double gain) [member function] - cls.add_method('SetRxGainDbPhy2', - 'void', - [param('double', 'gain')]) ## uan-phy-dual.h (module 'uan'): void ns3::UanPhyDual::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -5346,7 +5522,7 @@ def register_Ns3UanPhyDual_methods(root_module, cls): return def register_Ns3UanPhyGen_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen(ns3::UanPhyGen const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen(ns3::UanPhyGen const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyGen const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyGen::UanPhyGen() [constructor] cls.add_constructor([]) @@ -5405,11 +5581,6 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'ns3::Ptr< ns3::Packet >', [], is_const=True, is_virtual=True) - ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxGainDb() [member function] - cls.add_method('GetRxGainDb', - 'double', - [], - is_virtual=True) ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyGen::GetRxThresholdDb() [member function] cls.add_method('GetRxThresholdDb', 'double', @@ -5495,7 +5666,7 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanNetDevice >', 'device')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetEnergyModelCallback(ns3::Callback cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetEnergyModelCallback(ns3::DeviceEnergyModel::ChangeStateCallback cb) [member function] cls.add_method('SetEnergyModelCallback', 'void', [param('ns3::Callback< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -5505,21 +5676,16 @@ def register_Ns3UanPhyGen_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanMac >', 'mac')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveErrorCallback(ns3::Callback, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveErrorCallback(ns3::UanPhy::RxErrCallback cb) [member function] cls.add_method('SetReceiveErrorCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveOkCallback(ns3::Callback, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetReceiveOkCallback(ns3::UanPhy::RxOkCallback cb) [member function] cls.add_method('SetReceiveOkCallback', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxGainDb(double gain) [member function] - cls.add_method('SetRxGainDb', - 'void', - [param('double', 'gain')], - is_virtual=True) ## uan-phy-gen.h (module 'uan'): void ns3::UanPhyGen::SetRxThresholdDb(double thresh) [member function] cls.add_method('SetRxThresholdDb', 'void', @@ -5555,7 +5721,7 @@ def register_Ns3UanPhyGen_methods(root_module, cls): def register_Ns3UanPhyPer_methods(root_module, cls): ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer() [constructor] cls.add_constructor([]) - ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer(ns3::UanPhyPer const & arg0) [copy constructor] + ## uan-phy.h (module 'uan'): ns3::UanPhyPer::UanPhyPer(ns3::UanPhyPer const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPer const &', 'arg0')]) ## uan-phy.h (module 'uan'): double ns3::UanPhyPer::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] cls.add_method('CalcPer', @@ -5579,8 +5745,25 @@ def register_Ns3UanPhyPer_methods(root_module, cls): visibility='protected', is_virtual=True) return +def register_Ns3UanPhyPerCommonModes_methods(root_module, cls): + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes::UanPhyPerCommonModes(ns3::UanPhyPerCommonModes const & arg0) [constructor] + cls.add_constructor([param('ns3::UanPhyPerCommonModes const &', 'arg0')]) + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerCommonModes::UanPhyPerCommonModes() [constructor] + cls.add_constructor([]) + ## uan-phy-gen.h (module 'uan'): double ns3::UanPhyPerCommonModes::CalcPer(ns3::Ptr pkt, double sinrDb, ns3::UanTxMode mode) [member function] + cls.add_method('CalcPer', + 'double', + [param('ns3::Ptr< ns3::Packet >', 'pkt'), param('double', 'sinrDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) + ## uan-phy-gen.h (module 'uan'): static ns3::TypeId ns3::UanPhyPerCommonModes::GetTypeId() [member function] + cls.add_method('GetTypeId', + 'ns3::TypeId', + [], + is_static=True) + return + def register_Ns3UanPhyPerGenDefault_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault(ns3::UanPhyPerGenDefault const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault(ns3::UanPhyPerGenDefault const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPerGenDefault const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerGenDefault::UanPhyPerGenDefault() [constructor] cls.add_constructor([]) @@ -5597,7 +5780,7 @@ def register_Ns3UanPhyPerGenDefault_methods(root_module, cls): return def register_Ns3UanPhyPerUmodem_methods(root_module, cls): - ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem(ns3::UanPhyPerUmodem const & arg0) [copy constructor] + ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem(ns3::UanPhyPerUmodem const & arg0) [constructor] cls.add_constructor([param('ns3::UanPhyPerUmodem const &', 'arg0')]) ## uan-phy-gen.h (module 'uan'): ns3::UanPhyPerUmodem::UanPhyPerUmodem() [constructor] cls.add_constructor([]) @@ -5616,7 +5799,7 @@ def register_Ns3UanPhyPerUmodem_methods(root_module, cls): def register_Ns3UanPropModel_methods(root_module, cls): ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel() [constructor] cls.add_constructor([]) - ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel(ns3::UanPropModel const & arg0) [copy constructor] + ## uan-prop-model.h (module 'uan'): ns3::UanPropModel::UanPropModel(ns3::UanPropModel const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModel const &', 'arg0')]) ## uan-prop-model.h (module 'uan'): void ns3::UanPropModel::Clear() [member function] cls.add_method('Clear', @@ -5651,7 +5834,7 @@ def register_Ns3UanPropModel_methods(root_module, cls): return def register_Ns3UanPropModelIdeal_methods(root_module, cls): - ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal(ns3::UanPropModelIdeal const & arg0) [copy constructor] + ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal(ns3::UanPropModelIdeal const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModelIdeal const &', 'arg0')]) ## uan-prop-model-ideal.h (module 'uan'): ns3::UanPropModelIdeal::UanPropModelIdeal() [constructor] cls.add_constructor([]) @@ -5678,7 +5861,7 @@ def register_Ns3UanPropModelIdeal_methods(root_module, cls): return def register_Ns3UanPropModelThorp_methods(root_module, cls): - ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp(ns3::UanPropModelThorp const & arg0) [copy constructor] + ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp(ns3::UanPropModelThorp const & arg0) [constructor] cls.add_constructor([param('ns3::UanPropModelThorp const &', 'arg0')]) ## uan-prop-model-thorp.h (module 'uan'): ns3::UanPropModelThorp::UanPropModelThorp() [constructor] cls.add_constructor([]) @@ -5707,21 +5890,26 @@ def register_Ns3UanPropModelThorp_methods(root_module, cls): def register_Ns3UanTransducer_methods(root_module, cls): ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer() [constructor] cls.add_constructor([]) - ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer(ns3::UanTransducer const & arg0) [copy constructor] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanTransducer(ns3::UanTransducer const & arg0) [constructor] cls.add_constructor([param('ns3::UanTransducer const &', 'arg0')]) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::AddPhy(ns3::Ptr phy) [member function] cls.add_method('AddPhy', 'void', [param('ns3::Ptr< ns3::UanPhy >', 'phy')], is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): double ns3::UanTransducer::ApplyRxGainDb(double rxPowerDb, ns3::UanTxMode mode) [member function] + cls.add_method('ApplyRxGainDb', + 'double', + [param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'mode')], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Clear() [member function] cls.add_method('Clear', 'void', [], is_pure_virtual=True, is_virtual=True) - ## uan-transducer.h (module 'uan'): std::list > const & ns3::UanTransducer::GetArrivalList() const [member function] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::ArrivalList const & ns3::UanTransducer::GetArrivalList() const [member function] cls.add_method('GetArrivalList', - 'std::list< ns3::UanPacketArrival > const &', + 'ns3::UanTransducer::ArrivalList const &', [], is_pure_virtual=True, is_const=True, is_virtual=True) ## uan-transducer.h (module 'uan'): ns3::Ptr ns3::UanTransducer::GetChannel() const [member function] @@ -5729,11 +5917,16 @@ def register_Ns3UanTransducer_methods(root_module, cls): 'ns3::Ptr< ns3::UanChannel >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## uan-transducer.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducer::GetPhyList() const [member function] + ## uan-transducer.h (module 'uan'): ns3::UanTransducer::UanPhyList const & ns3::UanTransducer::GetPhyList() const [member function] cls.add_method('GetPhyList', - 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + 'ns3::UanTransducer::UanPhyList const &', [], is_pure_virtual=True, is_const=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): double ns3::UanTransducer::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducer::GetState() const [member function] cls.add_method('GetState', 'ns3::UanTransducer::State', @@ -5764,6 +5957,11 @@ def register_Ns3UanTransducer_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanChannel >', 'chan')], is_pure_virtual=True, is_virtual=True) + ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::SetRxGainDb(double gainDb) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gainDb')], + is_pure_virtual=True, is_virtual=True) ## uan-transducer.h (module 'uan'): void ns3::UanTransducer::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] cls.add_method('Transmit', 'void', @@ -5772,7 +5970,7 @@ def register_Ns3UanTransducer_methods(root_module, cls): return def register_Ns3UanTransducerHd_methods(root_module, cls): - ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd(ns3::UanTransducerHd const & arg0) [copy constructor] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd(ns3::UanTransducerHd const & arg0) [constructor] cls.add_constructor([param('ns3::UanTransducerHd const &', 'arg0')]) ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducerHd::UanTransducerHd() [constructor] cls.add_constructor([]) @@ -5781,14 +5979,19 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanPhy >', 'arg0')], is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): double ns3::UanTransducerHd::ApplyRxGainDb(double rxPowerDb, ns3::UanTxMode mode) [member function] + cls.add_method('ApplyRxGainDb', + 'double', + [param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'mode')], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Clear() [member function] cls.add_method('Clear', 'void', [], is_virtual=True) - ## uan-transducer-hd.h (module 'uan'): std::list > const & ns3::UanTransducerHd::GetArrivalList() const [member function] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::ArrivalList const & ns3::UanTransducerHd::GetArrivalList() const [member function] cls.add_method('GetArrivalList', - 'std::list< ns3::UanPacketArrival > const &', + 'ns3::UanTransducer::ArrivalList const &', [], is_const=True, is_virtual=True) ## uan-transducer-hd.h (module 'uan'): ns3::Ptr ns3::UanTransducerHd::GetChannel() const [member function] @@ -5796,11 +5999,16 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'ns3::Ptr< ns3::UanChannel >', [], is_const=True, is_virtual=True) - ## uan-transducer-hd.h (module 'uan'): std::list, std::allocator > > const & ns3::UanTransducerHd::GetPhyList() const [member function] + ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::UanPhyList const & ns3::UanTransducerHd::GetPhyList() const [member function] cls.add_method('GetPhyList', - 'std::list< ns3::Ptr< ns3::UanPhy > > const &', + 'ns3::UanTransducer::UanPhyList const &', [], is_const=True, is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): double ns3::UanTransducerHd::GetRxGainDb() [member function] + cls.add_method('GetRxGainDb', + 'double', + [], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): ns3::UanTransducer::State ns3::UanTransducerHd::GetState() const [member function] cls.add_method('GetState', 'ns3::UanTransducer::State', @@ -5831,6 +6039,11 @@ def register_Ns3UanTransducerHd_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::UanChannel >', 'chan')], is_virtual=True) + ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::SetRxGainDb(double gainDb) [member function] + cls.add_method('SetRxGainDb', + 'void', + [param('double', 'gainDb')], + is_virtual=True) ## uan-transducer-hd.h (module 'uan'): void ns3::UanTransducerHd::Transmit(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txMode) [member function] cls.add_method('Transmit', 'void', @@ -5996,7 +6209,7 @@ def register_Ns3ZipfRandomVariable_methods(root_module, cls): return def register_Ns3AttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor] cls.add_constructor([]) @@ -6023,7 +6236,7 @@ def register_Ns3AttributeAccessor_methods(root_module, cls): return def register_Ns3AttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor] cls.add_constructor([]) @@ -6065,7 +6278,7 @@ def register_Ns3AttributeChecker_methods(root_module, cls): return def register_Ns3AttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor] cls.add_constructor([]) @@ -6074,12 +6287,12 @@ def register_Ns3AttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::AttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_pure_virtual=True, is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::AttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6089,13 +6302,13 @@ def register_Ns3AttributeValue_methods(root_module, cls): def register_Ns3BooleanChecker_methods(root_module, cls): ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker() [constructor] cls.add_constructor([]) - ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanChecker::BooleanChecker(ns3::BooleanChecker const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanChecker const &', 'arg0')]) return def register_Ns3BooleanValue_methods(root_module, cls): cls.add_output_stream_operator() - ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [copy constructor] + ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue(ns3::BooleanValue const & arg0) [constructor] cls.add_constructor([param('ns3::BooleanValue const &', 'arg0')]) ## boolean.h (module 'core'): ns3::BooleanValue::BooleanValue() [constructor] cls.add_constructor([]) @@ -6106,7 +6319,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## boolean.h (module 'core'): bool ns3::BooleanValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6116,7 +6329,7 @@ def register_Ns3BooleanValue_methods(root_module, cls): 'bool', [], is_const=True) - ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] + ## boolean.h (module 'core'): std::string ns3::BooleanValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6130,21 +6343,21 @@ def register_Ns3BooleanValue_methods(root_module, cls): def register_Ns3CallbackChecker_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackChecker::CallbackChecker(ns3::CallbackChecker const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackChecker const &', 'arg0')]) return def register_Ns3CallbackImplBase_methods(root_module, cls): ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase() [constructor] cls.add_constructor([]) - ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackImplBase::CallbackImplBase(ns3::CallbackImplBase const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')]) ## callback.h (module 'core'): std::string ns3::CallbackImplBase::GetTypeid() const [member function] cls.add_method('GetTypeid', 'std::string', [], is_pure_virtual=True, is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] + ## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr other) const [member function] cls.add_method('IsEqual', 'bool', [param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')], @@ -6154,10 +6367,95 @@ def register_Ns3CallbackImplBase_methods(root_module, cls): 'std::string', [param('std::string const &', 'mangled')], is_static=True, visibility='protected') + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::ObjectBase*']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'void']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'double']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned short']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Address const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::NetDevice::PacketType']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanAddress']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'bool']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Ptr ']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanAddress const&']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::UanTxMode']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'ns3::Time']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'unsigned int']) + ## callback.h (module 'core'): static std::string ns3::CallbackImplBase::GetCppTypeid() [member function] + cls.add_method('GetCppTypeid', + 'std::string', + [], + is_static=True, visibility='protected', template_parameters=[u'int']) return def register_Ns3CallbackValue_methods(root_module, cls): - ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor] + ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [constructor] cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')]) ## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor] cls.add_constructor([]) @@ -6168,12 +6466,12 @@ def register_Ns3CallbackValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True) - ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] + ## callback.h (module 'core'): std::string ns3::CallbackValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6185,7 +6483,7 @@ def register_Ns3CallbackValue_methods(root_module, cls): return def register_Ns3Channel_methods(root_module, cls): - ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy constructor] + ## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [constructor] cls.add_constructor([param('ns3::Channel const &', 'arg0')]) ## channel.h (module 'network'): ns3::Channel::Channel() [constructor] cls.add_constructor([]) @@ -6269,7 +6567,7 @@ def register_Ns3DeterministicRandomVariable_methods(root_module, cls): return def register_Ns3DeviceEnergyModel_methods(root_module, cls): - ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [copy constructor] + ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel(ns3::DeviceEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::DeviceEnergyModel const &', 'arg0')]) ## device-energy-model.h (module 'energy'): ns3::DeviceEnergyModel::DeviceEnergyModel() [constructor] cls.add_constructor([]) @@ -6318,16 +6616,16 @@ def register_Ns3DeviceEnergyModel_methods(root_module, cls): def register_Ns3DoubleValue_methods(root_module, cls): ## double.h (module 'core'): ns3::DoubleValue::DoubleValue() [constructor] cls.add_constructor([]) - ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(double const & value) [constructor] cls.add_constructor([param('double const &', 'value')]) + ## double.h (module 'core'): ns3::DoubleValue::DoubleValue(ns3::DoubleValue const & arg0) [constructor] + cls.add_constructor([param('ns3::DoubleValue const &', 'arg0')]) ## double.h (module 'core'): ns3::Ptr ns3::DoubleValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## double.h (module 'core'): bool ns3::DoubleValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6337,7 +6635,7 @@ def register_Ns3DoubleValue_methods(root_module, cls): 'double', [], is_const=True) - ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] + ## double.h (module 'core'): std::string ns3::DoubleValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6383,7 +6681,7 @@ def register_Ns3EmpiricalRandomVariable_methods(root_module, cls): return def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor(ns3::EmptyAttributeAccessor const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeAccessor const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeAccessor::EmptyAttributeAccessor() [constructor] cls.add_constructor([]) @@ -6410,7 +6708,7 @@ def register_Ns3EmptyAttributeAccessor_methods(root_module, cls): return def register_Ns3EmptyAttributeChecker_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker(ns3::EmptyAttributeChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeChecker const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeChecker::EmptyAttributeChecker() [constructor] cls.add_constructor([]) @@ -6447,7 +6745,7 @@ def register_Ns3EmptyAttributeChecker_methods(root_module, cls): return def register_Ns3EmptyAttributeValue_methods(root_module, cls): - ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor] + ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [constructor] cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')]) ## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor] cls.add_constructor([]) @@ -6456,12 +6754,12 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, visibility='private', is_virtual=True) - ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## attribute.h (module 'core'): bool ns3::EmptyAttributeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], visibility='private', is_virtual=True) - ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## attribute.h (module 'core'): std::string ns3::EmptyAttributeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6469,7 +6767,7 @@ def register_Ns3EmptyAttributeValue_methods(root_module, cls): return def register_Ns3EnergyHarvester_methods(root_module, cls): - ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [copy constructor] + ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester(ns3::EnergyHarvester const & arg0) [constructor] cls.add_constructor([param('ns3::EnergyHarvester const &', 'arg0')]) ## energy-harvester.h (module 'energy'): ns3::EnergyHarvester::EnergyHarvester() [constructor] cls.add_constructor([]) @@ -6514,7 +6812,7 @@ def register_Ns3EnergyHarvester_methods(root_module, cls): return def register_Ns3EnergySource_methods(root_module, cls): - ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [copy constructor] + ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource(ns3::EnergySource const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySource const &', 'arg0')]) ## energy-source.h (module 'energy'): ns3::EnergySource::EnergySource() [constructor] cls.add_constructor([]) @@ -6609,7 +6907,7 @@ def register_Ns3EnergySource_methods(root_module, cls): return def register_Ns3EnergySourceContainer_methods(root_module, cls): - ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [copy constructor] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer(ns3::EnergySourceContainer const & arg0) [constructor] cls.add_constructor([param('ns3::EnergySourceContainer const &', 'arg0')]) ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::EnergySourceContainer() [constructor] cls.add_constructor([]) @@ -6631,14 +6929,14 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): cls.add_method('Add', 'void', [param('std::string', 'sourceName')]) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::Begin() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::Begin() const [member function] cls.add_method('Begin', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) - ## energy-source-container.h (module 'energy'): __gnu_cxx::__normal_iterator*,std::vector, std::allocator > > > ns3::EnergySourceContainer::End() const [member function] + ## energy-source-container.h (module 'energy'): ns3::EnergySourceContainer::Iterator ns3::EnergySourceContainer::End() const [member function] cls.add_method('End', - '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::EnergySource > const, std::vector< ns3::Ptr< ns3::EnergySource > > >', + 'ns3::EnergySourceContainer::Iterator', [], is_const=True) ## energy-source-container.h (module 'energy'): ns3::Ptr ns3::EnergySourceContainer::Get(uint32_t i) const [member function] @@ -6669,7 +6967,7 @@ def register_Ns3EnergySourceContainer_methods(root_module, cls): return def register_Ns3EnumChecker_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker(ns3::EnumChecker const & arg0) [constructor] cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor] cls.add_constructor([]) @@ -6714,7 +7012,7 @@ def register_Ns3EnumChecker_methods(root_module, cls): return def register_Ns3EnumValue_methods(root_module, cls): - ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [copy constructor] + ## enum.h (module 'core'): ns3::EnumValue::EnumValue(ns3::EnumValue const & arg0) [constructor] cls.add_constructor([param('ns3::EnumValue const &', 'arg0')]) ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor] cls.add_constructor([]) @@ -6725,7 +7023,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## enum.h (module 'core'): bool ns3::EnumValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6735,7 +7033,7 @@ def register_Ns3EnumValue_methods(root_module, cls): 'int', [], is_const=True) - ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] + ## enum.h (module 'core'): std::string ns3::EnumValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6785,7 +7083,7 @@ def register_Ns3ErlangRandomVariable_methods(root_module, cls): return def register_Ns3EventImpl_methods(root_module, cls): - ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor] + ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [constructor] cls.add_constructor([param('ns3::EventImpl const &', 'arg0')]) ## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor] cls.add_constructor([]) @@ -6887,16 +7185,16 @@ def register_Ns3GammaRandomVariable_methods(root_module, cls): def register_Ns3IntegerValue_methods(root_module, cls): ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue() [constructor] cls.add_constructor([]) - ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(int64_t const & value) [constructor] cls.add_constructor([param('int64_t const &', 'value')]) + ## integer.h (module 'core'): ns3::IntegerValue::IntegerValue(ns3::IntegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::IntegerValue const &', 'arg0')]) ## integer.h (module 'core'): ns3::Ptr ns3::IntegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## integer.h (module 'core'): bool ns3::IntegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6906,7 +7204,7 @@ def register_Ns3IntegerValue_methods(root_module, cls): 'int64_t', [], is_const=True) - ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## integer.h (module 'core'): std::string ns3::IntegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6920,23 +7218,23 @@ def register_Ns3IntegerValue_methods(root_module, cls): def register_Ns3Ipv4AddressChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker::Ipv4AddressChecker(ns3::Ipv4AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4AddressChecker const &', 'arg0')]) return def register_Ns3Ipv4AddressValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Address const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue::Ipv4AddressValue(ns3::Ipv4AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4AddressValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6946,7 +7244,7 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): 'ns3::Ipv4Address', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6960,23 +7258,23 @@ def register_Ns3Ipv4AddressValue_methods(root_module, cls): def register_Ns3Ipv4MaskChecker_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [copy constructor] + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker::Ipv4MaskChecker(ns3::Ipv4MaskChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv4MaskChecker const &', 'arg0')]) return def register_Ns3Ipv4MaskValue_methods(root_module, cls): ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue() [constructor] cls.add_constructor([]) - ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4Mask const & value) [constructor] cls.add_constructor([param('ns3::Ipv4Mask const &', 'value')]) + ## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue::Ipv4MaskValue(ns3::Ipv4MaskValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv4MaskValue const &', 'arg0')]) ## ipv4-address.h (module 'network'): ns3::Ptr ns3::Ipv4MaskValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv4-address.h (module 'network'): bool ns3::Ipv4MaskValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -6986,7 +7284,7 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): 'ns3::Ipv4Mask', [], is_const=True) - ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7000,23 +7298,23 @@ def register_Ns3Ipv4MaskValue_methods(root_module, cls): def register_Ns3Ipv6AddressChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker::Ipv6AddressChecker(ns3::Ipv6AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6AddressChecker const &', 'arg0')]) return def register_Ns3Ipv6AddressValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6Address const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Address const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue::Ipv6AddressValue(ns3::Ipv6AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6AddressValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7026,7 +7324,7 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): 'ns3::Ipv6Address', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7040,23 +7338,23 @@ def register_Ns3Ipv6AddressValue_methods(root_module, cls): def register_Ns3Ipv6PrefixChecker_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [copy constructor] + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker::Ipv6PrefixChecker(ns3::Ipv6PrefixChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Ipv6PrefixChecker const &', 'arg0')]) return def register_Ns3Ipv6PrefixValue_methods(root_module, cls): ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue() [constructor] cls.add_constructor([]) - ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6Prefix const & value) [constructor] cls.add_constructor([param('ns3::Ipv6Prefix const &', 'value')]) + ## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue::Ipv6PrefixValue(ns3::Ipv6PrefixValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Ipv6PrefixValue const &', 'arg0')]) ## ipv6-address.h (module 'network'): ns3::Ptr ns3::Ipv6PrefixValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## ipv6-address.h (module 'network'): bool ns3::Ipv6PrefixValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7066,7 +7364,7 @@ def register_Ns3Ipv6PrefixValue_methods(root_module, cls): 'ns3::Ipv6Prefix', [], is_const=True) - ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] + ## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7118,23 +7416,23 @@ def register_Ns3LogNormalRandomVariable_methods(root_module, cls): def register_Ns3Mac48AddressChecker_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [copy constructor] + ## mac48-address.h (module 'network'): ns3::Mac48AddressChecker::Mac48AddressChecker(ns3::Mac48AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Mac48AddressChecker const &', 'arg0')]) return def register_Ns3Mac48AddressValue_methods(root_module, cls): ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue() [constructor] cls.add_constructor([]) - ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48Address const & value) [constructor] cls.add_constructor([param('ns3::Mac48Address const &', 'value')]) + ## mac48-address.h (module 'network'): ns3::Mac48AddressValue::Mac48AddressValue(ns3::Mac48AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Mac48AddressValue const &', 'arg0')]) ## mac48-address.h (module 'network'): ns3::Ptr ns3::Mac48AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## mac48-address.h (module 'network'): bool ns3::Mac48AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7144,7 +7442,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): 'ns3::Mac48Address', [], is_const=True) - ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7156,7 +7454,7 @@ def register_Ns3Mac48AddressValue_methods(root_module, cls): return def register_Ns3MobilityModel_methods(root_module, cls): - ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [copy constructor] + ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel(ns3::MobilityModel const & arg0) [constructor] cls.add_constructor([param('ns3::MobilityModel const &', 'arg0')]) ## mobility-model.h (module 'mobility'): ns3::MobilityModel::MobilityModel() [constructor] cls.add_constructor([]) @@ -7223,7 +7521,7 @@ def register_Ns3MobilityModel_methods(root_module, cls): def register_Ns3NetDevice_methods(root_module, cls): ## net-device.h (module 'network'): ns3::NetDevice::NetDevice() [constructor] cls.add_constructor([]) - ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [copy constructor] + ## net-device.h (module 'network'): ns3::NetDevice::NetDevice(ns3::NetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::NetDevice const &', 'arg0')]) ## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback callback) [member function] cls.add_method('AddLinkChangeCallback', @@ -7335,12 +7633,12 @@ def register_Ns3NetDevice_methods(root_module, cls): 'void', [param('ns3::Ptr< ns3::Node >', 'node')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::Callback,ns3::Ptr,short unsigned int,const ns3::Address&,const ns3::Address&,ns3::NetDevice::PacketType,ns3::empty,ns3::empty,ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', - [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_pure_virtual=True, is_virtual=True) - ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## net-device.h (module 'network'): void ns3::NetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -7356,7 +7654,7 @@ def register_Ns3NixVector_methods(root_module, cls): cls.add_output_stream_operator() ## nix-vector.h (module 'network'): ns3::NixVector::NixVector() [constructor] cls.add_constructor([]) - ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [copy constructor] + ## nix-vector.h (module 'network'): ns3::NixVector::NixVector(ns3::NixVector const & o) [constructor] cls.add_constructor([param('ns3::NixVector const &', 'o')]) ## nix-vector.h (module 'network'): void ns3::NixVector::AddNeighborIndex(uint32_t newBits, uint32_t numberOfBits) [member function] cls.add_method('AddNeighborIndex', @@ -7397,7 +7695,7 @@ def register_Ns3NixVector_methods(root_module, cls): return def register_Ns3Node_methods(root_module, cls): - ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor] + ## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [constructor] cls.add_constructor([param('ns3::Node const &', 'arg0')]) ## node.h (module 'network'): ns3::Node::Node() [constructor] cls.add_constructor([]) @@ -7456,19 +7754,19 @@ def register_Ns3Node_methods(root_module, cls): 'ns3::TypeId', [], is_static=True) - ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('RegisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] + ## node.h (module 'network'): void ns3::Node::RegisterProtocolHandler(ns3::Node::ProtocolHandler handler, uint16_t protocolType, ns3::Ptr device, bool promiscuous=false) [member function] cls.add_method('RegisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler'), param('uint16_t', 'protocolType'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'promiscuous', default_value='false')]) - ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Callback,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> listener) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterDeviceAdditionListener(ns3::Node::DeviceAdditionListener listener) [member function] cls.add_method('UnregisterDeviceAdditionListener', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'listener')]) - ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::Address const&, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> handler) [member function] + ## node.h (module 'network'): void ns3::Node::UnregisterProtocolHandler(ns3::Node::ProtocolHandler handler) [member function] cls.add_method('UnregisterProtocolHandler', 'void', [param('ns3::Callback< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'handler')]) @@ -7532,23 +7830,23 @@ def register_Ns3NormalRandomVariable_methods(root_module, cls): def register_Ns3ObjectFactoryChecker_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [copy constructor] + ## object-factory.h (module 'core'): ns3::ObjectFactoryChecker::ObjectFactoryChecker(ns3::ObjectFactoryChecker const & arg0) [constructor] cls.add_constructor([param('ns3::ObjectFactoryChecker const &', 'arg0')]) return def register_Ns3ObjectFactoryValue_methods(root_module, cls): ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue() [constructor] cls.add_constructor([]) - ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactory const & value) [constructor] cls.add_constructor([param('ns3::ObjectFactory const &', 'value')]) + ## object-factory.h (module 'core'): ns3::ObjectFactoryValue::ObjectFactoryValue(ns3::ObjectFactoryValue const & arg0) [constructor] + cls.add_constructor([param('ns3::ObjectFactoryValue const &', 'arg0')]) ## object-factory.h (module 'core'): ns3::Ptr ns3::ObjectFactoryValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## object-factory.h (module 'core'): bool ns3::ObjectFactoryValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7558,7 +7856,7 @@ def register_Ns3ObjectFactoryValue_methods(root_module, cls): 'ns3::ObjectFactory', [], is_const=True) - ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] + ## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7573,7 +7871,7 @@ def register_Ns3Packet_methods(root_module, cls): cls.add_output_stream_operator() ## packet.h (module 'network'): ns3::Packet::Packet() [constructor] cls.add_constructor([]) - ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [copy constructor] + ## packet.h (module 'network'): ns3::Packet::Packet(ns3::Packet const & o) [constructor] cls.add_constructor([param('ns3::Packet const &', 'o')]) ## packet.h (module 'network'): ns3::Packet::Packet(uint32_t size) [constructor] cls.add_constructor([param('uint32_t', 'size')]) @@ -7766,7 +8064,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): cls.add_method('GetMean', 'double', [], - deprecated=True, is_const=True) + is_const=True) ## random-variable-stream.h (module 'core'): double ns3::ParetoRandomVariable::GetScale() const [member function] cls.add_method('GetScale', 'double', @@ -7805,7 +8103,7 @@ def register_Ns3ParetoRandomVariable_methods(root_module, cls): def register_Ns3PointerChecker_methods(root_module, cls): ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker() [constructor] cls.add_constructor([]) - ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerChecker::PointerChecker(ns3::PointerChecker const & arg0) [constructor] cls.add_constructor([param('ns3::PointerChecker const &', 'arg0')]) ## pointer.h (module 'core'): ns3::TypeId ns3::PointerChecker::GetPointeeTypeId() const [member function] cls.add_method('GetPointeeTypeId', @@ -7815,7 +8113,7 @@ def register_Ns3PointerChecker_methods(root_module, cls): return def register_Ns3PointerValue_methods(root_module, cls): - ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [copy constructor] + ## pointer.h (module 'core'): ns3::PointerValue::PointerValue(ns3::PointerValue const & arg0) [constructor] cls.add_constructor([param('ns3::PointerValue const &', 'arg0')]) ## pointer.h (module 'core'): ns3::PointerValue::PointerValue() [constructor] cls.add_constructor([]) @@ -7826,7 +8124,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## pointer.h (module 'core'): bool ns3::PointerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7836,7 +8134,7 @@ def register_Ns3PointerValue_methods(root_module, cls): 'ns3::Ptr< ns3::Object >', [], is_const=True) - ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## pointer.h (module 'core'): std::string ns3::PointerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7850,16 +8148,16 @@ def register_Ns3PointerValue_methods(root_module, cls): def register_Ns3TimeValue_methods(root_module, cls): ## nstime.h (module 'core'): ns3::TimeValue::TimeValue() [constructor] cls.add_constructor([]) - ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::Time const & value) [constructor] cls.add_constructor([param('ns3::Time const &', 'value')]) + ## nstime.h (module 'core'): ns3::TimeValue::TimeValue(ns3::TimeValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TimeValue const &', 'arg0')]) ## nstime.h (module 'core'): ns3::Ptr ns3::TimeValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## nstime.h (module 'core'): bool ns3::TimeValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7869,7 +8167,7 @@ def register_Ns3TimeValue_methods(root_module, cls): 'ns3::Time', [], is_const=True) - ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] + ## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7883,23 +8181,23 @@ def register_Ns3TimeValue_methods(root_module, cls): def register_Ns3TypeIdChecker_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [copy constructor] + ## type-id.h (module 'core'): ns3::TypeIdChecker::TypeIdChecker(ns3::TypeIdChecker const & arg0) [constructor] cls.add_constructor([param('ns3::TypeIdChecker const &', 'arg0')]) return def register_Ns3TypeIdValue_methods(root_module, cls): ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue() [constructor] cls.add_constructor([]) - ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeId const & value) [constructor] cls.add_constructor([param('ns3::TypeId const &', 'value')]) + ## type-id.h (module 'core'): ns3::TypeIdValue::TypeIdValue(ns3::TypeIdValue const & arg0) [constructor] + cls.add_constructor([param('ns3::TypeIdValue const &', 'arg0')]) ## type-id.h (module 'core'): ns3::Ptr ns3::TypeIdValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## type-id.h (module 'core'): bool ns3::TypeIdValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7909,7 +8207,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): 'ns3::TypeId', [], is_const=True) - ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] + ## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -7921,7 +8219,7 @@ def register_Ns3TypeIdValue_methods(root_module, cls): return def register_Ns3UanChannel_methods(root_module, cls): - ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel(ns3::UanChannel const & arg0) [copy constructor] + ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel(ns3::UanChannel const & arg0) [constructor] cls.add_constructor([param('ns3::UanChannel const &', 'arg0')]) ## uan-channel.h (module 'uan'): ns3::UanChannel::UanChannel() [constructor] cls.add_constructor([]) @@ -7963,34 +8261,40 @@ def register_Ns3UanChannel_methods(root_module, cls): ## uan-channel.h (module 'uan'): void ns3::UanChannel::TxPacket(ns3::Ptr src, ns3::Ptr packet, double txPowerDb, ns3::UanTxMode txmode) [member function] cls.add_method('TxPacket', 'void', - [param('ns3::Ptr< ns3::UanTransducer >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txmode')]) + [param('ns3::Ptr< ns3::UanTransducer >', 'src'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'txPowerDb'), param('ns3::UanTxMode', 'txmode')], + is_virtual=True) ## uan-channel.h (module 'uan'): void ns3::UanChannel::DoDispose() [member function] cls.add_method('DoDispose', 'void', [], visibility='protected', is_virtual=True) + ## uan-channel.h (module 'uan'): void ns3::UanChannel::SendUp(uint32_t i, ns3::Ptr packet, double rxPowerDb, ns3::UanTxMode txMode, ns3::UanPdp pdp) [member function] + cls.add_method('SendUp', + 'void', + [param('uint32_t', 'i'), param('ns3::Ptr< ns3::Packet >', 'packet'), param('double', 'rxPowerDb'), param('ns3::UanTxMode', 'txMode'), param('ns3::UanPdp', 'pdp')], + visibility='protected') return def register_Ns3UanModesListChecker_methods(root_module, cls): ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker() [constructor] cls.add_constructor([]) - ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker(ns3::UanModesListChecker const & arg0) [copy constructor] + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListChecker::UanModesListChecker(ns3::UanModesListChecker const & arg0) [constructor] cls.add_constructor([param('ns3::UanModesListChecker const &', 'arg0')]) return def register_Ns3UanModesListValue_methods(root_module, cls): ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue() [constructor] cls.add_constructor([]) - ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesListValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UanModesListValue const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesList const & value) [constructor] cls.add_constructor([param('ns3::UanModesList const &', 'value')]) + ## uan-tx-mode.h (module 'uan'): ns3::UanModesListValue::UanModesListValue(ns3::UanModesListValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UanModesListValue const &', 'arg0')]) ## uan-tx-mode.h (module 'uan'): ns3::Ptr ns3::UanModesListValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uan-tx-mode.h (module 'uan'): bool ns3::UanModesListValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uan-tx-mode.h (module 'uan'): bool ns3::UanModesListValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8000,7 +8304,7 @@ def register_Ns3UanModesListValue_methods(root_module, cls): 'ns3::UanModesList', [], is_const=True) - ## uan-tx-mode.h (module 'uan'): std::string ns3::UanModesListValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uan-tx-mode.h (module 'uan'): std::string ns3::UanModesListValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8012,7 +8316,7 @@ def register_Ns3UanModesListValue_methods(root_module, cls): return def register_Ns3UanNetDevice_methods(root_module, cls): - ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice(ns3::UanNetDevice const & arg0) [copy constructor] + ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice(ns3::UanNetDevice const & arg0) [constructor] cls.add_constructor([param('ns3::UanNetDevice const &', 'arg0')]) ## uan-net-device.h (module 'uan'): ns3::UanNetDevice::UanNetDevice() [constructor] cls.add_constructor([]) @@ -8157,12 +8461,12 @@ def register_Ns3UanNetDevice_methods(root_module, cls): cls.add_method('SetPhy', 'void', [param('ns3::Ptr< ns3::UanPhy >', 'phy')]) - ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetPromiscReceiveCallback(ns3::Callback,ns3::Ptr,short unsigned int,const ns3::Address&,const ns3::Address&,ns3::NetDevice::PacketType,ns3::empty,ns3::empty,ns3::empty> cb) [member function] + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetPromiscReceiveCallback(ns3::NetDevice::PromiscReceiveCallback cb) [member function] cls.add_method('SetPromiscReceiveCallback', 'void', - [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, short unsigned int, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], + [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty >', 'cb')], is_virtual=True) - ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetReceiveCallback(ns3::Callback, ns3::Ptr, unsigned short, ns3::Address const&, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> cb) [member function] + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::SetReceiveCallback(ns3::NetDevice::ReceiveCallback cb) [member function] cls.add_method('SetReceiveCallback', 'void', [param('ns3::Callback< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'cb')], @@ -8185,6 +8489,11 @@ def register_Ns3UanNetDevice_methods(root_module, cls): 'void', [], visibility='protected', is_virtual=True) + ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::DoInitialize() [member function] + cls.add_method('DoInitialize', + 'void', + [], + visibility='protected', is_virtual=True) ## uan-net-device.h (module 'uan'): void ns3::UanNetDevice::ForwardUp(ns3::Ptr pkt, ns3::UanAddress const & src) [member function] cls.add_method('ForwardUp', 'void', @@ -8195,16 +8504,16 @@ def register_Ns3UanNetDevice_methods(root_module, cls): def register_Ns3UintegerValue_methods(root_module, cls): ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue() [constructor] cls.add_constructor([]) - ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(uint64_t const & value) [constructor] cls.add_constructor([param('uint64_t const &', 'value')]) + ## uinteger.h (module 'core'): ns3::UintegerValue::UintegerValue(ns3::UintegerValue const & arg0) [constructor] + cls.add_constructor([param('ns3::UintegerValue const &', 'arg0')]) ## uinteger.h (module 'core'): ns3::Ptr ns3::UintegerValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## uinteger.h (module 'core'): bool ns3::UintegerValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8214,7 +8523,7 @@ def register_Ns3UintegerValue_methods(root_module, cls): 'uint64_t', [], is_const=True) - ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] + ## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8228,23 +8537,23 @@ def register_Ns3UintegerValue_methods(root_module, cls): def register_Ns3Vector2DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector2DChecker::Vector2DChecker(ns3::Vector2DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector2DChecker const &', 'arg0')]) return def register_Ns3Vector2DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2D const & value) [constructor] cls.add_constructor([param('ns3::Vector2D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector2DValue::Vector2DValue(ns3::Vector2DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector2DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector2DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector2DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8254,7 +8563,7 @@ def register_Ns3Vector2DValue_methods(root_module, cls): 'ns3::Vector2D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector2DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8268,23 +8577,23 @@ def register_Ns3Vector2DValue_methods(root_module, cls): def register_Ns3Vector3DChecker_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [copy constructor] + ## vector.h (module 'core'): ns3::Vector3DChecker::Vector3DChecker(ns3::Vector3DChecker const & arg0) [constructor] cls.add_constructor([param('ns3::Vector3DChecker const &', 'arg0')]) return def register_Ns3Vector3DValue_methods(root_module, cls): ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue() [constructor] cls.add_constructor([]) - ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3D const & value) [constructor] cls.add_constructor([param('ns3::Vector3D const &', 'value')]) + ## vector.h (module 'core'): ns3::Vector3DValue::Vector3DValue(ns3::Vector3DValue const & arg0) [constructor] + cls.add_constructor([param('ns3::Vector3DValue const &', 'arg0')]) ## vector.h (module 'core'): ns3::Ptr ns3::Vector3DValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## vector.h (module 'core'): bool ns3::Vector3DValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8294,7 +8603,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): 'ns3::Vector3D', [], is_const=True) - ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] + ## vector.h (module 'core'): std::string ns3::Vector3DValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8306,7 +8615,7 @@ def register_Ns3Vector3DValue_methods(root_module, cls): return def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): - ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel(ns3::AcousticModemEnergyModel const & arg0) [copy constructor] + ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel(ns3::AcousticModemEnergyModel const & arg0) [constructor] cls.add_constructor([param('ns3::AcousticModemEnergyModel const &', 'arg0')]) ## acoustic-modem-energy-model.h (module 'uan'): ns3::AcousticModemEnergyModel::AcousticModemEnergyModel() [constructor] cls.add_constructor([]) @@ -8365,11 +8674,11 @@ def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): 'void', [], is_virtual=True) - ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyDepletionCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyDepletionCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyDepletionCallback callback) [member function] cls.add_method('SetEnergyDepletionCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) - ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyRechargeCallback(ns3::Callback callback) [member function] + ## acoustic-modem-energy-model.h (module 'uan'): void ns3::AcousticModemEnergyModel::SetEnergyRechargeCallback(ns3::AcousticModemEnergyModel::AcousticModemEnergyRechargeCallback callback) [member function] cls.add_method('SetEnergyRechargeCallback', 'void', [param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')]) @@ -8414,23 +8723,23 @@ def register_Ns3AcousticModemEnergyModel_methods(root_module, cls): def register_Ns3AddressChecker_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressChecker::AddressChecker() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [copy constructor] + ## address.h (module 'network'): ns3::AddressChecker::AddressChecker(ns3::AddressChecker const & arg0) [constructor] cls.add_constructor([param('ns3::AddressChecker const &', 'arg0')]) return def register_Ns3AddressValue_methods(root_module, cls): ## address.h (module 'network'): ns3::AddressValue::AddressValue() [constructor] cls.add_constructor([]) - ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [copy constructor] - cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::Address const & value) [constructor] cls.add_constructor([param('ns3::Address const &', 'value')]) + ## address.h (module 'network'): ns3::AddressValue::AddressValue(ns3::AddressValue const & arg0) [constructor] + cls.add_constructor([param('ns3::AddressValue const &', 'arg0')]) ## address.h (module 'network'): ns3::Ptr ns3::AddressValue::Copy() const [member function] cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True) - ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] + ## address.h (module 'network'): bool ns3::AddressValue::DeserializeFromString(std::string value, ns3::Ptr checker) [member function] cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8440,7 +8749,7 @@ def register_Ns3AddressValue_methods(root_module, cls): 'ns3::Address', [], is_const=True) - ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] + ## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr checker) const [member function] cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], @@ -8451,8 +8760,404 @@ def register_Ns3AddressValue_methods(root_module, cls): [param('ns3::Address const &', 'value')]) return +def register_Ns3CallbackImpl__Bool_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< bool, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): bool ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3) [member operator] + cls.add_method('operator()', + 'bool', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Ns3ObjectBase___star___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< ns3::ObjectBase *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): ns3::ObjectBase * ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'ns3::ObjectBase *', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Double_Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, double, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(double arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('double', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(int arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('int', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3MobilityModel__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::MobilityModel const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::MobilityModel const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::UanTxMode arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('double', 'arg1'), param('ns3::UanTxMode', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanAddress_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::UanAddress, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanAddress arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::UanAddress', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanTxMode arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('ns3::UanTxMode', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_int_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned int, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, unsigned short, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, short unsigned int arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet const >', 'arg0'), param('short unsigned int', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Ptr__lt__const_ns3Packet__gt___Unsigned_short_Const_ns3Address___amp___Const_ns3Address___amp___Ns3NetDevicePacketType_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::Ptr< ns3::Packet const >, unsigned short, ns3::Address const &, ns3::Address const &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::Ptr, unsigned short, const ns3::Address &, const ns3::Address &, ns3::NetDevice::PacketType, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::Ptr arg1, short unsigned int arg2, ns3::Address const & arg3, ns3::Address const & arg4, ns3::NetDevice::PacketType arg5) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0'), param('ns3::Ptr< ns3::Packet const >', 'arg1'), param('short unsigned int', 'arg2'), param('ns3::Address const &', 'arg3'), param('ns3::Address const &', 'arg4'), param('ns3::NetDevice::PacketType', 'arg5')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3NetDevice__gt___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::NetDevice >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::NetDevice >', 'arg0')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Const_ns3UanAddress___amp___Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, ns3::UanAddress const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, const ns3::UanAddress &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, ns3::UanAddress const & arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('ns3::UanAddress const &', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3UanTxMode_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::UanTxMode, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1, ns3::UanTxMode arg2) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1'), param('ns3::UanTxMode', 'arg2')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Ptr__lt__ns3Packet__gt___Double_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::CallbackImpl(ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Ptr< ns3::Packet >, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl, double, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty>::operator()(ns3::Ptr arg0, double arg1) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Ptr< ns3::Packet >', 'arg0'), param('double', 'arg1')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Time_Ns3Time_Unsigned_int_Unsigned_int_Double_Unsigned_int_Double_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::Time, ns3::Time, unsigned int, unsigned int, double, unsigned int, double, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()(ns3::Time arg0, ns3::Time arg1, unsigned int arg2, unsigned int arg3, double arg4, unsigned int arg5, double arg6) [member operator] + cls.add_method('operator()', + 'void', + [param('ns3::Time', 'arg0'), param('ns3::Time', 'arg1'), param('unsigned int', 'arg2'), param('unsigned int', 'arg3'), param('double', 'arg4'), param('unsigned int', 'arg5'), param('double', 'arg6')], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + +def register_Ns3CallbackImpl__Void_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_Ns3Empty_methods(root_module, cls): + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl() [constructor] + cls.add_constructor([]) + ## callback.h (module 'core'): ns3::CallbackImpl::CallbackImpl(ns3::CallbackImpl const & arg0) [constructor] + cls.add_constructor([param('ns3::CallbackImpl< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty > const &', 'arg0')]) + ## callback.h (module 'core'): static std::string ns3::CallbackImpl::DoGetTypeid() [member function] + cls.add_method('DoGetTypeid', + 'std::string', + [], + is_static=True) + ## callback.h (module 'core'): std::string ns3::CallbackImpl::GetTypeid() const [member function] + cls.add_method('GetTypeid', + 'std::string', + [], + is_const=True, is_virtual=True) + ## callback.h (module 'core'): void ns3::CallbackImpl::operator()() [member operator] + cls.add_method('operator()', + 'void', + [], + is_pure_virtual=True, is_virtual=True, custom_name=u'__call__') + return + def register_Ns3HashImplementation_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation(ns3::Hash::Implementation const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Implementation const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Implementation::Implementation() [constructor] cls.add_constructor([]) @@ -8474,7 +9179,7 @@ def register_Ns3HashImplementation_methods(root_module, cls): return def register_Ns3HashFunctionFnv1a_methods(root_module, cls): - ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [copy constructor] + ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a(ns3::Hash::Function::Fnv1a const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Fnv1a const &', 'arg0')]) ## hash-fnv.h (module 'core'): ns3::Hash::Function::Fnv1a::Fnv1a() [constructor] cls.add_constructor([]) @@ -8496,7 +9201,7 @@ def register_Ns3HashFunctionFnv1a_methods(root_module, cls): return def register_Ns3HashFunctionHash32_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Function::Hash32 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash32 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash32::Hash32(ns3::Hash::Hash32Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash32Function_ptr', 'hp')]) @@ -8513,7 +9218,7 @@ def register_Ns3HashFunctionHash32_methods(root_module, cls): return def register_Ns3HashFunctionHash64_methods(root_module, cls): - ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [copy constructor] + ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Function::Hash64 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Hash64 const &', 'arg0')]) ## hash-function.h (module 'core'): ns3::Hash::Function::Hash64::Hash64(ns3::Hash::Hash64Function_ptr hp) [constructor] cls.add_constructor([param('ns3::Hash::Hash64Function_ptr', 'hp')]) @@ -8535,7 +9240,7 @@ def register_Ns3HashFunctionHash64_methods(root_module, cls): return def register_Ns3HashFunctionMurmur3_methods(root_module, cls): - ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [copy constructor] + ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3(ns3::Hash::Function::Murmur3 const & arg0) [constructor] cls.add_constructor([param('ns3::Hash::Function::Murmur3 const &', 'arg0')]) ## hash-murmur3.h (module 'core'): ns3::Hash::Function::Murmur3::Murmur3() [constructor] cls.add_constructor([]) @@ -8558,7 +9263,7 @@ def register_Ns3HashFunctionMurmur3_methods(root_module, cls): def register_functions(root_module): module = root_module - ## uan-tx-mode.h (module 'uan'): extern ns3::Ptr ns3::MakeUanModesListChecker() [free function] + ## uan-tx-mode.h (module 'uan'): ns3::Ptr ns3::MakeUanModesListChecker() [free function] module.add_function('MakeUanModesListChecker', 'ns3::Ptr< ns3::AttributeChecker const >', []) From fa6e4a0317d4fe3af61f46e002e188eda0f99d64 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sat, 19 Aug 2017 08:43:14 -0700 Subject: [PATCH 222/551] wifi: Additional Doxygen fixes --- src/wifi/examples/test-interference-helper.cc | 5 +- src/wifi/helper/ht-wifi-mac-helper.h | 3 + src/wifi/helper/qos-wifi-mac-helper.h | 1 + src/wifi/helper/spectrum-wifi-helper.h | 1 + src/wifi/helper/yans-wifi-helper.h | 1 + src/wifi/model/ampdu-tag.h | 4 +- src/wifi/model/block-ack-agreement.h | 1 + src/wifi/model/block-ack-manager.h | 27 +++- src/wifi/model/ctrl-headers.h | 4 +- src/wifi/model/dca-txop.h | 4 + src/wifi/model/dcf-state.h | 1 + src/wifi/model/edca-txop-n.h | 4 +- src/wifi/model/he-capabilities.h | 5 +- src/wifi/model/interference-helper.h | 7 +- src/wifi/model/mac-low.h | 4 +- src/wifi/model/mac-rx-middle.h | 1 + src/wifi/model/minstrel-ht-wifi-manager.h | 144 +++++++++++++++--- src/wifi/model/minstrel-wifi-manager.h | 7 +- src/wifi/model/mpdu-aggregator.h | 11 +- src/wifi/model/mpdu-standard-aggregator.h | 11 +- .../model/originator-block-ack-agreement.h | 1 + src/wifi/model/regular-wifi-mac.h | 9 +- src/wifi/model/ssid.h | 25 +++ src/wifi/model/supported-rates.h | 38 ++++- .../model/wifi-information-element-vector.h | 35 ++++- src/wifi/model/wifi-information-element.h | 4 +- src/wifi/model/wifi-mac-header.cc | 2 + src/wifi/model/wifi-mac.h | 4 +- src/wifi/model/wifi-mode.h | 3 + src/wifi/model/wifi-remote-station-manager.h | 5 +- .../model/wifi-spectrum-signal-parameters.h | 2 + src/wifi/test/dcf-manager-test.cc | 1 + 32 files changed, 317 insertions(+), 58 deletions(-) diff --git a/src/wifi/examples/test-interference-helper.cc b/src/wifi/examples/test-interference-helper.cc index 215eced0590..7f34476ff96 100644 --- a/src/wifi/examples/test-interference-helper.cc +++ b/src/wifi/examples/test-interference-helper.cc @@ -97,7 +97,10 @@ class InterferenceExperiment void Run (struct InterferenceExperiment::Input input); private: - /// Function triggered when a packet is dropped + /** + * Function triggered when a packet is dropped + * \param packet the packet that was dropped + */ void PacketDropped(Ptr packet); /// Send A function void SendA (void) const; diff --git a/src/wifi/helper/ht-wifi-mac-helper.h b/src/wifi/helper/ht-wifi-mac-helper.h index 7a5c94ed6e8..19e2de0aa0a 100644 --- a/src/wifi/helper/ht-wifi-mac-helper.h +++ b/src/wifi/helper/ht-wifi-mac-helper.h @@ -53,11 +53,14 @@ class HtWifiMacHelper : public QosWifiMacHelper /** * Create a mac helper in a default working state. + * \returns a default HtWifiMacHelper */ static HtWifiMacHelper Default (void); /** * Converts a HT MCS value into a DataRate value + * \param mcs the HT MCS + * \returns a DataRate value for the HT MCS */ static StringValue DataRateForMcs (int mcs); }; diff --git a/src/wifi/helper/qos-wifi-mac-helper.h b/src/wifi/helper/qos-wifi-mac-helper.h index bf61b42aef8..717c104c83e 100644 --- a/src/wifi/helper/qos-wifi-mac-helper.h +++ b/src/wifi/helper/qos-wifi-mac-helper.h @@ -53,6 +53,7 @@ class QosWifiMacHelper : public WifiMacHelper /** * Create a mac helper in a default working state. + * \returns a default QosWifiMacHelper */ static QosWifiMacHelper Default (void); diff --git a/src/wifi/helper/spectrum-wifi-helper.h b/src/wifi/helper/spectrum-wifi-helper.h index a61e3c12046..4442c950e97 100644 --- a/src/wifi/helper/spectrum-wifi-helper.h +++ b/src/wifi/helper/spectrum-wifi-helper.h @@ -45,6 +45,7 @@ class SpectrumWifiPhyHelper : public WifiPhyHelper /** * Create a phy helper in a default working state. + * \returns a default SpectrumWifPhyHelper */ static SpectrumWifiPhyHelper Default (void); diff --git a/src/wifi/helper/yans-wifi-helper.h b/src/wifi/helper/yans-wifi-helper.h index 6ea625c4d40..f7d1dcce645 100644 --- a/src/wifi/helper/yans-wifi-helper.h +++ b/src/wifi/helper/yans-wifi-helper.h @@ -168,6 +168,7 @@ class YansWifiPhyHelper : public WifiPhyHelper /** * Create a phy helper in a default working state. + * \returns a default YansWifiPhyHelper */ static YansWifiPhyHelper Default (void); diff --git a/src/wifi/model/ampdu-tag.h b/src/wifi/model/ampdu-tag.h index 0d3f5942673..02598b26f4f 100644 --- a/src/wifi/model/ampdu-tag.h +++ b/src/wifi/model/ampdu-tag.h @@ -48,7 +48,9 @@ class AmpduTag : public Tag */ AmpduTag (); /** - * Set m_ampdu to 1. + * \param supported the A-MPDU supported flag + * + * Set the A-MPDU supported flag. */ void SetAmpdu (bool supported); /** diff --git a/src/wifi/model/block-ack-agreement.h b/src/wifi/model/block-ack-agreement.h index 881d5992479..d46476a44ce 100644 --- a/src/wifi/model/block-ack-agreement.h +++ b/src/wifi/model/block-ack-agreement.h @@ -31,6 +31,7 @@ namespace ns3 { */ class BlockAckAgreement { + /// Provide access to MacLow class friend class MacLow; diff --git a/src/wifi/model/block-ack-manager.h b/src/wifi/model/block-ack-manager.h index 7ad8a7e414e..78380809263 100644 --- a/src/wifi/model/block-ack-manager.h +++ b/src/wifi/model/block-ack-manager.h @@ -72,8 +72,12 @@ class BlockAckManager : public Object private: /// type conversion operator BlockAckManager (const BlockAckManager&); - /// assignment operator - BlockAckManager& operator= (const BlockAckManager&); + /** + * assignment operator + * \param block BlockAckManager to assign + * \returns the assigned BlockAckManager + */ + BlockAckManager& operator= (const BlockAckManager& block); public: @@ -322,8 +326,8 @@ class BlockAckManager : public Object void SetUnblockDestinationCallback (Callback callback); /** - * \param recipient - * \param tid + * \param recipient the destination address + * \param tid the Traffic ID * \param startingSeq * * \return true if there are packets in the queue that could be sent under block ACK, @@ -336,8 +340,8 @@ class BlockAckManager : public Object */ bool SwitchToBlockAckIfNeeded (Mac48Address recipient, uint8_t tid, uint16_t startingSeq); /** - * \param recipient - * \param tid + * \param recipient the destination address + * \param tid the Traffic ID * * \return the sequence number of the next retry packet for a specific agreement * @@ -348,10 +352,19 @@ class BlockAckManager : public Object uint16_t GetSeqNumOfNextRetryPacket (Mac48Address recipient, uint8_t tid) const; /** * Checks if the packet already exists in the retransmit queue or not if it does then it doesn't add it again + * + * \param currentSeq the current sequence + * \param recipient the destination address + * \param tid the Traffic ID + * \returns true if the packet already exists */ bool AlreadyExists (uint16_t currentSeq, Mac48Address recipient, uint8_t tid) const; /** * Remove a packet after you peek in the queue and get it + * \param tid the Traffic ID + * \param recipient the destination address + * \param seqnumber sequence number + * \returns true if a packet was removed */ bool RemovePacket (uint8_t tid, Mac48Address recipient, uint16_t seqnumber); /** @@ -373,7 +386,7 @@ class BlockAckManager : public Object * * \param tid Traffic ID * \param seqNumber sequence number - * \param recipient mac address + * \param recipient MAC address * * \returns true if BAR retransmission needed */ diff --git a/src/wifi/model/ctrl-headers.h b/src/wifi/model/ctrl-headers.h index c3d1b22875d..d8435c9170e 100644 --- a/src/wifi/model/ctrl-headers.h +++ b/src/wifi/model/ctrl-headers.h @@ -408,8 +408,8 @@ class CtrlBAckResponseHeader : public Header union { - uint16_t m_bitmap[64]; - uint64_t m_compressedBitmap; + uint16_t m_bitmap[64]; ///< the block ack bitmap + uint64_t m_compressedBitmap; ///< the compressed block ack bitmap } bitmap; ///< bitmap union type }; diff --git a/src/wifi/model/dca-txop.h b/src/wifi/model/dca-txop.h index a61540c214e..ed45a040988 100644 --- a/src/wifi/model/dca-txop.h +++ b/src/wifi/model/dca-txop.h @@ -58,7 +58,9 @@ class CtrlBAckResponseHeader; class DcaTxop : public Object { public: + /// allow DcfListener class access friend class DcfListener; + /// allow MacLowTransmissionListener class access friend class MacLowTransmissionListener; DcaTxop (); @@ -247,6 +249,7 @@ class DcaTxop : public Object virtual void GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address recipient, double rxSnr, WifiMode txMode, double dataSnr); /** * Event handler when a Block ACK timeout has occurred. + * \param nMpdus the number of MPDUs sent in the A-MPDU transmission that results in a Block ACK timeout. */ virtual void MissedBlockAck (uint8_t nMpdus); @@ -290,6 +293,7 @@ class DcaTxop : public Object protected: + ///< DcfState associated class friend class DcfState; virtual void DoDispose (void); diff --git a/src/wifi/model/dcf-state.h b/src/wifi/model/dcf-state.h index 79f881ca718..7a89418b18c 100644 --- a/src/wifi/model/dcf-state.h +++ b/src/wifi/model/dcf-state.h @@ -144,6 +144,7 @@ class DcfState : public Object protected: + /// DcfManager associated class friend class DcfManager; // Inherited from ns3::Object diff --git a/src/wifi/model/edca-txop-n.h b/src/wifi/model/edca-txop-n.h index 1408eb9ac78..52599d89d46 100644 --- a/src/wifi/model/edca-txop-n.h +++ b/src/wifi/model/edca-txop-n.h @@ -68,7 +68,7 @@ enum TypeOfStation class EdcaTxopN : public DcaTxop { public: - // Allow test cases to access private members + /// Allow test cases to access private members friend class ::AmpduAggregationTest; std::map m_aMpduEnabled; //!< list containing flags whether A-MPDU is enabled for a given destination address @@ -200,6 +200,7 @@ class EdcaTxopN : public DcaTxop void GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address recipient, double rxSnr, WifiMode txMode, double dataSnr); /** * Event handler when a Block ACK timeout has occurred. + * \param nMpdus number of MPDUs sent in the A-MPDU transmission that results in a Block ACK timeout. */ void MissedBlockAck (uint8_t nMpdus); /** @@ -424,6 +425,7 @@ class EdcaTxopN : public DcaTxop private: + /// allow AggregationCapableTransmissionListener class access friend class AggregationCapableTransmissionListener; /** diff --git a/src/wifi/model/he-capabilities.h b/src/wifi/model/he-capabilities.h index aea41bf4883..0961933ac63 100644 --- a/src/wifi/model/he-capabilities.h +++ b/src/wifi/model/he-capabilities.h @@ -40,7 +40,10 @@ class HeCapabilities : public WifiInformationElement * \param hesupported the HE supported indicator */ void SetHeSupported (uint8_t hesupported); - + /** + * Get the wifi information element ID + * \returns the wifi information element ID + */ WifiInformationElementId ElementId () const; /** * Get information field size diff --git a/src/wifi/model/interference-helper.h b/src/wifi/model/interference-helper.h index bcabe3e9578..333a6f5eb9e 100644 --- a/src/wifi/model/interference-helper.h +++ b/src/wifi/model/interference-helper.h @@ -327,7 +327,12 @@ class InterferenceHelper double m_firstPower; ///< first power bool m_rxing; ///< flag whether it is in receiving state - /// Returns a const_iterator to the first nichange, which is later than moment + /** + * Returns a const iterator to the first nichange, which is later than moment + * + * \param moment time to check from + * \returns an iterator to the list of NiChanges + */ NiChanges::const_iterator GetPosition (Time moment); /** * Add NiChange to the list at the appropriate position. diff --git a/src/wifi/model/mac-low.h b/src/wifi/model/mac-low.h index 4c622b990ed..58f7a1ddda5 100644 --- a/src/wifi/model/mac-low.h +++ b/src/wifi/model/mac-low.h @@ -212,6 +212,7 @@ class MacLowTransmissionParameters private: friend std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters ¶ms); uint32_t m_nextSize; //!< the next size + /// wait ack enumerated type enum { ACK_NONE, @@ -243,8 +244,9 @@ std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters class MacLow : public Object { public: - // Allow test cases to access private members + /// Allow test cases to access private members friend class ::TwoLevelAggregationTest; + /// Allow test cases to access private members friend class ::AmpduAggregationTest; /** * typedef for a callback for MacLowRx diff --git a/src/wifi/model/mac-rx-middle.h b/src/wifi/model/mac-rx-middle.h index 9c84a908cb8..afee9cf3d4b 100644 --- a/src/wifi/model/mac-rx-middle.h +++ b/src/wifi/model/mac-rx-middle.h @@ -63,6 +63,7 @@ class MacRxMiddle : public SimpleRefCount private: + /// allow MacRxMiddleTest associated class access friend class MacRxMiddleTest; /** * Look up for OriginatorRxStatus associated with the sender address diff --git a/src/wifi/model/minstrel-ht-wifi-manager.h b/src/wifi/model/minstrel-ht-wifi-manager.h index 8082df36f6e..7d2a4846e3e 100644 --- a/src/wifi/model/minstrel-ht-wifi-manager.h +++ b/src/wifi/model/minstrel-ht-wifi-manager.h @@ -46,8 +46,8 @@ typedef std::vector > TxTime; struct McsGroup { uint8_t streams; ///< streams - uint8_t sgi; ///< SQI - uint8_t chWidth; ///< channel width + uint8_t sgi; ///< short guard interval (0 or 1) + uint8_t chWidth; ///< channel width (MHz) bool isVht; ///< is VHT? bool isSupported; ///< is supported? @@ -260,37 +260,105 @@ class MinstrelHtWifiManager : public WifiRemoteStationManager */ void DoDisposeStation (WifiRemoteStation *station); - /// Check the validity of a combination of number of streams, chWidth and mode. + /** + * Check the validity of a combination of number of streams, chWidth and mode. + * + * \param phy pointer to the wifi phy + * \param streams the number of streams + * \param chWidth the channel width (MHz) + * \param mode the wifi mode + * \returns true if the combination is valid + */ bool IsValidMcs (Ptr phy, uint8_t streams, uint8_t chWidth, WifiMode mode); - /// Estimates the TxTime of a frame with a given mode and group (stream, guard interval and channel width). + /** + * Estimates the TxTime of a frame with a given mode and group (stream, guard interval and channel width). + * + * \param phy pointer to the wifi phy + * \param streams the number of streams + * \param sgi short guard interval enabled (0 or 1) + * \param chWidth the channel width (MHz) + * \param mode the wifi mode + * \returns the transmit time + */ Time CalculateMpduTxDuration (Ptr phy, uint8_t streams, uint8_t sgi, uint8_t chWidth, WifiMode mode); - /// Estimates the TxTime of a frame with a given mode and group (stream, guard interval and channel width). + /** + * Estimates the TxTime of a frame with a given mode and group (stream, guard interval and channel width). + * + * \param phy pointer to the wifi phy + * \param streams the number of streams + * \param sgi short guard interval enabled (0 or 1) + * \param chWidth the channel width (MHz) + * \param mode the wifi mode + * \returns the transmit time + */ Time CalculateFirstMpduTxDuration (Ptr phy, uint8_t streams, uint8_t sgi, uint8_t chWidth, WifiMode mode); - /// Obtain the TXtime saved in the group information. + /** + * Obtain the TXtime saved in the group information. + * + * \param groupId the group ID + * \param mode the wifi mode + * \returns the transmit time + */ Time GetMpduTxTime (uint32_t groupId, WifiMode mode) const; - /// Save a TxTime to the vector of groups. + /** + * Save a TxTime to the vector of groups. + * + * \param groupId the group ID + * \param mode the wifi mode + * \param t the transmit time + */ void AddMpduTxTime (uint32_t groupId, WifiMode mode, Time t); - /// Obtain the TXtime saved in the group information. + /** + * Obtain the TXtime saved in the group information. + * + * \param groupId the group ID + * \param mode the wifi mode + * \returns the transmit time + */ Time GetFirstMpduTxTime (uint32_t groupId, WifiMode mode) const; - /// Save a TxTime to the vector of groups. + /** + * Save a TxTime to the vector of groups. + * + * \param groupId the group ID + * \param mode the wifi mode + * \param t the transmit time + */ void AddFirstMpduTxTime (uint32_t groupId, WifiMode mode, Time t); - /// Update the number of retries and reset accordingly. + /** + * Update the number of retries and reset accordingly. + * \param station the wifi remote station + */ void UpdateRetry (MinstrelHtWifiRemoteStation *station); - /// Update the number of sample count variables. + /** + * Update the number of sample count variables. + * + * \param station the wifi remote station + * \param nSuccessfulMpdus + * \param nFailedMpdus + */ void UpdatePacketCounters (MinstrelHtWifiRemoteStation *station, uint8_t nSuccessfulMpdus, uint8_t nFailedMpdus); - /// Getting the next sample from Sample Table. + /** + * Getting the next sample from Sample Table. + * + * \param station the wifi remote station + * \returns the next sample + */ uint32_t GetNextSample (MinstrelHtWifiRemoteStation *station); - /// Set the next sample from Sample Table. + /** + * Set the next sample from Sample Table. + * + * \param station the wifi remote station + */ void SetNextSample (MinstrelHtWifiRemoteStation *station); /** @@ -456,7 +524,12 @@ class MinstrelHtWifiManager : public WifiRemoteStationManager * \returns the rate ID */ - /// Return the rateId inside a group, from the global index. + /** + * Return the rateId inside a group, from the global index. + * + * \param index the index + * \returns the rate ID + */ uint32_t GetRateId (uint32_t index); /** @@ -476,22 +549,53 @@ class MinstrelHtWifiManager : public WifiRemoteStationManager */ uint32_t GetIndex (uint32_t groupId, uint32_t rateId); - /// Returns the groupId of a HT MCS with the given number of streams, if using sgi and the channel width used. + /** + * Returns the groupId of a HT MCS with the given number of streams, if using sgi and the channel width used. + * + * \param txstreams the number of streams + * \param sgi short guard interval enabled (0 or 1) + * \param chWidth the channel width (MHz) + * \returns the HT group ID + */ uint32_t GetHtGroupId (uint8_t txstreams, uint8_t sgi, uint8_t chWidth); - /// Returns the groupId of a VHT MCS with the given number of streams, if using sgi and the channel width used. + /** + * Returns the groupId of a VHT MCS with the given number of streams, if using sgi and the channel width used. + * + * \param txstreams the number of streams + * \param sgi short guard interval enabled (0 or 1) + * \param chWidth the channel width (MHz) + * \returns the VHT group ID + */ uint32_t GetVhtGroupId (uint8_t txstreams, uint8_t sgi, uint8_t chWidth); - /// Returns the lowest global index of the rates supported by the station. + /** + * Returns the lowest global index of the rates supported by the station. + * + * \param station the minstrel HT wifi remote station + * \returns the lowest global index + */ uint32_t GetLowestIndex (MinstrelHtWifiRemoteStation *station); - /// Returns the lowest global index of the rates supported by in the group. + /** + * Returns the lowest global index of the rates supported by in the group. + * + * \param station the minstrel HT wifi remote station + * \param groupId the group ID + * \returns the lowest global index + */ uint32_t GetLowestIndex (MinstrelHtWifiRemoteStation *station, uint32_t groupId); - /// Returns a list of only the VHT MCS supported by the device. + /** + * Returns a list of only the VHT MCS supported by the device. + * \returns the list of the VHT MCS supported + */ WifiModeList GetVhtDeviceMcsList (void) const; - /// Returns a list of only the HT MCS supported by the device. + /** + * Returns a list of only the HT MCS supported by the device. + * \returns the list of the HT MCS supported + */ WifiModeList GetHtDeviceMcsList (void) const; Time m_updateStats; //!< How frequent do we calculate the stats (1/10 seconds). diff --git a/src/wifi/model/minstrel-wifi-manager.h b/src/wifi/model/minstrel-wifi-manager.h index e72ee4822cd..015dea3902d 100644 --- a/src/wifi/model/minstrel-wifi-manager.h +++ b/src/wifi/model/minstrel-wifi-manager.h @@ -275,7 +275,12 @@ class MinstrelWifiManager : public WifiRemoteStationManager bool IsLowLatency (void) const; - /// for estimating the TxTime of a packet with a given mode + /** + * for estimating the TxTime of a packet with a given mode + * + * \param mode Wi-Fi mode + * \returns the transmission time + */ Time GetCalcTxTime (WifiMode mode) const; /** * Add transmission time for the given mode to an internal list. diff --git a/src/wifi/model/mpdu-aggregator.h b/src/wifi/model/mpdu-aggregator.h index 0a839405e80..cc0ffea2ebb 100644 --- a/src/wifi/model/mpdu-aggregator.h +++ b/src/wifi/model/mpdu-aggregator.h @@ -76,10 +76,17 @@ class MpduAggregator : public Object */ virtual bool Aggregate (Ptr packet, Ptr aggregatedPacket) const = 0; /** - * This method performs a VHT/HE single MPDU aggregation. - */ + * \param packet the packet we want to insert into aggregatedPacket. + * \param aggregatedPacket packet that will contain the packet of size packetSize, if aggregation is possible. + * + * This method performs a VHT/HE single MPDU aggregation. + */ virtual void AggregateSingleMpdu (Ptr packet, Ptr aggregatedPacket) const = 0; /** + * \param packet the packet we want to insert into aggregatedPacket. + * \param last true if it is the last packet. + * \param isSingleMpdu true if it is a single MPDU + * * Adds A-MPDU subframe header and padding to each MPDU that is part of an A-MPDU before it is sent. */ virtual void AddHeaderAndPad (Ptr packet, bool last, bool isSingleMpdu) const = 0; diff --git a/src/wifi/model/mpdu-standard-aggregator.h b/src/wifi/model/mpdu-standard-aggregator.h index 6071909c50a..d49b11c6ad0 100644 --- a/src/wifi/model/mpdu-standard-aggregator.h +++ b/src/wifi/model/mpdu-standard-aggregator.h @@ -67,10 +67,17 @@ class MpduStandardAggregator : public MpduAggregator */ bool Aggregate (Ptr packet, Ptr aggregatedPacket) const; /** - * This method performs a VHT/HE single MPDU aggregation. - */ + * \param packet the packet we want to insert into aggregatedPacket. + * \param aggregatedPacket packet that will contain the packet of size packetSize, if aggregation is possible. + * + * This method performs a VHT/HE single MPDU aggregation. + */ void AggregateSingleMpdu (Ptr packet, Ptr aggregatedPacket) const; /** + * \param packet the packet we want to insert into aggregatedPacket. + * \param last true if it is the last packet. + * \param isSingleMpdu true if it is a single MPDU + * * Adds A-MPDU subframe header and padding to each MPDU that is part of an A-MPDU before it is sent. */ void AddHeaderAndPad (Ptr packet, bool last, bool isSingleMpdu) const; diff --git a/src/wifi/model/originator-block-ack-agreement.h b/src/wifi/model/originator-block-ack-agreement.h index 0de9b61249f..46ad71d5b8f 100644 --- a/src/wifi/model/originator-block-ack-agreement.h +++ b/src/wifi/model/originator-block-ack-agreement.h @@ -32,6 +32,7 @@ namespace ns3 { */ class OriginatorBlockAckAgreement : public BlockAckAgreement { + /// allow BlockAckManager class access friend class BlockAckManager; diff --git a/src/wifi/model/regular-wifi-mac.h b/src/wifi/model/regular-wifi-mac.h index ac467d0722e..5608d5c9fb2 100644 --- a/src/wifi/model/regular-wifi-mac.h +++ b/src/wifi/model/regular-wifi-mac.h @@ -569,8 +569,13 @@ class RegularWifiMac : public WifiMac private: /// type conversion operator RegularWifiMac (const RegularWifiMac &); - /// assignment operator - RegularWifiMac & operator= (const RegularWifiMac &); + /** + * assignment operator + * + * \param mac the RegularWifiMac to assign + * \returns the assigned value + */ + RegularWifiMac & operator= (const RegularWifiMac & mac); /** * This method is a private utility invoked to configure the channel diff --git a/src/wifi/model/ssid.h b/src/wifi/model/ssid.h index a06dbec2e4f..6007701a8b6 100644 --- a/src/wifi/model/ssid.h +++ b/src/wifi/model/ssid.h @@ -75,9 +75,34 @@ class Ssid : public WifiInformationElement */ char* PeekString (void) const; + /** + * Get the ElementID. + * + * \returns the element ID + */ WifiInformationElementId ElementId () const; + + /** + * Get the information field size. + * + * \returns the information field size + */ uint8_t GetInformationFieldSize () const; + + /** + * Get the information field size. + * + * \param start the information field iterator + */ void SerializeInformationField (Buffer::Iterator start) const; + + /** + * Get the information field size. + * + * \param start the information field iterator + * \param length the size of the information field + * \returns the size of the field read + */ uint8_t DeserializeInformationField (Buffer::Iterator start, uint8_t length); diff --git a/src/wifi/model/supported-rates.h b/src/wifi/model/supported-rates.h index 06d1e8acb0e..22cbaf86cb1 100644 --- a/src/wifi/model/supported-rates.h +++ b/src/wifi/model/supported-rates.h @@ -79,8 +79,8 @@ class ExtendedSupportedRatesIE : public WifiInformationElement * Deserialize information field. * * \param start the iterator - * \param length the field length - * \returns the information field + * \param length the field length (bytes) + * \returns length of the information field deserialized (bytes) */ uint8_t DeserializeInformationField (Buffer::Iterator start, uint8_t length); @@ -133,8 +133,13 @@ class SupportedRates : public WifiInformationElement /// type conversion operator SupportedRates (const SupportedRates &); - /// assignment operator - SupportedRates& operator= (const SupportedRates&); + /** + * assignment operator + * + * \param rates the rates to assign + * \returns the assigned value + */ + SupportedRates& operator= (const SupportedRates& rates); /** * This defines the maximum number of supported rates that a STA is @@ -207,14 +212,35 @@ class SupportedRates : public WifiInformationElement * \return the rate */ uint32_t GetRate (uint8_t i) const; - + /** + * Get the ElementID. + * + * \returns the element ID + */ WifiInformationElementId ElementId () const; + /** + * Get the information field size. + * + * \returns the information field size + */ uint8_t GetInformationFieldSize () const; + /** + * Get the information field size. + * + * \param start the information field iterator + */ void SerializeInformationField (Buffer::Iterator start) const; + /** + * Get the information field size. + * + * \param start the information field iterator + * \param length the size of the information field (bytes) + * \returns the size of the field read (bytes) + */ uint8_t DeserializeInformationField (Buffer::Iterator start, uint8_t length); - /* + /** * We support the Extended Supported Rates Information Element * through the ExtendedSupportedRatesIE object which is declared * above. We allow this class to be a friend so that it can access diff --git a/src/wifi/model/wifi-information-element-vector.h b/src/wifi/model/wifi-information-element-vector.h index 3001fb8b1fc..db733578cad 100644 --- a/src/wifi/model/wifi-information-element-vector.h +++ b/src/wifi/model/wifi-information-element-vector.h @@ -68,17 +68,37 @@ class WifiInformationElementVector : public Header * \return deserialized bytes */ virtual uint32_t DeserializeSingleIe (Buffer::Iterator start); - /// Set maximum size to control overflow of the max packet length + /** + * Set maximum size to control overflow of the max packet length + * + * \param size the maximum size to set (bytes) + */ void SetMaxSize (uint16_t size); /// As soon as this is a vector, we define an Iterator typedef std::vector >::iterator Iterator; - /// Returns Begin of the vector + /** + * Returns Begin of the vector + * \returns the begin of the vector + */ Iterator Begin (); - /// Returns End of the vector + /** + * Returns End of the vector + * \returns the end of the vector + */ Iterator End (); - /// add an IE, if maxSize has exceeded, returns false + /** + * add an IE, if maxSize has exceeded, returns false + * + * \param element wifi information element to add + * \returns true is added + */ bool AddInformationElement (Ptr element); - /// vector of pointers to information elements is the body of IeVector + /** + * vector of pointers to information elements is the body of IeVector + * + * \param id the element id to find + * \returns the information element + */ Ptr FindFirst (WifiInformationElementId id) const; /** @@ -97,7 +117,10 @@ class WifiInformationElementVector : public Header * typedef for a vector of WifiInformationElements. */ typedef std::vector > IE_VECTOR; - /// Current number of bytes + /** + * Current number of bytes + * \returns the number of bytes + */ uint32_t GetSize () const; IE_VECTOR m_elements; //!< Information element vector /// Size in bytes (actually, max packet length) diff --git a/src/wifi/model/wifi-information-element.h b/src/wifi/model/wifi-information-element.h index 77caa3d2faa..44dd1d5868a 100644 --- a/src/wifi/model/wifi-information-element.h +++ b/src/wifi/model/wifi-information-element.h @@ -269,7 +269,9 @@ class WifiInformationElement : public SimpleRefCount uint16_t GetSerializedSize () const; // Each subclass must implement these pure virtual functions: - /// Own unique Element ID + /** + * \returns Own unique Element ID + */ virtual WifiInformationElementId ElementId () const = 0; /** * Length of serialized information (i.e., the length of the body diff --git a/src/wifi/model/wifi-mac-header.cc b/src/wifi/model/wifi-mac-header.cc index 13554407254..7f57ff940f7 100644 --- a/src/wifi/model/wifi-mac-header.cc +++ b/src/wifi/model/wifi-mac-header.cc @@ -27,6 +27,7 @@ namespace ns3 { NS_OBJECT_ENSURE_REGISTERED (WifiMacHeader); +/// type enumeration enum { TYPE_MGT = 0, @@ -34,6 +35,7 @@ enum TYPE_DATA = 2 }; +/// subtype enumeration enum { //Reserved: 0 - 6 diff --git a/src/wifi/model/wifi-mac.h b/src/wifi/model/wifi-mac.h index adc0a43e825..c3758631acb 100644 --- a/src/wifi/model/wifi-mac.h +++ b/src/wifi/model/wifi-mac.h @@ -201,11 +201,11 @@ class WifiMac : public Object */ virtual void SetWifiPhy (Ptr phy) = 0; /** - * return current attached WifiPhy device + * \return currently attached WifiPhy device */ virtual Ptr GetWifiPhy (void) const = 0; /** - * remove current attached WifiPhy device from this MAC. + * remove currently attached WifiPhy device from this MAC. */ virtual void ResetWifiPhy (void) = 0; /** diff --git a/src/wifi/model/wifi-mode.h b/src/wifi/model/wifi-mode.h index 628050e5b0e..e97aec095a1 100644 --- a/src/wifi/model/wifi-mode.h +++ b/src/wifi/model/wifi-mode.h @@ -222,7 +222,9 @@ class WifiMode private: + /// allow WifiModeFactory class access friend class WifiModeFactory; + /// allow WifiPhyTag class access friend class WifiPhyTag; // access the UID-based constructor /** * Create a WifiMode from a given unique ID. @@ -299,6 +301,7 @@ class WifiModeFactory private: + /// allow WifiMode class access friend class WifiMode; friend std::istream & operator >> (std::istream &is, WifiMode &mode); diff --git a/src/wifi/model/wifi-remote-station-manager.h b/src/wifi/model/wifi-remote-station-manager.h index bd25f7327f0..fb31579a880 100644 --- a/src/wifi/model/wifi-remote-station-manager.h +++ b/src/wifi/model/wifi-remote-station-manager.h @@ -57,7 +57,10 @@ class WifiRemoteStationInfo void NotifyTxSuccess (uint32_t retryCounter); /// Updates average frame error rate when final data or RTS has failed. void NotifyTxFailed (); - /// Return frame error rate (probability that frame is corrupted due to transmission error). + /** + * Return frame error rate (probability that frame is corrupted due to transmission error). + * \returns the frame error rate + */ double GetFrameErrorRate () const; private: /** diff --git a/src/wifi/model/wifi-spectrum-signal-parameters.h b/src/wifi/model/wifi-spectrum-signal-parameters.h index a523ba185fc..fc99ba9c616 100644 --- a/src/wifi/model/wifi-spectrum-signal-parameters.h +++ b/src/wifi/model/wifi-spectrum-signal-parameters.h @@ -46,6 +46,8 @@ struct WifiSpectrumSignalParameters : public SpectrumSignalParameters /** * copy constructor + * + * \param p the wifi spectrum signal parameters */ WifiSpectrumSignalParameters (const WifiSpectrumSignalParameters& p); diff --git a/src/wifi/test/dcf-manager-test.cc b/src/wifi/test/dcf-manager-test.cc index 1a8afe29d06..f4ddeabac55 100644 --- a/src/wifi/test/dcf-manager-test.cc +++ b/src/wifi/test/dcf-manager-test.cc @@ -52,6 +52,7 @@ class DcfStateTest : public DcfState private: + /// allow DcfManagerTest class access friend class DcfManagerTest; typedef std::pair ExpectedGrant; //!< the expected grant typedef From b47735c64957600fd4038f5821e8c2dfe741bfad Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sun, 20 Aug 2017 20:39:57 -0700 Subject: [PATCH 223/551] dsdv: Fix Doxygen warnings --- src/dsdv/examples/dsdv-manet.cc | 87 ++++++++++---- src/dsdv/model/dsdv-packet-queue.cc | 10 +- src/dsdv/model/dsdv-packet-queue.h | 130 +++++++++++++++++++-- src/dsdv/model/dsdv-packet.cc | 2 +- src/dsdv/model/dsdv-packet.h | 35 ++++++ src/dsdv/model/dsdv-routing-protocol.cc | 17 ++- src/dsdv/model/dsdv-routing-protocol.h | 94 ++++++++++++--- src/dsdv/model/dsdv-rtable.cc | 2 +- src/dsdv/model/dsdv-rtable.h | 148 ++++++++++++++++++++++-- src/dsdv/test/dsdv-testcase.cc | 27 ++++- 10 files changed, 481 insertions(+), 71 deletions(-) diff --git a/src/dsdv/examples/dsdv-manet.cc b/src/dsdv/examples/dsdv-manet.cc index 0254754bca5..ec14f625049 100644 --- a/src/dsdv/examples/dsdv-manet.cc +++ b/src/dsdv/examples/dsdv-manet.cc @@ -45,10 +45,31 @@ uint16_t port = 9; NS_LOG_COMPONENT_DEFINE ("DsdvManetExample"); +/** + * \ingroup dsdv + * \ingroup dsdv-examples + * \ingroup examples + * + * \brief DSDV Manet example + */ class DsdvManetExample { public: DsdvManetExample (); + /** + * Run function + * \param nWifis The total number of nodes + * \param nSinks The total number of receivers + * \param totalTime The total simulation time + * \param rate The network speed + * \param phyMode The physical mode + * \param nodeSpeed The node speed + * \param periodicUpdateInterval The routing update interval + * \param settlingTime The routing update settling time + * \param dataStart The data transmission start time + * \param printRoutes print the routes if true + * \param CSVfileName The CSV file name + */ void CaseRun (uint32_t nWifis, uint32_t nSinks, double totalTime, @@ -62,32 +83,54 @@ class DsdvManetExample std::string CSVfileName); private: - uint32_t m_nWifis; - uint32_t m_nSinks; - double m_totalTime; - std::string m_rate; - std::string m_phyMode; - uint32_t m_nodeSpeed; - uint32_t m_periodicUpdateInterval; - uint32_t m_settlingTime; - double m_dataStart; - uint32_t bytesTotal; - uint32_t packetsReceived; - bool m_printRoutes; - std::string m_CSVfileName; - - NodeContainer nodes; - NetDeviceContainer devices; - Ipv4InterfaceContainer interfaces; + uint32_t m_nWifis; ///< total number of nodes + uint32_t m_nSinks; ///< number of receiver nodes + double m_totalTime; ///< total simulation time (in seconds) + std::string m_rate; ///< network bandwidth + std::string m_phyMode; ///< remote station manager data mode + uint32_t m_nodeSpeed; ///< mobility speed + uint32_t m_periodicUpdateInterval; ///< routing update interval + uint32_t m_settlingTime; ///< routing setting time + double m_dataStart; ///< time to start data transmissions (seconds) + uint32_t bytesTotal; ///< total bytes received by all nodes + uint32_t packetsReceived; ///< total packets received by all nodes + bool m_printRoutes; ///< print routing table + std::string m_CSVfileName; ///< CSV file name + + NodeContainer nodes; ///< the collection of nodes + NetDeviceContainer devices; ///< the collection of devices + Ipv4InterfaceContainer interfaces; ///< the collection of interfaces private: + /// Create and initialize all nodes void CreateNodes (); + /** + * Create and initialize all devices + * \param tr_name The trace file name + */ void CreateDevices (std::string tr_name); + /** + * Create network + * \param tr_name The trace file name + */ void InstallInternetStack (std::string tr_name); + /// Create data sinks and sources void InstallApplications (); + /// Setup mobility model void SetupMobility (); - void ReceivePacket (Ptr ); - Ptr SetupPacketReceive (Ipv4Address, Ptr ); + /** + * Packet receive function + * \param socket The communication socket + */ + void ReceivePacket (Ptr socket); + /** + * Setup packet receivers + * \param addr the receiving IPv4 address + * \param node the receiving node + * \returns the communication socket + */ + Ptr SetupPacketReceive (Ipv4Address addr, Ptr node ); + /// Check network throughput void CheckThroughput (); }; @@ -252,11 +295,11 @@ DsdvManetExample::SetupMobility () std::ostringstream speedConstantRandomVariableStream; speedConstantRandomVariableStream << "ns3::ConstantRandomVariable[Constant=" - << m_nodeSpeed - << "]"; + << m_nodeSpeed + << "]"; Ptr taPositionAlloc = pos.Create ()->GetObject (); - mobility.SetMobilityModel ("ns3::RandomWaypointMobilityModel", "Speed", StringValue (speedConstantRandomVariableStream.str ()), + mobility.SetMobilityModel ("ns3::RandomWaypointMobilityModel", "Speed", StringValue (speedConstantRandomVariableStream.str ()), "Pause", StringValue ("ns3::ConstantRandomVariable[Constant=2.0]"), "PositionAllocator", PointerValue (taPositionAlloc)); mobility.SetPositionAllocator (taPositionAlloc); mobility.Install (nodes); diff --git a/src/dsdv/model/dsdv-packet-queue.cc b/src/dsdv/model/dsdv-packet-queue.cc index ae2b9462cb3..df7da03ea41 100644 --- a/src/dsdv/model/dsdv-packet-queue.cc +++ b/src/dsdv/model/dsdv-packet-queue.cc @@ -38,7 +38,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsdvPacketQueue"); - + namespace dsdv { uint32_t PacketQueue::GetSize () @@ -144,8 +144,16 @@ PacketQueue::GetCountForPacketsWithDst (Ipv4Address dst) return count; } +/** + * IsExpired structure + */ struct IsExpired { + /** + * \brief Check for expired entry + * \param e QueueEntry to check + * \return true if expired + */ bool operator() (QueueEntry const & e) const { diff --git a/src/dsdv/model/dsdv-packet-queue.h b/src/dsdv/model/dsdv-packet-queue.h index bbbbea58489..6a42d48c347 100644 --- a/src/dsdv/model/dsdv-packet-queue.h +++ b/src/dsdv/model/dsdv-packet-queue.h @@ -45,9 +45,18 @@ namespace dsdv { class QueueEntry { public: + /// Unicast forward call back function typedef typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback; + /// Error callback function typedef typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback; - /// c-tor + /** + * c-tor + * + * \param pa the packet to create the entry + * \param h the Ipv4Header + * \param ucb the UnicastForwardCallback function + * \param ecb the ErrorCallback function + */ QueueEntry (Ptr pa = 0, Ipv4Header const & h = Ipv4Header (), UnicastForwardCallback ucb = UnicastForwardCallback (), ErrorCallback ecb = ErrorCallback ()) @@ -61,50 +70,91 @@ class QueueEntry /** * Compare queue entries + * \param o QueueEntry to compare * \return true if equal */ bool operator== (QueueEntry const & o) const { return ((m_packet == o.m_packet) && (m_header.GetDestination () == o.m_header.GetDestination ()) && (m_expire == o.m_expire)); } - + // Fields + /** + * Get unicast forward callback function + * \returns the unicast forward callback + */ UnicastForwardCallback GetUnicastForwardCallback () const { return m_ucb; } + /** + * Set unicast forward callback function + * \param ucb the unicast forward callback + */ void SetUnicastForwardCallback (UnicastForwardCallback ucb) { m_ucb = ucb; } + /** + * Get error callback function + * \returns the error callback + */ ErrorCallback GetErrorCallback () const { return m_ecb; } + /** + * Set error callback function + * \param ecb the error callback + */ void SetErrorCallback (ErrorCallback ecb) { m_ecb = ecb; } + /** + * Get packet + * \returns the current packet + */ Ptr GetPacket () const { return m_packet; } + /** + * Set packet + * \param p The current packet + */ void SetPacket (Ptr p) { m_packet = p; } + /** + * Get IP header + * \returns the IPv4 header + */ Ipv4Header GetIpv4Header () const { return m_header; } + /** + * Set IP header + * \param h The IPv4 header + */ void SetIpv4Header (Ipv4Header h) { m_header = h; } + /** + * Set expire time + * \param exp + */ void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); } + /** + * Get expire time + * \returns the expire time + */ Time GetExpireTime () const { return m_expire - Simulator::Now (); @@ -137,51 +187,103 @@ class PacketQueue PacketQueue () { } - /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + /** + * Push entry in queue, if there is no entry with the same packet and destination address in queue. + * \param entry QueueEntry to compare + * \return true if successful + */ bool Enqueue (QueueEntry & entry); - /// Return first found (the earliest) entry for given destination + /** + * Return first found (the earliest) entry for given destination + * + * \param dst the destination IP address + * \param entry the queue entry + * \returns true if successful + */ bool Dequeue (Ipv4Address dst, QueueEntry & entry); - /// Remove all packets with destination IP address dst + /** + * Remove all packets with destination IP address dst + * \param dst the destination IP address + */ void DropPacketWithDst (Ipv4Address dst); - /// Finds whether a packet with destination dst exists in the queue + /** + * Finds whether a packet with destination dst exists in the queue + * \param dst the destination IP address + * \returns true if a packet found + */ bool Find (Ipv4Address dst); - /// Get count of packets with destination dst in the queue + /** + * Get count of packets with destination dst in the queue + * \param dst the destination IP address + * \returns the count + */ uint32_t GetCountForPacketsWithDst (Ipv4Address dst); - /// Number of entries + /** + * Get the number of entries + * \returns the number of entries + */ uint32_t GetSize (); - + // Fields + /** + * Get maximum queue length + * \returns the maximum queue length + */ uint32_t GetMaxQueueLen () const { return m_maxLen; } + /** + * Set maximum queue length + * \param len the maximum queue length + */ void SetMaxQueueLen (uint32_t len) { m_maxLen = len; } + /** + * Get maximum packets per destination + * \returns the maximum packets per destination + */ uint32_t GetMaxPacketsPerDst () const { return m_maxLenPerDst; } + /** + * Set maximum packets per destination + * \param len The maximum packets per destination + */ void SetMaxPacketsPerDst (uint32_t len) { m_maxLenPerDst = len; } + /** + * Get queue timeout + * \returns the queue timeout + */ Time GetQueueTimeout () const { return m_queueTimeout; } + /** + * Set queue timeout + * \param t The queue timeout + */ void SetQueueTimeout (Time t) { m_queueTimeout = t; } private: - std::vector m_queue; + std::vector m_queue; ///< the queue /// Remove all expired entries void Purge (); - /// Notify that packet is dropped from queue by timeout + /** + * Notify that the packet is dropped from queue due to timeout + * \param en the queue entry + * \param reason the reason for the packet drop + */ void Drop (QueueEntry en, std::string reason); /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; @@ -189,6 +291,12 @@ class PacketQueue uint32_t m_maxLenPerDst; /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds. Time m_queueTimeout; + /** + * Determine if queue entries are equal + * \param en the queue entry + * \param dst the IPv4 destination address + * \returns true if the entry is for the destination address + */ static bool IsEqual (QueueEntry en, const Ipv4Address dst) { return (en.GetIpv4Header ().GetDestination () == dst); diff --git a/src/dsdv/model/dsdv-packet.cc b/src/dsdv/model/dsdv-packet.cc index 9da19729de7..398ace0690d 100644 --- a/src/dsdv/model/dsdv-packet.cc +++ b/src/dsdv/model/dsdv-packet.cc @@ -36,7 +36,7 @@ namespace ns3 { namespace dsdv { NS_OBJECT_ENSURE_REGISTERED (DsdvHeader); - + DsdvHeader::DsdvHeader (Ipv4Address dst, uint32_t hopCount, uint32_t dstSeqNo) : m_dst (dst), m_hopCount (hopCount), diff --git a/src/dsdv/model/dsdv-packet.h b/src/dsdv/model/dsdv-packet.h index 932304d4e20..a7c345007eb 100644 --- a/src/dsdv/model/dsdv-packet.h +++ b/src/dsdv/model/dsdv-packet.h @@ -58,8 +58,19 @@ namespace dsdv { class DsdvHeader : public Header { public: + /** + * Constructor + * + * \param dst destination IP address + * \param hopcount hop count + * \param dstSeqNo destination sequence number + */ DsdvHeader (Ipv4Address dst = Ipv4Address (), uint32_t hopcount = 0, uint32_t dstSeqNo = 0); virtual ~DsdvHeader (); + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (void); virtual TypeId GetInstanceTypeId (void) const; virtual uint32_t GetSerializedSize () const; @@ -67,31 +78,55 @@ class DsdvHeader : public Header virtual uint32_t Deserialize (Buffer::Iterator start); virtual void Print (std::ostream &os) const; + /** + * Set destination address + * \param destination the destination IPv4 address + */ void SetDst (Ipv4Address destination) { m_dst = destination; } + /** + * Get destination address + * \returns the destination IPv4 address + */ Ipv4Address GetDst () const { return m_dst; } + /** + * Set hop count + * \param hopCount the hop count + */ void SetHopCount (uint32_t hopCount) { m_hopCount = hopCount; } + /** + * Get hop count + * \returns the hop count + */ uint32_t GetHopCount () const { return m_hopCount; } + /** + * Set destination sequence number + * \param sequenceNumber The sequence number + */ void SetDstSeqno (uint32_t sequenceNumber) { m_dstSeqNo = sequenceNumber; } + /** + * Get destination sequence number + * \returns the destination sequence number + */ uint32_t GetDstSeqno () const { diff --git a/src/dsdv/model/dsdv-routing-protocol.cc b/src/dsdv/model/dsdv-routing-protocol.cc index 980f24ba31a..dac2e2d51d5 100644 --- a/src/dsdv/model/dsdv-routing-protocol.cc +++ b/src/dsdv/model/dsdv-routing-protocol.cc @@ -43,9 +43,9 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsdvRoutingProtocol"); - + namespace dsdv { - + NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol); /// UDP Port for DSDV control traffic @@ -57,12 +57,21 @@ struct DeferredRouteOutputTag : public Tag /// Positive if output device is fixed in RouteOutput int32_t oif; + /** + * Constructor + * + * \param o outgoing interface (OIF) + */ DeferredRouteOutputTag (int32_t o = -1) : Tag (), oif (o) { } + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId () { @@ -70,7 +79,7 @@ struct DeferredRouteOutputTag : public Tag .SetParent () .SetGroupName ("Dsdv") .AddConstructor () - ; + ; return tid; } @@ -232,7 +241,7 @@ void RoutingProtocol::PrintRoutingTable (Ptr stream, Time::Unit unit) const { *stream->GetStream () << "Node: " << m_ipv4->GetObject ()->GetId () - << ", Time: " << Now().As (unit) + << ", Time: " << Now ().As (unit) << ", Local time: " << GetObject ()->GetLocalTime ().As (unit) << ", DSDV Routing table" << std::endl; diff --git a/src/dsdv/model/dsdv-routing-protocol.h b/src/dsdv/model/dsdv-routing-protocol.h index c15f077a961..40af8228c4c 100644 --- a/src/dsdv/model/dsdv-routing-protocol.h +++ b/src/dsdv/model/dsdv-routing-protocol.h @@ -53,8 +53,11 @@ namespace dsdv { class RoutingProtocol : public Ipv4RoutingProtocol { public: - static TypeId - GetTypeId (void); + /** + * \brief Get the type ID. + * \return the object TypeId + */ + static TypeId GetTypeId (void); static const uint32_t DSDV_PORT; /// c-tor @@ -66,6 +69,17 @@ class RoutingProtocol : public Ipv4RoutingProtocol // From Ipv4RoutingProtocol Ptr RouteOutput (Ptr p, const Ipv4Header &header, Ptr oif, Socket::SocketErrno &sockerr); + /** + * Route input packet + * \param p The packet + * \param header The IPv4 header + * \param idev The device + * \param ucb The unicast forward callback + * \param mcb The multicast forward callback + * \param lcb The local deliver callback + * \param ecb The error callback + * \returns true if successful + */ bool RouteInput (Ptr p, const Ipv4Header &header, Ptr idev, UnicastForwardCallback ucb, MulticastForwardCallback mcb, LocalDeliverCallback lcb, ErrorCallback ecb); virtual void PrintRoutingTable (Ptr stream, Time::Unit unit = Time::S) const; @@ -76,25 +90,48 @@ class RoutingProtocol : public Ipv4RoutingProtocol virtual void SetIpv4 (Ptr ipv4); // Methods to handle protocol parameters + /** + * Set enable buffer flag + * \param f The enable buffer flag + */ void SetEnableBufferFlag (bool f); + /** + * Get enable buffer flag + * \returns the enable buffer flag + */ bool GetEnableBufferFlag () const; + /** + * Set weighted settling time (WST) flag + * \param f the weighted settling time (WST) flag + */ void SetWSTFlag (bool f); + /** + * Get weighted settling time (WST) flag + * \returns the weighted settling time (WST) flag + */ bool GetWSTFlag () const; + /** + * Set enable route aggregation (RA) flag + * \param f the enable route aggregation (RA) flag + */ void SetEnableRAFlag (bool f); + /** + * Get enable route aggregation (RA) flag + * \returns the enable route aggregation (RA) flag + */ bool GetEnableRAFlag () const; - /** - * Assign a fixed random variable stream number to the random variables - * used by this model. Return the number of streams (possibly zero) that - * have been assigned. - * - * \param stream first stream index to use - * \return the number of stream indices assigned by this model - */ + /** + * Assign a fixed random variable stream number to the random variables + * used by this model. Return the number of streams (possibly zero) that + * have been assigned. + * + * \param stream first stream index to use + * \return the number of stream indices assigned by this model + */ int64_t AssignStreams (int64_t stream); private: - // Protocol parameters. /// Holdtimes is the multiplicative factor of PeriodicUpdateInterval for which the node waits since the last update /// before flushing a route from the routing table. If PeriodicUpdateInterval is 8s and Holdtimes is 3, the node @@ -143,11 +180,16 @@ class RoutingProtocol : public Ipv4RoutingProtocol ErrorCallback m_ecb; private: - /// Start protocol operation void Start (); - /// Queue packet untill we find a route + /** + * Queue packet until we find a route + * \param p the packet to route + * \param header the Ipv4Header + * \param ucb the UnicastForwardCallback function + * \param ecb the ErrorCallback function + */ void DeferredRouteOutput (Ptr p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb); /// Look for any queued packets to send them out @@ -160,18 +202,31 @@ class RoutingProtocol : public Ipv4RoutingProtocol */ void SendPacketFromQueue (Ipv4Address dst, Ptr route); - /// Find socket with local interface address iface + /** + * Find socket with local interface address iface + * \param iface the interface + * \returns the socket + */ Ptr FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const; - + // Receive dsdv control packets - /// Receive and process dsdv control packet + /** + * Receive and process dsdv control packet + * \param socket the socket for receiving dsdv control packets + */ void RecvDsdv (Ptr socket); - + /// Send packet void Send (Ptr, Ptr, const Ipv4Header &); - /// Create loopback route for given header + /** + * Create loopback route for given header + * + * \param header the IP header + * \param oif the device + * \returns the route + */ Ptr LoopbackRoute (const Ipv4Header & header, Ptr oif) const; /** @@ -187,6 +242,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol /// Broadcasts the entire routing table for every PeriodicUpdateInterval void SendPeriodicUpdate (); + /// Merge periodic updates void MergeTriggerPeriodicUpdates (); /// Notify that packet is dropped for some reason @@ -198,7 +254,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol Timer m_triggeredExpireTimer; /// Provides uniform random variables. - Ptr m_uniformRandomVariable; + Ptr m_uniformRandomVariable; }; } diff --git a/src/dsdv/model/dsdv-rtable.cc b/src/dsdv/model/dsdv-rtable.cc index fd92aacc2c0..31436c24d7f 100644 --- a/src/dsdv/model/dsdv-rtable.cc +++ b/src/dsdv/model/dsdv-rtable.cc @@ -36,7 +36,7 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("DsdvRoutingTable"); - + namespace dsdv { RoutingTableEntry::RoutingTableEntry (Ptr dev, Ipv4Address dst, diff --git a/src/dsdv/model/dsdv-rtable.h b/src/dsdv/model/dsdv-rtable.h index 04292cd680c..21a367469fc 100644 --- a/src/dsdv/model/dsdv-rtable.h +++ b/src/dsdv/model/dsdv-rtable.h @@ -56,112 +56,208 @@ enum RouteFlags class RoutingTableEntry { public: - /// c-tor - RoutingTableEntry (Ptr dev = 0, Ipv4Address dst = Ipv4Address (), uint32_t m_seqNo = 0, + /** + * c-tor + * + * \param dev the net device + * \param dst the destination IP address + * \param seqNo the sequence number + * \param iface the interface + * \param hops the number of hops + * \param nextHop the IP address of the next hop + * \param lifetime the lifetime + * \param SettlingTime the settling time + * \param changedEntries flag for changed entries + */ + RoutingTableEntry (Ptr dev = 0, Ipv4Address dst = Ipv4Address (), uint32_t seqNo = 0, Ipv4InterfaceAddress iface = Ipv4InterfaceAddress (), uint32_t hops = 0, Ipv4Address nextHop = Ipv4Address (), Time lifetime = Simulator::Now (), Time SettlingTime = Simulator::Now (), bool changedEntries = false); ~RoutingTableEntry (); + /** + * Get destination IP address + * \returns the destination IPv4 address + */ Ipv4Address GetDestination () const { return m_ipv4Route->GetDestination (); } + /** + * Get route + * \returns the IPv4 route + */ Ptr GetRoute () const { return m_ipv4Route; } + /** + * Set route + * \param route the IPv4 route + */ void SetRoute (Ptr route) { m_ipv4Route = route; } + /** + * Set next hop + * \param nextHop the IPv4 address of the next hop + */ void SetNextHop (Ipv4Address nextHop) { m_ipv4Route->SetGateway (nextHop); } + /** + * Get next hop + * \returns the IPv4 address of the next hop + */ Ipv4Address GetNextHop () const { return m_ipv4Route->GetGateway (); } + /** + * Set output device + * \param device the output device + */ void SetOutputDevice (Ptr device) { m_ipv4Route->SetOutputDevice (device); } + /** + * Get output device + * \returns the output device + */ Ptr GetOutputDevice () const { return m_ipv4Route->GetOutputDevice (); } + /** + * Get interface address + * \returns the IPv4 interface address + */ Ipv4InterfaceAddress GetInterface () const { return m_iface; } + /** + * Set interface address + * \param iface the IPv4 interface address + */ void SetInterface (Ipv4InterfaceAddress iface) { m_iface = iface; } + /** + * Set sequence number + * \param sequenceNumber the sequence number + */ void SetSeqNo (uint32_t sequenceNumber) { m_seqNo = sequenceNumber; } + /** + * Get sequence number + * \returns the sequence number + */ uint32_t GetSeqNo () const { return m_seqNo; } + /** + * Set hop + * \param hopCount the hop count + */ void SetHop (uint32_t hopCount) { m_hops = hopCount; } + /** + * Get hop + * \returns the hop count + */ uint32_t GetHop () const { return m_hops; } + /** + * Set lifetime + * \param lifeTime the lifetime value + */ void SetLifeTime (Time lifeTime) { m_lifeTime = lifeTime; } + /** + * Get lifetime + * \returns the lifetime value + */ Time GetLifeTime () const { return (Simulator::Now () - m_lifeTime); } + /** + * Set settling time + * \param settlingTime the settling time + */ void SetSettlingTime (Time settlingTime) { m_settlingTime = settlingTime; } + /** + * Get settling time + * \returns the settling time + */ Time GetSettlingTime () const { return (m_settlingTime); } + /** + * Set route flags + * \param flag the route flags + */ void SetFlag (RouteFlags flag) { m_flag = flag; } + /** + * Get route flags + * \returns the route flags + */ RouteFlags GetFlag () const { return m_flag; } + /** + * Set entries changed indicator + * \param entriesChanged + */ void SetEntriesChanged (bool entriesChanged) { m_entriesChanged = entriesChanged; } + /** + * Get entries changed + * \returns the entries changed flag + */ bool GetEntriesChanged () const { @@ -169,6 +265,7 @@ class RoutingTableEntry } /** * \brief Compare destination address + * \param destination destination node IP address * \return true if equal */ bool @@ -176,11 +273,14 @@ class RoutingTableEntry { return (m_ipv4Route->GetDestination () == destination); } + /** + * Print routing table entry + * \param stream the output stream + */ void Print (Ptr stream) const; private: - // Fields /// Destination Sequence Number uint32_t m_seqNo; @@ -243,6 +343,13 @@ class RoutingTable */ bool LookupRoute (Ipv4Address dst, RoutingTableEntry & rt); + /** + * Lookup routing table entry with destination address dst + * \param id destination address + * \param rt entry with destination address dst, if exists + * \param forRouteInput for routing input + * \return true on success + */ bool LookupRoute (Ipv4Address id, RoutingTableEntry & rt, bool forRouteInput); /** @@ -265,7 +372,10 @@ class RoutingTable */ void GetListOfAllRoutes (std::map & allRoutes); - /// Delete all route from interface with address iface + /** + * Delete all route from interface with address iface + * \param iface the interface + */ void DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface); /// Delete all entries from routing table @@ -274,13 +384,22 @@ class RoutingTable { m_ipv4AddressEntry.clear (); } - /// Delete all outdated entries if Lifetime is expired + /** + * Delete all outdated entries if Lifetime is expired + * \param removedAddresses is the list of addresses to purge + */ void Purge (std::map & removedAddresses); - /// Print routing table + /** + * Print routing table + * \param stream the output stream + */ void Print (Ptr stream) const; - /// Provides the number of routes present in that nodes routing table. + /** + * Provides the number of routes present in that nodes routing table. + * \returns the number of routes + */ uint32_t RoutingTableSize (); /** @@ -288,6 +407,7 @@ class RoutingTable * after the event is completed. * \param address destination address for which this event is running. * \param id unique eventid that was generated. + * \return true on success */ bool AddIpv4Event (Ipv4Address address, EventId id); @@ -321,25 +441,31 @@ class RoutingTable */ EventId GetEventId (Ipv4Address address); - - // Handle life time of invalid route + + /** + * Get hold down time (time until an invalid route may be deleted) + * \returns the hold down time + */ Time Getholddowntime () const { return m_holddownTime; } + /** + * Set hold down time (time until an invalid route may be deleted) + * \param t the hold down time + */ void Setholddowntime (Time t) { m_holddownTime = t; } private: - // Fields /// an entry in the routing table. std::map m_ipv4AddressEntry; /// an entry in the event table. std::map m_ipv4Events; - /// + /// hold down time of an expired route Time m_holddownTime; }; diff --git a/src/dsdv/test/dsdv-testcase.cc b/src/dsdv/test/dsdv-testcase.cc index f04805ce87b..cc43e4d9260 100644 --- a/src/dsdv/test/dsdv-testcase.cc +++ b/src/dsdv/test/dsdv-testcase.cc @@ -48,6 +48,19 @@ using namespace ns3; +/** + * \ingroup dsdv-test + * \defgroup dsdv-test DSDV module tests + */ + + +/** + * \ingroup dsdv-test + * \ingroup tests + * + * \brief DSDV test case to verify the DSDV header + * + */ class DsdvHeaderTestCase : public TestCase { public: @@ -98,6 +111,12 @@ DsdvHeaderTestCase::DoRun () } } +/** + * \ingroup dsdv-test + * \ingroup tests + * + * \brief DSDV routing table tests (adding and looking up routes) + */ class DsdvTableTestCase : public TestCase { public: @@ -184,6 +203,12 @@ DsdvTableTestCase::DoRun () Simulator::Destroy (); } +/** + * \ingroup dsdv-test + * \ingroup tests + * + * \brief DSDV test suite + */ class DsdvTestSuite : public TestSuite { public: @@ -192,4 +217,4 @@ class DsdvTestSuite : public TestSuite AddTestCase (new DsdvHeaderTestCase (), TestCase::QUICK); AddTestCase (new DsdvTableTestCase (), TestCase::QUICK); } -} g_dsdvTestSuite; +} g_dsdvTestSuite; ///< the test suite From f4d433a5eae597f1b32c14c0a8ab9539e70f7476 Mon Sep 17 00:00:00 2001 From: Akin Soysal Date: Mon, 21 Aug 2017 11:31:00 +0300 Subject: [PATCH 224/551] wifi: (fixes #2776) Fix segfault in MacLow --- AUTHORS | 1 + src/wifi/model/mac-low.cc | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/AUTHORS b/AUTHORS index 7799cc7b412..75e1363e436 100644 --- a/AUTHORS +++ b/AUTHORS @@ -173,6 +173,7 @@ Phillip Sitbon (phillip.sitbon@gmail.com) Pedro Silva (pmms@inesctec.pt) Anirudh Sivaraman (sk.anirudh@gmail.com) Steven Smith (smith84@llnl.gov) +Akin Soysal (akinsoysal@gmail.com) Andrew Stanton (acstanton515@gmail.com) Ewgenij Starostin (estar@cs.tu-berlin.de) YunQiang Su (wzssyqa@gmail.com) diff --git a/src/wifi/model/mac-low.cc b/src/wifi/model/mac-low.cc index 7b501b517dd..9ce319d25cb 100644 --- a/src/wifi/model/mac-low.cc +++ b/src/wifi/model/mac-low.cc @@ -650,8 +650,8 @@ MacLow::StartTransmission (Ptr packet, SocketPriorityTag priorityTag; m_currentPacket->RemovePacketTag (priorityTag); m_currentHdr = *hdr; - m_currentDca = dca; CancelAllEvents (); + m_currentDca = dca; m_txParams = params; m_currentTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr); From b68a27364c8ca14a7763d7dfc5cb1ed46a498b4d Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Tue, 29 Aug 2017 14:51:27 -0700 Subject: [PATCH 225/551] wifi: Extend documentation helper for attribute implementations --- utils/print-introspected-doxygen.cc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/utils/print-introspected-doxygen.cc b/utils/print-introspected-doxygen.cc index afa63e2fb28..29a75a1a9c8 100644 --- a/utils/print-introspected-doxygen.cc +++ b/utils/print-introspected-doxygen.cc @@ -878,6 +878,14 @@ PrintAttributeImplementations (std::ostream & os) { "Address", "Address", true, "address.h" }, { "Box", "Box", true, "box.h" }, { "DataRate", "DataRate", true, "data-rate.h" }, + { "DsssParameterSet", + "DsssParameterSet", + true, "dsss-parameter-set.h"}, + { "EdcaParameterSet", + "EdcaParameterSet", + true, "edca-parameter-set.h"}, + { "ErpInformation", "ErpInformation", true, "erp-information.h" }, + { "HeCapabilities", "HeCapabilities", true, "he-capabilities.h" }, { "HtCapabilities", "HtCapabilities", true, "ht-capabilities.h" }, { "IeMeshId", "IeMeshId", true, "ie-dot11s-id.h" }, { "Ipv4Address", "Ipv4Address", true, "ipv4-address.h" }, @@ -898,6 +906,8 @@ PrintAttributeImplementations (std::ostream & os) { "ValueClassTest", "ValueClassTest", false, "" /* outside ns3 */ }, { "Vector2D", "Vector2D", true, "vector.h" }, { "Vector3D", "Vector3D", true, "vector.h" }, + { "VhtCapabilities","VhtCapabilities",true, "vht-capabilities.h" }, + { "VhtOperation", "VhtOperation", true, "vht-operation.h" }, { "Waypoint", "Waypoint", true, "waypoint.h" }, { "WifiMode", "WifiMode", true, "wifi-mode.h" }, From 2e4d8236357b61d04ecfe3fb3a1445f3cb78cedf Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Tue, 29 Aug 2017 14:56:00 -0700 Subject: [PATCH 226/551] uan: Doxygen update for recent change --- src/uan/model/uan-transducer.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/uan/model/uan-transducer.h b/src/uan/model/uan-transducer.h index 51da32e38ad..780eefa9543 100644 --- a/src/uan/model/uan-transducer.h +++ b/src/uan/model/uan-transducer.h @@ -195,6 +195,8 @@ class UanTransducer : public Object virtual double GetRxGainDb (void) = 0; /** * Apply receiver gain in dB to the received power. + * \param rxPowerDb Signal power in dB of arriving packet. + * \param mode Mode arriving packet is using. * * \return Updated receive power (in dB) with gain applied. */ From de237474ebcf6bb64c8f94c0d6302ca366aff3a3 Mon Sep 17 00:00:00 2001 From: Zoraze Ali Date: Wed, 30 Aug 2017 11:13:13 +0200 Subject: [PATCH 227/551] lte: (fixes #2777) save bearer info in m_drbMap, needed for handover request --- src/lte/model/lte-enb-rrc.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lte/model/lte-enb-rrc.cc b/src/lte/model/lte-enb-rrc.cc index ffd8a1ddba6..dca7d269728 100644 --- a/src/lte/model/lte-enb-rrc.cc +++ b/src/lte/model/lte-enb-rrc.cc @@ -371,6 +371,7 @@ UeManager::SetupDataRadioBearer (EpsBearer bearer, uint8_t bearerId, uint32_t gt uint8_t lcid = Drbid2Lcid (drbid); uint8_t bid = Drbid2Bid (drbid); NS_ASSERT_MSG ( bearerId == 0 || bid == bearerId, "bearer ID mismatch (" << (uint32_t) bid << " != " << (uint32_t) bearerId << ", the assumption that ID are allocated in the same way by MME and RRC is not valid any more"); + drbInfo->m_epsBearer = bearer; drbInfo->m_epsBearerIdentity = bid; drbInfo->m_drbIdentity = drbid; drbInfo->m_logicalChannelIdentity = lcid; From 5fcca3808fe8136c68db11dcf52e6920aea90f55 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Wed, 30 Aug 2017 08:38:06 -0700 Subject: [PATCH 228/551] aodv: Fix doxygen warnings --- src/aodv/examples/aodv.cc | 5 +- src/aodv/model/aodv-dpd.h | 26 +++++++-- src/aodv/model/aodv-id-cache.h | 26 +++++++-- src/aodv/model/aodv-neighbor.h | 61 ++++++++++++++----- src/aodv/model/aodv-packet.h | 56 ++++++++++++++---- src/aodv/model/aodv-routing-protocol.h | 71 ++++++++++++++++++---- src/aodv/model/aodv-rqueue.h | 53 ++++++++++++++--- src/aodv/model/aodv-rtable.h | 81 ++++++++++++++++++++------ src/aodv/test/bug-772.h | 5 +- 9 files changed, 311 insertions(+), 73 deletions(-) diff --git a/src/aodv/examples/aodv.cc b/src/aodv/examples/aodv.cc index b73b5204d1a..f8daca458d9 100644 --- a/src/aodv/examples/aodv.cc +++ b/src/aodv/examples/aodv.cc @@ -57,7 +57,10 @@ class AodvExample bool Configure (int argc, char **argv); /// Run simulation void Run (); - /// Report results + /** + * Report results + * \param os the output stream + */ void Report (std::ostream & os); private: diff --git a/src/aodv/model/aodv-dpd.h b/src/aodv/model/aodv-dpd.h index d91a18a4685..6a5d8a62e76 100644 --- a/src/aodv/model/aodv-dpd.h +++ b/src/aodv/model/aodv-dpd.h @@ -35,21 +35,35 @@ namespace aodv { * * \brief Helper class used to remember already seen packets and detect duplicates. * - * Currently duplicate detection is based on uinique packet ID given by Packet::GetUid () - * This approach is known to be weak and should be changed. + * Currently duplicate detection is based on unique packet ID given by Packet::GetUid () + * This approach is known to be weak (ns3::Packet UID is an internal identifier and not intended for logical uniqueness in models) and should be changed. */ class DuplicatePacketDetection { public: - /// C-tor + /** + * Constructor + * \param lifetime the lifetime for added entries + */ DuplicatePacketDetection (Time lifetime) : m_idCache (lifetime) { } - /// Check that the packet is duplicated. If not, save information about this packet. + /** + * Check if the packet is a duplicate. If not, save information about this packet. + * \param p the packet to check + * \param header the IP header to check + * \returns true if duplicate + */ bool IsDuplicate (Ptr p, const Ipv4Header & header); - /// Set duplicate records lifetimes + /** + * Set duplicate record lifetime + * \param lifetime the lifetime for duplicate records + */ void SetLifetime (Time lifetime); - /// Get duplicate records lifetimes + /** + * Get duplicate record lifetime + * \returns the duplicate record lifetime + */ Time GetLifetime () const; private: /// Impl diff --git a/src/aodv/model/aodv-id-cache.h b/src/aodv/model/aodv-id-cache.h index 863b23bacd5..4f659222b88 100644 --- a/src/aodv/model/aodv-id-cache.h +++ b/src/aodv/model/aodv-id-cache.h @@ -43,22 +43,38 @@ namespace aodv { class IdCache { public: - /// c-tor + /** + * constructor + * \param lifetime the lifetime for added entries + */ IdCache (Time lifetime) : m_lifetime (lifetime) { } - /// Check that entry (addr, id) exists in cache. Add entry, if it doesn't exist. + /** + * Check that entry (addr, id) exists in cache. Add entry, if it doesn't exist. + * \param addr the IP address + * \param id the cache entry ID + * \returns true if the pair exists + */ bool IsDuplicate (Ipv4Address addr, uint32_t id); /// Remove all expired entries void Purge (); - /// Return number of entries in cache + /** + * \returns number of entries in cache + */ uint32_t GetSize (); - /// Set lifetime for future added entries. + /** + * Set lifetime for future added entries. + * \param lifetime the lifetime for entries + */ void SetLifetime (Time lifetime) { m_lifetime = lifetime; } - /// Return lifetime for existing entries in cache + /** + * Return lifetime for existing entries in cache + * \returns thhe lifetime + */ Time GetLifeTime () const { return m_lifetime; diff --git a/src/aodv/model/aodv-neighbor.h b/src/aodv/model/aodv-neighbor.h index d1bb4597a61..8e3fd119380 100644 --- a/src/aodv/model/aodv-neighbor.h +++ b/src/aodv/model/aodv-neighbor.h @@ -47,7 +47,10 @@ class RoutingProtocol; class Neighbors { public: - /// c-tor + /** + * constructor + * \param delay the delay time for purging the list of neighbors + */ Neighbors (Time delay); /// Neighbor description struct Neighbor @@ -76,11 +79,23 @@ class Neighbors { } }; - /// Return expire time for neighbor node with address addr, if exists, else return 0. + /** + * Return expire time for neighbor node with address addr, if exists, else return 0. + * \param addr the IP address of the neighbor node + * \returns the expire time for the neighbor node + */ Time GetExpireTime (Ipv4Address addr); - /// Check that node with address addr is neighbor + /** + * Check that node with address addr is neighbor + * \param addr the IP address to check + * \returns true if the node with IP address is a neighbor + */ bool IsNeighbor (Ipv4Address addr); - /// Update expire time for entry with address addr, if it exists, else add new entry + /** + * Update expire time for entry with address addr, if it exists, else add new entry + * \param addr the IP address to check + * \param expire the expire time for the address + */ void Update (Ipv4Address addr, Time expire); /// Remove all expired entries void Purge (); @@ -92,22 +107,37 @@ class Neighbors m_nb.clear (); } - /// Add ARP cache to be used to allow layer 2 notifications processing - void AddArpCache (Ptr); - /// Don't use given ARP cache any more (interface is down) - void DelArpCache (Ptr); - /// Get callback to ProcessTxError + /** + * Add ARP cache to be used to allow layer 2 notifications processing + * \param a pointer to the ARP cache to add + */ + void AddArpCache (Ptr a); + /** + * Don't use given ARP cache any more (interface is down) + * \param a pointer to the ARP cache to delete + */ + void DelArpCache (Ptr a); + /** + * Get callback to ProcessTxError + * \returns the callback function + */ Callback GetTxErrorCallback () const { return m_txErrorCallback; } - /// Handle link failure callback + /** + * Set link failure callback + * \param cb the callback function + */ void SetCallback (Callback cb) { m_handleLinkFailure = cb; } - /// Handle link failure callback + /** + * Get link failure callback + * \returns the link failure callback + */ Callback GetCallback () const { return m_handleLinkFailure; @@ -125,8 +155,13 @@ class Neighbors /// list of ARP cached to be used for layer 2 notifications processing std::vector > m_arp; - /// Find MAC address by IP using list of ARP caches - Mac48Address LookupMacAddress (Ipv4Address); + /** + * Find MAC address by IP using list of ARP caches + * + * \param addr the IP address to lookup + * \returns the MAC address for the IP address + */ + Mac48Address LookupMacAddress (Ipv4Address addr); /// Process layer 2 TX error notification void ProcessTxError (WifiMacHeader const &); }; diff --git a/src/aodv/model/aodv-packet.h b/src/aodv/model/aodv-packet.h index ad0a191d35c..7ede84465b6 100644 --- a/src/aodv/model/aodv-packet.h +++ b/src/aodv/model/aodv-packet.h @@ -57,7 +57,10 @@ enum MessageType class TypeHeader : public Header { public: - /// c-tor + /** + * constructor + * \param t the AODV RREQ type + */ TypeHeader (MessageType t = AODVTYPE_RREQ); /** @@ -71,12 +74,17 @@ class TypeHeader : public Header uint32_t Deserialize (Buffer::Iterator start); void Print (std::ostream &os) const; - /// Return type + /** + * \returns the type + */ MessageType Get () const { return m_type; } - /// Check that type if valid + /** + * Check that type if valid + * \returns true if the type is valid + */ bool IsValid () const { return m_valid; @@ -123,8 +131,19 @@ std::ostream & operator<< (std::ostream & os, TypeHeader const & h); class RreqHeader : public Header { public: - /// c-tor - RreqHeader (uint8_t flags = 0, uint8_t reserved = 0, uint8_t hopCount = 0, + /** + * constructor + * + * \param flags the message flags (0) + * \param reserved the reserved bits (0) + * \param hopCount the hop count + * \param requestID the request ID + * \param dst the destination IP address + * \param dstSeqNo the destination sequence number + * \param origin the origin IP address + * \param originSeqNo the origin sequence number + */ + RreqHeader (uint8_t flags = 0, uint8_t reserved = 0, uint8_t hopCount = 0, uint32_t requestID = 0, Ipv4Address dst = Ipv4Address (), uint32_t dstSeqNo = 0, Ipv4Address origin = Ipv4Address (), uint32_t originSeqNo = 0); @@ -316,7 +335,16 @@ std::ostream & operator<< (std::ostream & os, RreqHeader const &); class RrepHeader : public Header { public: - /// c-tor + /** + * constructor + * + * \param prefixSize the prefix size (0) + * \param hopCount the hop count (0) + * \param dst the destination IP address + * \param dstSeqNo the destination sequence number + * \param origin the origin IP address + * \param lifetime the lifetime + */ RrepHeader (uint8_t prefixSize = 0, uint8_t hopCount = 0, Ipv4Address dst = Ipv4Address (), uint32_t dstSeqNo = 0, Ipv4Address origin = Ipv4Address (), Time lifetime = MilliSeconds (0)); @@ -429,7 +457,13 @@ class RrepHeader : public Header */ uint8_t GetPrefixSize () const; - /// Configure RREP to be a Hello message + /** + * Configure RREP to be a Hello message + * + * \param src the source IP address + * \param srcSeqNo the source sequence number + * \param lifetime the lifetime of the message + */ void SetHello (Ipv4Address src, uint32_t srcSeqNo, Time lifetime); /** @@ -469,7 +503,7 @@ std::ostream & operator<< (std::ostream & os, RrepHeader const &); class RrepAckHeader : public Header { public: - /// c-tor + /// constructor RrepAckHeader (); /** @@ -523,7 +557,7 @@ std::ostream & operator<< (std::ostream & os, RrepAckHeader const &); class RerrHeader : public Header { public: - /// c-tor + /// constructor RerrHeader (); /** @@ -564,7 +598,9 @@ class RerrHeader : public Header bool RemoveUnDestination (std::pair & un); /// Clear header void Clear (); - /// Return number of unreachable destinations in RERR message + /** + * \returns number of unreachable destinations in RERR message + */ uint8_t GetDestCount () const { return (uint8_t)m_unreachableDstSeqNo.size (); diff --git a/src/aodv/model/aodv-routing-protocol.h b/src/aodv/model/aodv-routing-protocol.h index 86422b12720..4123c61bd4d 100644 --- a/src/aodv/model/aodv-routing-protocol.h +++ b/src/aodv/model/aodv-routing-protocol.h @@ -58,7 +58,7 @@ class RoutingProtocol : public Ipv4RoutingProtocol static TypeId GetTypeId (void); static const uint32_t AODV_PORT; - /// c-tor + /// constructor RoutingProtocol (); virtual ~RoutingProtocol (); virtual void DoDispose (); @@ -250,13 +250,29 @@ class RoutingProtocol : public Ipv4RoutingProtocol private: /// Start protocol operation void Start (); - /// Queue packet and send route request + /** + * Queue packet and send route request + * + * \param p the packet to route + * \param header the IP header + * \param ucb the UnicastForwardCallback function + * \param ecb the ErrorCallback function + */ void DeferredRouteOutput (Ptr p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb); - /// If route exists and valid, forward packet. + /** + * If route exists and is valid, forward packet. + * + * \param p the packet to route + * \param header the IP header + * \param ucb the UnicastForwardCallback function + * \param ecb the ErrorCallback function + * \returns true if forwarded + */ bool Forwarding (Ptr p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb); /** * Repeated attempts by a source node at route discovery for a single destination * use the expanding ring search technique. + * \param dst the destination IP address */ void ScheduleRreqRetry (Ipv4Address dst); /** @@ -272,15 +288,40 @@ class RoutingProtocol : public Ipv4RoutingProtocol * \param sender is supposed to be IP address of my neighbor. */ void UpdateRouteToNeighbor (Ipv4Address sender, Ipv4Address receiver); - /// Check that packet is send from own interface + /** + * Test whether the provided address is assigned to an interface on this node + * \param src the source IP address + * \returns true if the IP address is the node's IP address + */ bool IsMyOwnAddress (Ipv4Address src); - /// Find unicast socket with local interface address iface + /** + * Find unicast socket with local interface address iface + * + * \param iface the interface + * \returns the socket associated with the interface + */ Ptr FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const; - /// Find subnet directed broadcast socket with local interface address iface + /** + * Find subnet directed broadcast socket with local interface address iface + * + * \param iface the interface + * \returns the socket associated with the interface + */ Ptr FindSubnetBroadcastSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const; - /// Process hello message + /** + * Process hello message + * + * \param rrepHeader RREP message header + * \param receiverIfaceAddr receiver interface IP address + */ void ProcessHello (RrepHeader const & rrepHeader, Ipv4Address receiverIfaceAddr); - /// Create loopback route for given header + /** + * Create loopback route for given header + * + * \param header the IP header + * \param oif the output interface net device + * \returns the route + */ Ptr LoopbackRoute (const Ipv4Header & header, Ptr oif) const; ///\name Receive control packets @@ -350,10 +391,18 @@ class RoutingProtocol : public Ipv4RoutingProtocol void RerrRateLimitTimerExpire (); /// Map IP address + RREQ timer. std::map m_addressReqTimer; - /// Handle route discovery process + /** + * Handle route discovery process + * \param dst the destination IP address + */ void RouteRequestTimerExpire (Ipv4Address dst); - /// Mark link to neighbor node as unidirectional for blacklistTimeout - void AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout); + /** + * Mark link to neighbor node as unidirectional for blacklistTimeout + * + * \param neighbor the IP address of the neightbor node + * \param blacklistTimeout the black list timeout time + */ + void AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout); /// Provides uniform random variables. Ptr m_uniformRandomVariable; diff --git a/src/aodv/model/aodv-rqueue.h b/src/aodv/model/aodv-rqueue.h index 581624e0112..7f8ac704acf 100644 --- a/src/aodv/model/aodv-rqueue.h +++ b/src/aodv/model/aodv-rqueue.h @@ -47,7 +47,15 @@ class QueueEntry typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback; /// IPv4 routing error callback typedef typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback; - /// c-tor + /** + * constructor + * + * \param pa the packet to add to the queue + * \param h the Ipv4Header + * \param ucb the UnicastForwardCallback function + * \param ecb the ErrorCallback function + * \param exp the expiration time + */ QueueEntry (Ptr pa = 0, Ipv4Header const & h = Ipv4Header (), UnicastForwardCallback ucb = UnicastForwardCallback (), ErrorCallback ecb = ErrorCallback (), Time exp = Simulator::Now ()) @@ -172,21 +180,46 @@ class QueueEntry class RequestQueue { public: - /// Default c-tor + /** + * constructor + * + * \param maxLen the maximum length + * \param routeToQueueTimeout the route to queue timeout + */ RequestQueue (uint32_t maxLen, Time routeToQueueTimeout) : m_maxLen (maxLen), m_queueTimeout (routeToQueueTimeout) { } - /// Push entry in queue, if there is no entry with the same packet and destination address in queue. + /** + * Push entry in queue, if there is no entry with the same packet and destination address in queue. + * \param entry the queue entry + * \returns true if the entry is queued + */ bool Enqueue (QueueEntry & entry); - /// Return first found (the earliest) entry for given destination + /** + * Return first found (the earliest) entry for given destination + * + * \param dst the destination IP address + * \param entry the queue entry + * \returns true if the entry is dequeued + */ bool Dequeue (Ipv4Address dst, QueueEntry & entry); - /// Remove all packets with destination IP address dst + /** + * Remove all packets with destination IP address dst + * \param dst the destination IP address + */ void DropPacketWithDst (Ipv4Address dst); - /// Finds whether a packet with destination dst exists in the queue + /** + * Finds whether a packet with destination dst exists in the queue + * + * \param dst the destination IP address + * \returns true if an entry with the IP address is found + */ bool Find (Ipv4Address dst); - /// Number of entries + /** + * \returns the number of entries + */ uint32_t GetSize (); // Fields @@ -228,7 +261,11 @@ class RequestQueue std::vector m_queue; /// Remove all expired entries void Purge (); - /// Notify that packet is dropped from queue by timeout + /** + * Notify that packet is dropped from queue by timeout + * \param en the queue entry to drop + * \param reason the reason to drop the entry + */ void Drop (QueueEntry en, std::string reason); /// The maximum number of packets that we allow a routing protocol to buffer. uint32_t m_maxLen; diff --git a/src/aodv/model/aodv-rtable.h b/src/aodv/model/aodv-rtable.h index 59218005903..b70e30e8ace 100644 --- a/src/aodv/model/aodv-rtable.h +++ b/src/aodv/model/aodv-rtable.h @@ -59,8 +59,19 @@ enum RouteFlags class RoutingTableEntry { public: - /// c-to - RoutingTableEntry (Ptr dev = 0,Ipv4Address dst = Ipv4Address (), bool vSeqNo = false, uint32_t m_seqNo = 0, + /** + * constructor + * + * \param dev the device + * \param dst the destination IP address + * \param vSeqNo verify sequence number flag + * \param seqNo the sequence number + * \param iface the interface + * \param hops the number of hops + * \param nextHop the IP address of the next hop + * \param lifetime the lifetime of the entry + */ + RoutingTableEntry (Ptr dev = 0,Ipv4Address dst = Ipv4Address (), bool vSeqNo = false, uint32_t seqNo = 0, Ipv4InterfaceAddress iface = Ipv4InterfaceAddress (), uint16_t hops = 0, Ipv4Address nextHop = Ipv4Address (), Time lifetime = Simulator::Now ()); @@ -100,13 +111,16 @@ class RoutingTableEntry void GetPrecursors (std::vector & prec) const; //\} - /// Mark entry as "down" (i.e. disable it) + /** + * Mark entry as "down" (i.e. disable it) + * \param badLinkLifetime duration to keep entry marked as invalid + */ void Invalidate (Time badLinkLifetime); // Fields /** * Get destination address function - * \returns the IPv4 destiantion address + * \returns the IPv4 destination address */ Ipv4Address GetDestination () const { @@ -344,11 +358,11 @@ class RoutingTableEntry */ Time m_lifeTime; /** Ip route, include - * - destination address - * - source address - * - next hop address (gateway) - * - output device - */ + * - destination address + * - source address + * - next hop address (gateway) + * - output device + */ Ptr m_ipv4Route; /// Output interface address Ipv4InterfaceAddress m_iface; @@ -374,9 +388,12 @@ class RoutingTableEntry class RoutingTable { public: - /// c-tor + /** + * constructor + * \param t the routing table entry lifetime + */ RoutingTable (Time t); - ///\name Handle life time of invalid route + ///\name Handle lifetime of invalid route //\{ Time GetBadLinkLifetime () const { @@ -406,13 +423,32 @@ class RoutingTable * \return true on success */ bool LookupRoute (Ipv4Address dst, RoutingTableEntry & rt); - /// Lookup route in VALID state + /** + * Lookup route in VALID state + * \param dst destination address + * \param rt entry with destination address dst, if exists + * \return true on success + */ bool LookupValidRoute (Ipv4Address dst, RoutingTableEntry & rt); - /// Update routing table + /** + * Update routing table + * \param rt entry with destination address dst, if exists + * \return true on success + */ bool Update (RoutingTableEntry & rt); - /// Set routing table entry flags + /** + * Set routing table entry flags + * \param dst destination address + * \param state the routing flags + * \return true on success + */ bool SetEntryState (Ipv4Address dst, RouteFlags state); - /// Lookup routing entries with next hop Address dst and not empty list of precursors. + /** + * Lookup routing entries with next hop Address dst and not empty list of precursors. + * + * \param nextHop the next hop IP address + * \param unreachable + */ void GetListOfDestinationWithNextHop (Ipv4Address nextHop, std::map & unreachable); /** * Update routing entries with this destination as follows: @@ -423,7 +459,10 @@ class RoutingTable * \param unreachable routes to invalidate */ void InvalidateRoutesWithDst (std::map const & unreachable); - /// Delete all route from interface with address iface + /** + * Delete all route from interface with address iface + * \param iface the interface IP address + */ void DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface); /// Delete all entries from routing table void Clear () @@ -438,7 +477,10 @@ class RoutingTable * \return true on success */ bool MarkLinkAsUnidirectional (Ipv4Address neighbor, Time blacklistTimeout); - /// Print routing table + /** + * Print routing table + * \param stream the output stream + */ void Print (Ptr stream) const; private: @@ -446,7 +488,10 @@ class RoutingTable std::map m_ipv4AddressEntry; /// Deletion time for invalid routes Time m_badLinkLifetime; - /// const version of Purge, for use by Print() method + /** + * const version of Purge, for use by Print() method + * \param table the routing table entry to purge + */ void Purge (std::map &table) const; }; diff --git a/src/aodv/test/bug-772.h b/src/aodv/test/bug-772.h index ec782da347e..6a191bed1c5 100644 --- a/src/aodv/test/bug-772.h +++ b/src/aodv/test/bug-772.h @@ -76,7 +76,10 @@ class Bug772ChainTest : public TestCase void CheckResults (); /// Go void DoRun (); - /// receive data + /** + * Receive data function + * \param socket the socket to receive from + */ void HandleRead (Ptr socket); /// Receiving socket From 4b66cb5ac503d5e417bd6f0b65b06c29038170b4 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Fri, 1 Sep 2017 11:40:28 +0300 Subject: [PATCH 229/551] Documentation spelling fixes --- README | 2 +- doc/build.txt | 2 +- doc/manual/source/enable-modules.rst | 2 +- doc/manual/source/events.rst | 2 +- doc/manual/source/helpers.rst | 2 +- doc/manual/source/python.rst | 2 +- doc/manual/source/random-variables.rst | 2 +- doc/manual/source/tracing.rst | 76 +++++++++++----------- doc/tutorial/source/getting-started.rst | 2 +- doc/tutorial/source/introduction.rst | 2 +- doc/tutorial/source/tracing.rst | 2 +- src/antenna/doc/source/antenna-design.rst | 4 +- src/antenna/doc/source/antenna-testing.rst | 4 +- src/antenna/doc/source/antenna-user.rst | 2 +- src/csma/doc/csma.rst | 2 +- src/dsr/doc/dsr.rst | 10 +-- src/internet-apps/doc/internet-apps.rst | 2 +- src/internet/doc/routing-overview.rst | 4 +- src/uan/doc/uan.rst | 14 ++-- src/wifi/doc/source/wifi-design.rst | 4 +- src/wifi/doc/source/wifi-user.rst | 2 +- 21 files changed, 72 insertions(+), 72 deletions(-) diff --git a/README b/README index c1b8be10727..b139b327757 100644 --- a/README +++ b/README @@ -52,7 +52,7 @@ type the command ./waf configure --enable-examples followed by ./waf -in the the directory which contains +in the directory which contains this README file. The files built will be copied in the build/ directory. diff --git a/doc/build.txt b/doc/build.txt index 430f5977abd..08785798076 100644 --- a/doc/build.txt +++ b/doc/build.txt @@ -48,7 +48,7 @@ Other waf usages include: 4. ./waf --run "program [args]" Run a ns3 program, given its target name, with the given - arguments. This takes care of automatically modifying the the + arguments. This takes care of automatically modifying the path for finding the ns3 dynamic libraries in the environment before running the program. Note: the "program [args]" string is parsed using POSIX shell rules. diff --git a/doc/manual/source/enable-modules.rst b/doc/manual/source/enable-modules.rst index e395acb97f9..76ff9373a47 100644 --- a/doc/manual/source/enable-modules.rst +++ b/doc/manual/source/enable-modules.rst @@ -6,7 +6,7 @@ Enabling Subsets of |ns3| Modules As with most software projects, |ns3| is ever growing larger in terms of number of modules, lines of code, and memory footprint. Users, however, may only use a few of those modules at a time. For this reason, users may want to explicitly enable only the subset of the possible |ns3| modules that they actually need for their research. -This chapter discusses how to enable only the |ns3| modules that you are intersted in using. +This chapter discusses how to enable only the |ns3| modules that you are interested in using. How to enable a subset of |ns3|'s modules ***************************************** diff --git a/doc/manual/source/events.rst b/doc/manual/source/events.rst index 763713f821c..5baf3b5168e 100644 --- a/doc/manual/source/events.rst +++ b/doc/manual/source/events.rst @@ -168,7 +168,7 @@ network-level events. Notes: * Users need to be careful to propagate DoInitialize methods across objects - by calling Initialize explicitely on their member objects + by calling Initialize explicitly on their member objects * The context id associated with each ScheduleWithContext method has other uses beyond logging: it is used by an experimental branch of ns-3 to perform parallel simulation on multicore systems using diff --git a/doc/manual/source/helpers.rst b/doc/manual/source/helpers.rst index ca6980eec65..fffcab7e59d 100644 --- a/doc/manual/source/helpers.rst +++ b/doc/manual/source/helpers.rst @@ -7,7 +7,7 @@ Helpers The above chapters introduced you to various |ns3| programming concepts such as smart pointers for reference-counted memory management, attributes, namespaces, callbacks, etc. Users who work at this low-level API can interconnect |ns3| -objects with fine granulariy. However, a simulation program written entirely +objects with fine granularity. However, a simulation program written entirely using the low-level API would be quite long and tedious to code. For this reason, a separate so-called "helper API" has been overlaid on the core |ns3| API. If you have read the |ns3| tutorial, you will already be familiar with the diff --git a/doc/manual/source/python.rst b/doc/manual/source/python.rst index 622f655aaa9..50d58fdce9d 100644 --- a/doc/manual/source/python.rst +++ b/doc/manual/source/python.rst @@ -166,7 +166,7 @@ Callback based tracing is not yet properly supported for Python, as new |ns3| AP Pcap file writing is supported via the normal API. -Ascii tracing is supported since |ns3|.4 via the normal C++ API translated to Python. However, ascii tracing requires the creation of an ostream object to pass into the ascii tracing methods. In Python, the C++ std::ofstream has been minimally wrapped to allow this. For example: +ASCII tracing is supported since |ns3|.4 via the normal C++ API translated to Python. However, ASCII tracing requires the creation of an ostream object to pass into the ASCII tracing methods. In Python, the C++ std::ofstream has been minimally wrapped to allow this. For example: :: diff --git a/doc/manual/source/random-variables.rst b/doc/manual/source/random-variables.rst index 4b48b96c1ff..951d089ccaa 100644 --- a/doc/manual/source/random-variables.rst +++ b/doc/manual/source/random-variables.rst @@ -355,7 +355,7 @@ Publishing your results When you publish simulation results, a key piece of configuration information that you should always state is how you used the -the random number generator. +random number generator. * what seeds you used, * what RNG you used if not the default, diff --git a/doc/manual/source/tracing.rst b/doc/manual/source/tracing.rst index fbced172358..55ca8e5df78 100644 --- a/doc/manual/source/tracing.rst +++ b/doc/manual/source/tracing.rst @@ -521,32 +521,32 @@ tells the helper to interpret the ``prefix`` parameter as a complete filename. Ascii Tracing Device Helpers ++++++++++++++++++++++++++++ -The behavior of the ascii trace helper ``mixin`` is substantially similar to +The behavior of the ASCII trace helper ``mixin`` is substantially similar to the pcap version. Take a look at ``src/network/helper/trace-helper.h`` if you want to follow the discussion while looking at real code. The class ``AsciiTraceHelperForDevice`` adds the high level functionality for -using ascii tracing to a device helper class. As in the pcap case, every device -must implement a single virtual method inherited from the ascii trace +using ASCII tracing to a device helper class. As in the pcap case, every device +must implement a single virtual method inherited from the ASCII trace ``mixin``.:: virtual void EnableAsciiInternal (Ptr stream, std::string prefix, Ptr nd) = 0; The signature of this method reflects the device-centric view of the situation at this level; and also the fact that the helper may be writing to a shared -output stream. All of the public ascii-trace-related methods inherited from +output stream. All of the public ASCII-trace-related methods inherited from class ``AsciiTraceHelperForDevice`` reduce to calling this single device- -dependent implementation method. For example, the lowest level ascii trace +dependent implementation method. For example, the lowest level ASCII trace methods,:: void EnableAscii (std::string prefix, Ptr nd); void EnableAscii (Ptr stream, Ptr nd); will call the device implementation of ``EnableAsciiInternal`` directly, -providing either a valid prefix or stream. All other public ascii tracing +providing either a valid prefix or stream. All other public ASCII tracing methods will build on these low-level functions to provide additional user-level functionality. What this means to the user is that all device helpers in the -system will have all of the ascii trace methods available; and these methods +system will have all of the ASCII trace methods available; and these methods will all work in the same way across devices if the devices implement ``EnablAsciiInternal`` correctly. @@ -576,7 +576,7 @@ Ascii Tracing Device Helper Methods You are encouraged to peruse the Doxygen for class ``TraceHelperForDevice`` to find the details of these methods; but to summarize ... -There are twice as many methods available for ascii tracing as there were for +There are twice as many methods available for ASCII tracing as there were for pcap tracing. This is because, in addition to the pcap-style model where traces from each unique node/device pair are written to a unique file, we support a model in which trace information for many node/device pairs is written to a @@ -584,7 +584,7 @@ common file. This means that the -- file name generation mechanism is replaced by a mechanism to refer to a common file; and the number of API methods is doubled to allow all combinations. -Just as in pcap tracing, you can enable ascii tracing on a particular +Just as in pcap tracing, you can enable ASCII tracing on a particular node/net-device pair by providing a ``Ptr`` to an ``EnableAscii`` method. The ``Ptr`` is implicit since the net device must belong to exactly one ``Node``. For example,:: @@ -593,12 +593,12 @@ exactly one ``Node``. For example,:: ... helper.EnableAscii ("prefix", nd); -In this case, no trace contexts are written to the ascii trace file since they +In this case, no trace contexts are written to the ASCII trace file since they would be redundant. The system will pick the file name to be created using the same rules as described in the pcap section, except that the file will have the suffix ".tr" instead of ".pcap". -If you want to enable ascii tracing on more than one net device and have all +If you want to enable ASCII tracing on more than one net device and have all traces sent to a single file, you can do that as well by using an object to refer to a single file:: @@ -610,12 +610,12 @@ refer to a single file:: helper.EnableAscii (stream, nd1); helper.EnableAscii (stream, nd2); -In this case, trace contexts are written to the ascii trace file since they +In this case, trace contexts are written to the ASCII trace file since they are required to disambiguate traces from the two devices. Note that since the user is completely specifying the file name, the string should include the ".tr" for consistency. -You can enable ascii tracing on a particular node/net-device pair by providing a +You can enable ASCII tracing on a particular node/net-device pair by providing a ``std::string`` representing an object name service string to an ``EnablePcap`` method. The ``Ptr`` is looked up from the name string. Again, the ```` is implicit since the named net device must @@ -648,7 +648,7 @@ This would result in a single trace file called ``trace-file-name.tr`` that contains all of the trace events for both devices. The events would be disambiguated by trace context strings. -You can enable ascii tracing on a collection of node/net-device pairs by +You can enable ASCII tracing on a collection of node/net-device pairs by providing a ``NetDeviceContainer``. For each ``NetDevice`` in the container the type is checked. For each device of the proper type (the same type as is managed by the device helper), tracing is enabled. Again, the ```` is implicit @@ -658,7 +658,7 @@ since the found net device must belong to exactly one ``Node``. For example,:: ... helper.EnableAscii ("prefix", d); -This would result in a number of ascii trace files being created, each of which +This would result in a number of ASCII trace files being created, each of which follows the --.tr convention. Combining all of the traces into a single file is accomplished similarly to the examples above:: @@ -679,7 +679,7 @@ enabled.:: ... helper.EnableAscii ("prefix", n); -This would result in a number of ascii trace files being created, each of which +This would result in a number of ASCII trace files being created, each of which follows the --.tr convention. Combining all of the traces into a single file is accomplished similarly to the examples above: @@ -696,7 +696,7 @@ same type as that managed by the device helper.:: helper.EnableAsciiAll ("prefix"); -This would result in a number of ascii trace files being created, one for +This would result in a number of ASCII trace files being created, one for every device in the system of the type managed by the helper. All of these files will follow the --.tr convention. Combining all of the traces into a single file is accomplished similarly to the examples @@ -706,20 +706,20 @@ Ascii Tracing Device Helper Filename Selection ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Implicit in the prefix-style method descriptions above is the construction of -the complete filenames by the implementation method. By convention, ascii traces +the complete filenames by the implementation method. By convention, ASCII traces in the |ns3| system are of the form ``--.tr``. As previously mentioned, every node in the system will have a system-assigned node id; and every device will have an interface index (also called a device id) -relative to its node. By default, then, an ascii trace file created as a result +relative to its node. By default, then, an ASCII trace file created as a result of enabling tracing on the first device of node 21, using the prefix "prefix", would be ``prefix-21-1.tr``. You can always use the |ns3| object name service to make this more clear. For example, if you use the object name service to assign the name "server" to node -21, the resulting ascii trace file name will automatically become, +21, the resulting ASCII trace file name will automatically become, ``prefix-server-1.tr`` and if you also assign the name "eth0" to the device, -your ascii trace file name will automatically pick this up and be called +your ASCII trace file name will automatically pick this up and be called ``prefix-server-eth0.tr``. Pcap Tracing Protocol Helpers @@ -864,7 +864,7 @@ automatically become, "prefix-nserverIpv4-i1.pcap". Ascii Tracing Protocol Helpers ++++++++++++++++++++++++++++++ -The behavior of the ascii trace helpers is substantially similar to the pcap +The behavior of the ASCII trace helpers is substantially similar to the pcap case. Take a look at ``src/network/helper/trace-helper.h`` if you want to follow the discussion while looking at real code. @@ -874,7 +874,7 @@ appropriate type. For example, use a ``Ptr`` instead of a ``Ptr`` and call ``EnableAsciiIpv6`` instead of ``EnableAsciiIpv4``. The class ``AsciiTraceHelperForIpv4`` adds the high level functionality for -using ascii tracing to a protocol helper. Each protocol that enables these +using ASCII tracing to a protocol helper. Each protocol that enables these methods must implement a single virtual method inherited from this class.:: virtual void EnableAsciiIpv4Internal (Ptr stream, std::string prefix, @@ -924,7 +924,7 @@ Ascii Tracing Device Helper Methods You are encouraged to peruse the Doxygen for class ``PcapAndAsciiHelperForIpv4`` to find the details of these methods; but to summarize ... -There are twice as many methods available for ascii tracing as there were for +There are twice as many methods available for ASCII tracing as there were for pcap tracing. This is because, in addition to the pcap-style model where traces from each unique protocol/interface pair are written to a unique file, we support a model in which trace information for many protocol/interface pairs is @@ -932,7 +932,7 @@ written to a common file. This means that the -n- file name generation mechanism is replaced by a mechanism to refer to a common file; and the number of API methods is doubled to allow all combinations. -Just as in pcap tracing, you can enable ascii tracing on a particular +Just as in pcap tracing, you can enable ASCII tracing on a particular protocol/interface pair by providing a ``Ptr`` and an ``interface`` to an ``EnableAscii`` method. For example,:: @@ -940,12 +940,12 @@ protocol/interface pair by providing a ``Ptr`` and an ``interface`` to an ... helper.EnableAsciiIpv4 ("prefix", ipv4, 1); -In this case, no trace contexts are written to the ascii trace file since they +In this case, no trace contexts are written to the ASCII trace file since they would be redundant. The system will pick the file name to be created using the same rules as described in the pcap section, except that the file will have the suffix ".tr" instead of ".pcap". -If you want to enable ascii tracing on more than one interface and have all +If you want to enable ASCII tracing on more than one interface and have all traces sent to a single file, you can do that as well by using an object to refer to a single file. We have already something similar to this in the "cwnd" example above:: @@ -958,12 +958,12 @@ example above:: helper.EnableAsciiIpv4 (stream, protocol1, 1); helper.EnableAsciiIpv4 (stream, protocol2, 1); -In this case, trace contexts are written to the ascii trace file since they are +In this case, trace contexts are written to the ASCII trace file since they are required to disambiguate traces from the two interfaces. Note that since the user is completely specifying the file name, the string should include the ".tr" for consistency. -You can enable ascii tracing on a particular protocol by providing a +You can enable ASCII tracing on a particular protocol by providing a ``std::string`` representing an object name service string to an ``EnablePcap`` method. The ``Ptr`` is looked up from the name string. The ```` in the resulting filenames is implicit since there is a one-to-one correspondence @@ -992,7 +992,7 @@ This would result in a single trace file called "trace-file-name.tr" that contains all of the trace events for both interfaces. The events would be disambiguated by trace context strings. -You can enable ascii tracing on a collection of protocol/interface pairs by +You can enable ASCII tracing on a collection of protocol/interface pairs by providing an ``Ipv4InterfaceContainer``. For each protocol of the proper type (the same type as is managed by the device helper), tracing is enabled for the corresponding interface. Again, the ```` is implicit since there is a @@ -1009,7 +1009,7 @@ one-to-one correspondence between each protocol and its node. For example,:: ... helper.EnableAsciiIpv4 ("prefix", interfaces); -This would result in a number of ascii trace files being created, each of which +This would result in a number of ASCII trace files being created, each of which follows the -n-i.tr convention. Combining all of the traces into a single file is accomplished similarly to the examples above:: @@ -1025,7 +1025,7 @@ traces into a single file is accomplished similarly to the examples above:: ... helper.EnableAsciiIpv4 (stream, interfaces); -You can enable ascii tracing on a collection of protocol/interface pairs by +You can enable ASCII tracing on a collection of protocol/interface pairs by providing a ``NodeContainer``. For each ``Node`` in the ``NodeContainer`` the appropriate protocol is found. For each protocol, its interfaces are enumerated and tracing is enabled on the resulting pairs. For example,:: @@ -1034,7 +1034,7 @@ and tracing is enabled on the resulting pairs. For example,:: ... helper.EnableAsciiIpv4 ("prefix", n); -This would result in a number of ascii trace files being created, each of which +This would result in a number of ASCII trace files being created, each of which follows the --.tr convention. Combining all of the traces into a single file is accomplished similarly to the examples above: @@ -1047,12 +1047,12 @@ used to specify the resulting trace source.:: Of course, the traces can be combined into a single file as shown above. -Finally, you can enable ascii tracing for all interfaces in the system, with +Finally, you can enable ASCII tracing for all interfaces in the system, with associated protocol being the same type as that managed by the device helper.:: helper.EnableAsciiIpv4All ("prefix"); -This would result in a number of ascii trace files being created, one for +This would result in a number of ASCII trace files being created, one for every interface in the system related to a protocol of the type managed by the helper. All of these files will follow the -n-i--.tr." As previously mentioned, every node in the system will have a system-assigned node id. Since there is a one-to-one correspondence between protocols and nodes we use to node-id to identify the protocol identity. Every interface on a given protocol will have an interface index (also called simply an interface) relative -to its protocol. By default, then, an ascii trace file created as a result of +to its protocol. By default, then, an ASCII trace file created as a result of enabling tracing on the first device of node 21, using the prefix "prefix", would be "prefix-n21-i1.tr". Use the prefix to disambiguate multiple protocols per node. You can always use the |ns3| object name service to make this more clear. For example, if you use the object name service to assign the name "serverIpv4" -to the protocol on node 21, and also specify interface one, the resulting ascii +to the protocol on node 21, and also specify interface one, the resulting ASCII trace file name will automatically become, "prefix-nserverIpv4-1.tr". Tracing implementation details diff --git a/doc/tutorial/source/getting-started.rst b/doc/tutorial/source/getting-started.rst index 7eb2170eb46..b47ec3828a5 100644 --- a/doc/tutorial/source/getting-started.rst +++ b/doc/tutorial/source/getting-started.rst @@ -883,7 +883,7 @@ For example, to run your |ns3| program ``hello-simulator`` with the arguments Notice that the |ns3| program name goes with the ``--run`` argument, and the control utility (here ``gdb``) is the first token -in the ``--commmand-template`` argument. The ``--args`` tells ``gdb`` +in the ``--command-template`` argument. The ``--args`` tells ``gdb`` that the remainder of the command line belongs to the "inferior" program. (Some ``gdb``'s don't understand the ``--args`` feature. In this case, omit the program arguments from the ``--command-template``, diff --git a/doc/tutorial/source/introduction.rst b/doc/tutorial/source/introduction.rst index ac716a0b8d0..cab42eea6f6 100644 --- a/doc/tutorial/source/introduction.rst +++ b/doc/tutorial/source/introduction.rst @@ -41,7 +41,7 @@ models of how packet data networks work and perform, and provides a simulation engine for users to conduct simulation experiments. Some of the reasons to use |ns3| include to perform studies that are more difficult or not possible to perform with real systems, to study system behavior in -a highly controllled, reproducible environment, and to learn about how +a highly controlled, reproducible environment, and to learn about how networks work. Users will note that the available model set in |ns3| focuses on modeling how Internet protocols and networks work, but |ns3| is not limited to Internet systems; several users are using diff --git a/doc/tutorial/source/tracing.rst b/doc/tutorial/source/tracing.rst index 86db147b785..2389f371501 100644 --- a/doc/tutorial/source/tracing.rst +++ b/doc/tutorial/source/tracing.rst @@ -1272,7 +1272,7 @@ the list of TraceSources you will find **TraceSources** - * **CongestionWindow**: The TCP connnection's congestion window + * **CongestionWindow**: The TCP connection's congestion window Callback signature: **ns3::TracedValueCallback::Uint32** diff --git a/src/antenna/doc/source/antenna-design.rst b/src/antenna/doc/source/antenna-design.rst index beda6295c87..d93db0d5d14 100644 --- a/src/antenna/doc/source/antenna-design.rst +++ b/src/antenna/doc/source/antenna-design.rst @@ -21,10 +21,10 @@ AntennaModel The AntennaModel uses the coordinate system adopted in [Balanis]_ and depicted in Figure :ref:`fig-antenna-coordinate-system`. This system -is obtained by traslating the cartesian coordinate system used by the +is obtained by translating the Cartesian coordinate system used by the ns-3 MobilityModel into the new origin :math:`o` which is the location of the antenna, and then transforming the coordinates of every generic -point :math:`p` of the space from cartesian coordinates +point :math:`p` of the space from Cartesian coordinates :math:`(x,y,z)` into spherical coordinates :math:`(r, \theta,\phi)`. The antenna model neglects the radial component :math:`r`, and diff --git a/src/antenna/doc/source/antenna-testing.rst b/src/antenna/doc/source/antenna-testing.rst index be93c6238d3..5598858370a 100644 --- a/src/antenna/doc/source/antenna-testing.rst +++ b/src/antenna/doc/source/antenna-testing.rst @@ -10,11 +10,11 @@ Angles ------ The unit test suite ``angles`` verifies that the Angles class is -constructed properly by correct conversion from 3D cartesian +constructed properly by correct conversion from 3D Cartesian coordinates according to the available methods (construction from a single vector and from a pair of vectors). For each method, several test cases are provided that compare the values :math:`(\phi, \theta)` -determied by the constructor to known reference values. The test +determined by the constructor to known reference values. The test passes if for each case the values are equal to the reference up to a tolerance of :math:`10^{-10}` which accounts for numerical errors. diff --git a/src/antenna/doc/source/antenna-user.rst b/src/antenna/doc/source/antenna-user.rst index 784b469fdc9..f3832682816 100644 --- a/src/antenna/doc/source/antenna-user.rst +++ b/src/antenna/doc/source/antenna-user.rst @@ -5,7 +5,7 @@ User Documentation ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -The antenna moduled can be used with all the wireless technologies and +The antenna modeled can be used with all the wireless technologies and physical layer models that support it. Currently, this includes the physical layer models based on the SpectrumPhy. Please refer to the documentation of each of these models for details. diff --git a/src/csma/doc/csma.rst b/src/csma/doc/csma.rst index bf9e5a037ae..8a6730c05ef 100644 --- a/src/csma/doc/csma.rst +++ b/src/csma/doc/csma.rst @@ -4,7 +4,7 @@ CSMA NetDevice -------------- -This is the introduction to CSMA NetDevice chapter, to complement the Csma model +This is the introduction to CSMA NetDevice chapter, to complement the CSMA model doxygen. Overview of the CSMA model diff --git a/src/dsr/doc/dsr.rst b/src/dsr/doc/dsr.rst index 5213d5ee15a..c7c5790de71 100644 --- a/src/dsr/doc/dsr.rst +++ b/src/dsr/doc/dsr.rst @@ -62,7 +62,7 @@ saves the whole path in the cache. The paths are sorted based on the hop count, and whenever one path is not able to be used, we change to the next path. The link cache is a slightly better design in the sense that it uses different subpaths and uses Implemented Link Cache using -Dijsktra algorithm, and this part is implemented by +Dijkstra algorithm, and this part is implemented by Song Luan . The following optional protocol optimizations aren't implemented: @@ -126,7 +126,7 @@ Implementation modification * The DsrFsHeader has added 3 fields: message type, source id, destination id, and these changes only for post-processing 1. Message type is used to identify the data packet from control packet - 2. source id is used to identify the real source of the data packet since we have to deliver the packet hop-by-hop and the ipv4header is not carrying the real source and destination ip address as needed + 2. source id is used to identify the real source of the data packet since we have to deliver the packet hop-by-hop and the Ipv4Header is not carrying the real source and destination ip address as needed 3. destination id is for same reason of above * Route Reply header is not word-aligned in DSR RFC, change it to word-aligned in implementation * DSR works as a shim header between transport and network protocol, it needs its own forwarding mechanism, we are changing the packet transmission to hop-by-hop delivery, so we added two fields in dsr fixed header to notify packet delivery @@ -140,7 +140,7 @@ This implementation used "path cache", which is simple to implement and ensures * the path cache has automatic expire policy * the cache saves multiple route entries for a certain destination and sort the entries based on hop counts * the MaxEntriesEachDst can be tuned to change the maximum entries saved for a single destination -* when adding mulitiple routes for one destination, the route is compared based on hop-count and expire time, the one with less hop count or relatively new route is favored +* when adding multiple routes for one destination, the route is compared based on hop-count and expire time, the one with less hop count or relatively new route is favored * Future implementation may include "link cache" as another possibility DSR Instructions @@ -164,7 +164,7 @@ and DsrMainHelpers in your simulation script. For instance: DsrMainHelper dsrMain; dsrMain.Install (dsr, adhocNodes); -The example scripts inside ``src/dsr/examples/`` demonstrate the use of DSR based nodesin different scenarios. +The example scripts inside ``src/dsr/examples/`` demonstrate the use of DSR based nodes in different scenarios. The helper source can be found inside ``src/dsr/helper/dsr-main-helper.{h,cc}`` and ``src/dsr/helper/dsr-helper.{h,cc}`` @@ -194,7 +194,7 @@ Limitations *********** The model is not fully compliant with :rfc:`4728`. As an example, Dsr fixed size header -has been extended and it is four octects longer then the RFC specification. +has been extended and it is four octets longer then the RFC specification. As a consequence, the DSR headers can not be correctly decoded by Wireshark. The model full compliance with the RFC is planned for the future. diff --git a/src/internet-apps/doc/internet-apps.rst b/src/internet-apps/doc/internet-apps.rst index 72226616366..e097feceed5 100644 --- a/src/internet-apps/doc/internet-apps.rst +++ b/src/internet-apps/doc/internet-apps.rst @@ -35,7 +35,7 @@ following attributes to be set: * Packet size (default 56 bytes) * Packet interval (default 1 second) -Moreover, the user can access the measured rtt value (as a Traced Source). +Moreover, the user can access the measured RTT value (as a Traced Source). Ping6 ***** diff --git a/src/internet/doc/routing-overview.rst b/src/internet/doc/routing-overview.rst index 12a32bce5f0..8c3d6c0b0e1 100644 --- a/src/internet/doc/routing-overview.rst +++ b/src/internet/doc/routing-overview.rst @@ -316,7 +316,7 @@ are the number of vertices (routers) and edges (links) respectively. It should be stressed that the convergence time is the number of steps in the algorithm, and each step is triggered by a message. Since Triggered Updates (i.e., when a route is changed) have a 1-5 seconds -cooldown, the toplogy can require some time to be stabilized. +cooldown, the topology can require some time to be stabilized. Users should be aware that, during routing tables construction, the routers might drop packets. Data traffic should be sent only after a time long @@ -351,7 +351,7 @@ Poison Reverse will advertise the route on the interface from which it was learned, but with a metric of 16 (infinity). For a full analysis of the three techniques, see :rfc:`1058`, section 2.2. -The examples are based on the network toplogy +The examples are based on the network topology described in the RFC, but it does not show the effect described there. The reason are the Triggered Updates, together with the fact that when a diff --git a/src/uan/doc/uan.rst b/src/uan/doc/uan.rst index 8ef7d1c9ebd..fe91ab848bf 100644 --- a/src/uan/doc/uan.rst +++ b/src/uan/doc/uan.rst @@ -80,7 +80,7 @@ Acoustic Ray Tracing software (http://oalib.hlsresearch.com/). The create-dat utility requires a Bellhop installation to run. Bellhop takes environment information about the channel, such as sound speed profile, surface height -bottom type, water depth, and uses a gaussian ray tracing algorithm to determine +bottom type, water depth, and uses a Gaussian ray tracing algorithm to determine propagation information. Arrivals from Bellhop are grouped together into equal length taps (the arrivals in a tap duration are coherently summed). The maximum taps are then aligned to take the same position in the PDP. The create-dat utility averages together @@ -229,7 +229,7 @@ The user will be able to: * use a specific power profile for the acoustic modem * use a specific energy model for the AUV * trace the power consumption of AUV navigation, through AUV's energy model -* trace the power consumprion underwater acoustic communications, through acoustic modem power profile +* trace the power consumption underwater acoustic communications, through acoustic modem power profile We have integrated the Energy Model with the UAN module, to implement energy handling. We have implemented a specific energy model for the two AUV classes and, an energy source for Lithium batteries. This will be really useful for researchers to keep trace of the AUV operational life. We have implemented also an acoustic modem power profile, to keep trace of its power consumption. This can be used to compare protocols specific power performance. In order to use such power profile, the acoustic transducer physical layer has been modified to use the modem power profile. We have decoupled the physical layer from the transducer specific energy model, to let the users change the different energy models without changing the physical layer. @@ -259,7 +259,7 @@ AUV energy sources Acoustic modem energy model ^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Basing on the Device Energy Model interface, has been implemented a generic energy model for acoustic modem. The model allows to trace four modem's power-states: Sleep, Idle, Receiving, Transmitting. The default parameters for the energy model are set to fit those of the WHOI μmodem. The class follows pretty closely the RadioEnergyModel class as the transducer behaviour is pretty close to that of a wifi radio. +Basing on the Device Energy Model interface, has been implemented a generic energy model for acoustic modem. The model allows to trace four modem's power-states: Sleep, Idle, Receiving, Transmitting. The default parameters for the energy model are set to fit those of the WHOI μmodem. The class follows pretty closely the RadioEnergyModel class as the transducer behaviour is pretty close to that of a Wi-Fi radio. The default power consumption values implemented into the model are as follows [6]: @@ -281,7 +281,7 @@ UAN module energy modifications The UAN module has been modified in order to utilize the implemented energy classes. Specifically, it has been modified the physical layer of the UAN module. It Has been implemented an UpdatePowerConsumption method that takes the modem's state as parameter. It checks if an energy source is installed into the node and, in case, it then use the AcousticModemEnergyModel to update the power consumption with the current modem's state. The modem power consumption's update takes place whenever the modem changes its state. -A user should take into account that, if the the power consumption handling is enabled (if the node has an energy source installed), all the communications processes will terminate whether the node depletes all the energy source. +A user should take into account that, if the power consumption handling is enabled (if the node has an energy source installed), all the communications processes will terminate whether the node depletes all the energy source. Li-Ion batteries model @@ -315,7 +315,7 @@ Some ideas could be : * insert a data logging capability * modify the framework to use sockets (enabling the possibility to use applications) * introduce some more MAC protocols -* modify the physical layer to let it consider the doppler spread (problematic in underwater environments) +* modify the physical layer to let it consider the Doppler spread (problematic in underwater environments) * introduce OFDM modulations References @@ -355,7 +355,7 @@ further examples can be found into the Unit tests in ``src/uan/test/...cc`` Examples ======== -Examples of the Framework's usage can be found into the examples folder. There are mobility related examples and uan related ones. +Examples of the Framework's usage can be found into the examples folder. There are mobility related examples and UAN related ones. Mobility Model Examples ####################### @@ -517,7 +517,7 @@ The unit test can be found in ``src/uan/test/auv-energy-model-test.cc``. The single packet energy consumption test do the following: * creates a two node network, one surface gateway and one fixed node at -500 m of depth -* install the acoustic communication stack with energy consuption support into the nodes +* install the acoustic communication stack with energy consumption support into the nodes * a packet is sent from the underwater node to the gateway * it is verified that both, the gateway and the fixed node, have consumed the expected amount of energy from their sources diff --git a/src/wifi/doc/source/wifi-design.rst b/src/wifi/doc/source/wifi-design.rst index 88cbcccd79d..f1d62b5f1bf 100644 --- a/src/wifi/doc/source/wifi-design.rst +++ b/src/wifi/doc/source/wifi-design.rst @@ -155,7 +155,7 @@ found in practice. The physical layer and channel models operate on a per-packet basis, with no frequency-selective propagation or interference effects when using the default YansWifiPhy model. Directional antennas are also not -supported at this time. For additive white gaussian noise (AWGN) +supported at this time. For additive white Gaussian noise (AWGN) scenarios, or wideband interference scenarios, performance is governed by the application of analytical models (based on modulation and factors such as channel width) to the received signal-to-noise ratio, where noise @@ -446,7 +446,7 @@ were adapted to use the Spectrum channel API. This required developing a few ``SpectrumModel``-related classes. The class ``WifiSpectrumValueHelper`` is used to create Wi-Fi signals with the spectrum framework and spread their energy across the bands. The -spectrum is sub-divided into 312.5 KHz sub-bands (the width of an OFDM +spectrum is sub-divided into 312.5 kHz sub-bands (the width of an OFDM subcarrier). The power allocated to a particular channel is spread across the sub-bands roughly according to how power would be allocated to sub-carriers using an even distribution of power and diff --git a/src/wifi/doc/source/wifi-user.rst b/src/wifi/doc/source/wifi-user.rst index 15d80a4c634..6d3e71b48fc 100644 --- a/src/wifi/doc/source/wifi-user.rst +++ b/src/wifi/doc/source/wifi-user.rst @@ -36,7 +36,7 @@ To create a WifiNetDevice, users need to follow these steps: * Decide on which physical layer framework, the ``SpectrumWifiPhy`` or ``YansWifiPhy``, to use. This will affect which Channel and Phy type to use. * Configure the Channel: Channel takes care of getting signal - from one device to other devices on the same wifi channel. + from one device to other devices on the same Wi-Fi channel. The main configurations of WifiChannel are propagation loss model and propagation delay model. * Configure the WifiPhy: WifiPhy takes care of actually sending and receiving wireless signal from Channel. Here, WifiPhy decides whether each frame will be successfully From 66208e454a7eefcddad85d62c86792b56596a093 Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Wed, 6 Sep 2017 05:57:39 -0700 Subject: [PATCH 230/551] mesh: Fix doxygen warnings --- src/mesh/examples/mesh.cc | 12 +- src/mesh/helper/mesh-helper.h | 13 ++- src/mesh/helper/mesh-stack-installer.h | 19 ++- src/mesh/model/dot11s/hwmp-protocol-mac.h | 6 +- src/mesh/model/dot11s/hwmp-protocol.h | 109 +++++++++++++++--- src/mesh/model/dot11s/hwmp-rtable.h | 26 ++++- .../model/dot11s/ie-dot11s-beacon-timing.h | 1 + .../model/dot11s/ie-dot11s-peer-management.h | 21 ++-- src/mesh/model/dot11s/ie-dot11s-preq.h | 14 ++- src/mesh/model/dot11s/peer-link-frame.h | 39 +++++-- src/mesh/model/dot11s/peer-link.h | 106 ++++++++++++++--- .../dot11s/peer-management-protocol-mac.h | 16 ++- .../model/dot11s/peer-management-protocol.h | 29 ++++- src/mesh/model/flame/flame-protocol.h | 43 +++++-- src/mesh/model/flame/flame-rtable.h | 30 ++++- src/mesh/model/mesh-l2-routing-protocol.h | 17 ++- src/mesh/model/mesh-point-device.h | 26 ++++- src/mesh/model/mesh-wifi-beacon.h | 26 ++++- .../model/mesh-wifi-interface-mac-plugin.h | 6 +- src/mesh/model/mesh-wifi-interface-mac.h | 60 ++++++++-- 20 files changed, 505 insertions(+), 114 deletions(-) diff --git a/src/mesh/examples/mesh.cc b/src/mesh/examples/mesh.cc index 60bfc87097d..bdf659b1f3f 100644 --- a/src/mesh/examples/mesh.cc +++ b/src/mesh/examples/mesh.cc @@ -70,9 +70,17 @@ class MeshTest public: /// Init test MeshTest (); - /// Configure test from command line arguments + /** + * Configure test from command line arguments + * + * \param argc command line argument count + * \param argv command line arguments + */ void Configure (int argc, char ** argv); - /// Run test + /** + * Run test + * \returns the test status + */ int Run (); private: int m_xSize; ///< X size diff --git a/src/mesh/helper/mesh-helper.h b/src/mesh/helper/mesh-helper.h index fc64d2a43dc..078c25be53e 100644 --- a/src/mesh/helper/mesh-helper.h +++ b/src/mesh/helper/mesh-helper.h @@ -51,6 +51,7 @@ class MeshHelper /** * \brief Set the helper to the default values for the MAC type, remote * station manager and channel policy. + * \returns the default MeshHelper */ static MeshHelper Default (); @@ -117,6 +118,7 @@ class MeshHelper std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ()); /** * Set PHY standard + * \param standard the wifi phy standard */ void SetStandard (enum WifiPhyStandard standard); /// \todo SetMeshId @@ -135,8 +137,9 @@ class MeshHelper /** * \brief set the channel policy + * \param policy the channel policy */ - void SetSpreadInterfaceChannels (ChannelPolicy); + void SetSpreadInterfaceChannels (ChannelPolicy policy); /** * \brief Set a number of interfaces in a mesh network * \param nInterfaces is the number of interfaces @@ -184,13 +187,17 @@ class MeshHelper /** * \brief Print statistics. + * + * \param device the net device + * \param os the output stream */ - void Report (const ns3::Ptr&, std::ostream& os); + void Report (const ns3::Ptr& device, std::ostream& os); /** * \brief Reset statistics. + * \param device the net device */ - void ResetStats (const ns3::Ptr&); + void ResetStats (const ns3::Ptr& device); /** * Assign a fixed random variable stream number to the random variables * used by this model. Return the number of streams (possibly zero) that diff --git a/src/mesh/helper/mesh-stack-installer.h b/src/mesh/helper/mesh-stack-installer.h index 8c77614613a..191c11b78f0 100644 --- a/src/mesh/helper/mesh-stack-installer.h +++ b/src/mesh/helper/mesh-stack-installer.h @@ -39,11 +39,22 @@ class MeshStack : public Object /// \return The TypeId. static TypeId GetTypeId (void); - ///\brief Installs mesh stack. needed by helper only + /** + * \brief Installs mesh stack. needed by helper only + * \param mp the mesh point device + * \returns true if successful + */ virtual bool InstallStack (Ptr mp) = 0; - /// Report statistics of a given mesh point - virtual void Report (const Ptr mp, std::ostream&) = 0; - /// Reset statistics of a given mesh point + /** + * Report statistics of a given mesh point + * \param mp the mesh point device + * \param os the output stream + */ + virtual void Report (const Ptr mp, std::ostream& os) = 0; + /** + * Reset statistics of a given mesh point + * \param mp the mesh point device + */ virtual void ResetStats (const Ptr mp) = 0; }; } diff --git a/src/mesh/model/dot11s/hwmp-protocol-mac.h b/src/mesh/model/dot11s/hwmp-protocol-mac.h index 78f7526e1dd..fde7a6573e6 100644 --- a/src/mesh/model/dot11s/hwmp-protocol-mac.h +++ b/src/mesh/model/dot11s/hwmp-protocol-mac.h @@ -63,6 +63,7 @@ class HwmpProtocolMac : public MeshWifiInterfaceMacPlugin //\} private: + /// allow HwmpProtocol class friend access friend class HwmpProtocol; /** * \returns a path selection action header @@ -167,7 +168,10 @@ class HwmpProtocolMac : public MeshWifiInterfaceMacPlugin uint32_t txDataBytes; ///< transmit data bytes uint16_t rxData; ///< receive data uint32_t rxDataBytes; ///< receive data bytes - /// Print function + /** + * Print function + * \param os the output stream + */ void Print (std::ostream & os) const; Statistics (); }; diff --git a/src/mesh/model/dot11s/hwmp-protocol.h b/src/mesh/model/dot11s/hwmp-protocol.h index 691a7e20a59..ebb70b19f54 100644 --- a/src/mesh/model/dot11s/hwmp-protocol.h +++ b/src/mesh/model/dot11s/hwmp-protocol.h @@ -78,11 +78,28 @@ class HwmpProtocol : public MeshL2RoutingProtocol Mac48Address destination; ///< destination address uint32_t seqnum; ///< sequence number } FailedDestination; - /// Route request, inherited from MeshL2RoutingProtocol + /** + * Route request, inherited from MeshL2RoutingProtocol + * + * \param sourceIface the source interface + * \param source the source address + * \param destination the destination address + * \param packet the packet to route + * \param protocolType the protocol type + * \param routeReply the route reply + * \returns true if route exists + */ bool RequestRoute (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, Ptr packet, uint16_t protocolType, RouteReplyCallback routeReply); /** * Clean HWMP packet tag from packet; only the packet parameter is used + * + * \param fromIface the from interface + * \param source the source address + * \param destination the destination address + * \param packet the packet to route + * \param protocolType the protocol type + * \returns true if successful */ bool RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source, const Mac48Address destination, Ptr packet, uint16_t& protocolType); @@ -104,8 +121,10 @@ class HwmpProtocol : public MeshL2RoutingProtocol * \param status The status of the peer link */ void PeerLinkStatus (Mac48Address meshPontAddress, Mac48Address peerAddress, uint32_t interface,bool status); - ///\brief This callback is used to obtain active neighbours on a given interface - ///\param cb is a callback, which returns a list of addresses on given interface (uint32_t) + /** + * \brief This callback is used to obtain active neighbours on a given interface + * \param cb is a callback, which returns a list of addresses on given interface (uint32_t) + */ void SetNeighboursCallback (Callback, uint32_t> cb); ///\name Proactive PREQ mechanism: ///\{ @@ -133,13 +152,21 @@ class HwmpProtocol : public MeshL2RoutingProtocol Ptr GetRoutingTable (void) const; private: + /// allow HwmpProtocolMac class friend access friend class HwmpProtocolMac; virtual void DoInitialize (); - /// assignment operator - HwmpProtocol& operator= (const HwmpProtocol &); - /// type conversion + /** + * assignment operator + * \param hwmp the HWMP protocol to assign + * \returns the assigned value + */ + HwmpProtocol& operator= (const HwmpProtocol & hwmp); + /** + * type conversion + * \returns the HWMP protocol + */ HwmpProtocol (const HwmpProtocol &); /** @@ -164,19 +191,63 @@ class HwmpProtocol : public MeshL2RoutingProtocol QueuedPacket (); }; typedef std::map > HwmpProtocolMacMap; ///< HwmpProtocolMacMap typedef - /// Like RequestRoute, but for unicast packets - bool ForwardUnicast (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, - Ptr packet, uint16_t protocolType, RouteReplyCallback routeReply, uint32_t ttl); + /** + * Like RequestRoute, but for unicast packets + * + * \param sourceIface the source interface + * \param source the source address + * \param destination the destination address + * \param packet the packet to route + * \param protocolType the protocol type + * \param routeReply the route reply callback + * \param ttl the TTL + * \returns true if forwarded + */ + bool ForwardUnicast (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, + Ptr packet, uint16_t protocolType, RouteReplyCallback routeReply, uint32_t ttl); ///\name Interaction with HWMP MAC plugin //\{ - ///\brief Handler for receiving Path Request + /** + * \brief Handler for receiving Path Request + * + * \param preq the IE preq + * \param from the from address + * \param interface the interface + * \param fromMp the 'from MP' address + * \param metric the metric + */ void ReceivePreq (IePreq preq, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric); - ///\brief Handler for receiving Path Reply + /** + * \brief Handler for receiving Path Reply + * + * \param prep the IE prep + * \param from the from address + * \param interface the interface + * \param fromMp the 'from MP' address + * \param metric the metric + */ void ReceivePrep (IePrep prep, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric); - ///\brief Handler for receiving Path Error - void ReceivePerr (std::vector, Mac48Address from, uint32_t interface, Mac48Address fromMp); - ///\brief Send Path Reply + /** + * \brief Handler for receiving Path Error + * + * \param destinations the list of failed destinations + * \param from the from address + * \param interface the interface + * \param fromMp the from MP address + */ + void ReceivePerr (std::vector destinations, Mac48Address from, uint32_t interface, Mac48Address fromMp); + /** + * \brief Send Path Reply + * \param src the source address + * \param dst the destination address + * \param retransmitter the retransmitter address + * \param initMetric the initial metric + * \param originatorDsn the originator DSN + * \param destinationSN the destination DSN + * \param lifetime the lifetime + * \param interface the interface + */ void SendPrep ( Mac48Address src, Mac48Address dst, @@ -194,9 +265,15 @@ class HwmpProtocol : public MeshL2RoutingProtocol * \return PathError */ PathError MakePathError (std::vector destinations); - ///\brief Forwards a received path error + /** + * \brief Forwards a received path error + * \param perr the path error + */ void ForwardPathError (PathError perr); - ///\brief Passes a self-generated PERR to interface-plugin + /** + * \brief Passes a self-generated PERR to interface-plugin + * \param perr the path error + */ void InitiatePathError (PathError perr); /** * Get PERR receivers diff --git a/src/mesh/model/dot11s/hwmp-rtable.h b/src/mesh/model/dot11s/hwmp-rtable.h index 0a7f4c98096..a7bccd88200 100644 --- a/src/mesh/model/dot11s/hwmp-rtable.h +++ b/src/mesh/model/dot11s/hwmp-rtable.h @@ -48,15 +48,29 @@ class HwmpRtable : public Object uint32_t metric; ///< metric uint32_t seqnum; ///< sequence number Time lifetime; ///< lifetime - /// Lookup result function + /** + * Lookup result function + * + * \param r the result address + * \param i the interface + * \param m the metric + * \param s the sequence number + * \param l the lifetime + */ LookupResult (Mac48Address r = Mac48Address::GetBroadcast (), uint32_t i = INTERFACE_ANY, uint32_t m = MAX_METRIC, uint32_t s = 0, Time l = Seconds (0.0)); - /// True for valid route + /** + * \returns True for valid route + */ bool IsValid () const; - /// Compare route lookup results, used by tests + /** + * Compare route lookup results, used by tests + * \param o the lookup result to compare + * \returns true if equal + */ bool operator== (const LookupResult & o) const; }; /// Path precursor = {MAC, interface ID} @@ -109,7 +123,11 @@ class HwmpRtable : public Object LookupResult LookupProactiveExpired (); //\} - /// When peer link with a given MAC-address fails - it returns list of unreachable destination addresses + /** + * When peer link with a given MAC-address fails - it returns list of unreachable destination addresses + * \param peerAddress the peer address + * \returns the list of unreachable destinations + */ std::vector GetUnreachableDestinations (Mac48Address peerAddress); private: diff --git a/src/mesh/model/dot11s/ie-dot11s-beacon-timing.h b/src/mesh/model/dot11s/ie-dot11s-beacon-timing.h index 0d7afb5cbdc..c552737ed07 100644 --- a/src/mesh/model/dot11s/ie-dot11s-beacon-timing.h +++ b/src/mesh/model/dot11s/ie-dot11s-beacon-timing.h @@ -101,6 +101,7 @@ class IeBeaconTiming : public WifiInformationElement /** * This methods are needed for beacon collision * avoidance module: + * \returns the neighbor timing elements list */ NeighboursTimingUnitsList GetNeighboursTimingElementsList (); /** diff --git a/src/mesh/model/dot11s/ie-dot11s-peer-management.h b/src/mesh/model/dot11s/ie-dot11s-peer-management.h index 2da2a932ae5..05d45c1c0d1 100644 --- a/src/mesh/model/dot11s/ie-dot11s-peer-management.h +++ b/src/mesh/model/dot11s/ie-dot11s-peer-management.h @@ -62,20 +62,20 @@ class IePeerManagement : public WifiInformationElement * Set peer open function * \param localLinkId */ - void SetPeerOpen (uint16_t localLinkId); + void SetPeerOpen (uint16_t localLinkId); /** * Set peer close function * \param localLinkID the local link id * \param peerLinkId the peer link id * \param reasonCode the reason code */ - void SetPeerClose (uint16_t localLinkID, uint16_t peerLinkId, PmpReasonCode reasonCode); + void SetPeerClose (uint16_t localLinkID, uint16_t peerLinkId, PmpReasonCode reasonCode); /** * Set peer confirm function * \param localLinkID the local link id * \param peerLinkId the peer link id */ - void SetPeerConfirm (uint16_t localLinkID, uint16_t peerLinkId); + void SetPeerConfirm (uint16_t localLinkID, uint16_t peerLinkId); /** * Get reason code function @@ -86,24 +86,27 @@ class IePeerManagement : public WifiInformationElement * Get local link ID function * \returns the local link id */ - uint16_t GetLocalLinkId () const; - /// Get peer link ID function - uint16_t GetPeerLinkId () const; + uint16_t GetLocalLinkId () const; + /** + * Get peer link ID function + * \returns the peer link ID + */ + uint16_t GetPeerLinkId () const; /** * Subtype is open function * \returns true if open */ - bool SubtypeIsOpen () const; + bool SubtypeIsOpen () const; /** * Subtype is close function * \returns true if closed */ - bool SubtypeIsClose () const; + bool SubtypeIsClose () const; /** * Subtype is confirm function * \returns true if the subtype is confirm */ - bool SubtypeIsConfirm () const; + bool SubtypeIsConfirm () const; /** * Get subtype function * \returns the subtype diff --git a/src/mesh/model/dot11s/ie-dot11s-preq.h b/src/mesh/model/dot11s/ie-dot11s-preq.h index c61033154c8..a85c8dc1b43 100644 --- a/src/mesh/model/dot11s/ie-dot11s-preq.h +++ b/src/mesh/model/dot11s/ie-dot11s-preq.h @@ -119,11 +119,17 @@ class IePreq : public WifiInformationElement Mac48Address dest_address, uint32_t dest_seq_number ); - /// Delete a destination address unit by destination + /** + * Delete a destination address unit by destination + * \param dest_address the destination address + */ void DelDestinationAddressElement (Mac48Address dest_address); /// Clear PREQ: remove all destinations void ClearDestinationAddressElements (); - /// Get all destinations, which are stored in PREQ: + /** + * Get all destinations, which are stored in PREQ: + * \returns the list of destination addresses + */ std::vector > GetDestinationList (); /// Set flag indicating that PREQ is unicast void SetUnicastPreq (); @@ -136,7 +142,7 @@ class IePreq : public WifiInformationElement /** * Set number of hops from originator to mesh STA transmitting this * element - * \param hopcount + * \param hopcount the hop count */ void SetHopcount (uint8_t hopcount); /** @@ -237,6 +243,8 @@ class IePreq : public WifiInformationElement /** * \brief Checks that preq's originator address equals to originator, and * this preq is not proactive + * \param originator the originator address + * \returns true if it may add */ bool MayAddAddress (Mac48Address originator); /** diff --git a/src/mesh/model/dot11s/peer-link-frame.h b/src/mesh/model/dot11s/peer-link-frame.h index 15cdb29e4d2..332884572dc 100644 --- a/src/mesh/model/dot11s/peer-link-frame.h +++ b/src/mesh/model/dot11s/peer-link-frame.h @@ -92,10 +92,17 @@ class PeerLinkOpenStart : public Header */ friend bool operator== (const PeerLinkOpenStart & a, const PeerLinkOpenStart & b); - /// assignment operator - PeerLinkOpenStart& operator= (const PeerLinkOpenStart &); - /// type conversion opertor - PeerLinkOpenStart (const PeerLinkOpenStart &); + /** + * assignment operator + * \param peer the peer link open start + * \returns the assigned value + */ + PeerLinkOpenStart& operator= (const PeerLinkOpenStart & peer); + /** + * constructor + * \param peer the peer link open start + */ + PeerLinkOpenStart (const PeerLinkOpenStart & peer); }; @@ -154,8 +161,13 @@ class PeerLinkCloseStart : public Header */ friend bool operator== (const PeerLinkCloseStart & a, const PeerLinkCloseStart & b); - /// assignment operator - PeerLinkCloseStart& operator= (const PeerLinkCloseStart &); + /** + * assignment operator + * + * \param peer the value to assign + * \returns the assigned value + */ + PeerLinkCloseStart& operator= (const PeerLinkCloseStart & peer); /// type conversion operator PeerLinkCloseStart (const PeerLinkCloseStart &); @@ -223,10 +235,17 @@ class PeerLinkConfirmStart : public Header */ friend bool operator== (const PeerLinkConfirmStart & a, const PeerLinkConfirmStart & b); - /// assignment operator - PeerLinkConfirmStart& operator= (const PeerLinkConfirmStart &); - /// type conversion operator - PeerLinkConfirmStart (const PeerLinkConfirmStart &); + /** + * assignment operator + * \param peer the peer link confirm start + * \returns the assigned value + */ + PeerLinkConfirmStart& operator= (const PeerLinkConfirmStart & peer); + /** + * constructor + * \param peer the peer link confirm start + */ + PeerLinkConfirmStart (const PeerLinkConfirmStart & peer); }; bool operator== (const PeerLinkConfirmStart & a, const PeerLinkConfirmStart & b); diff --git a/src/mesh/model/dot11s/peer-link.h b/src/mesh/model/dot11s/peer-link.h index 928de72b28b..c5e8aff712f 100644 --- a/src/mesh/model/dot11s/peer-link.h +++ b/src/mesh/model/dot11s/peer-link.h @@ -43,8 +43,12 @@ class PeerManagementProtocolMac; class PeerLink : public Object { public: + /// allow PeerManagementProtocol class friend access friend class PeerManagementProtocol; - /// Support object system + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /// C-tor create empty link PeerLink (); @@ -63,7 +67,12 @@ class PeerLink : public Object * \brief Literal names of Mesh Peer Management states for use in log messages */ static const char* const PeerStateNames[6]; - /// Process beacon received from peer + /** + * Process beacon received from peer + * + * \param lastBeacon the last beacon + * \param BeaconInterval the beacon interval + */ void SetBeaconInformation (Time lastBeacon, Time BeaconInterval); /** * \brief Method used to detect peer link changes @@ -95,7 +104,10 @@ class PeerLink : public Object * \name MLME * \{ */ - /// MLME-CancelPeerLink.request + /** + * MLME-CancelPeerLink.request + * \param reason the reason for the request + */ void MLMECancelPeerLink (PmpReasonCode reason); /// MLME-ActivePeerLinkOpen.request void MLMEActivePeerLinkOpen (); @@ -103,13 +115,19 @@ class PeerLink : public Object void MLMEPeeringRequestReject (); /// Callback type for MLME-SignalPeerLinkStatus event typedef Callback SignalStatusCallback; - /// Set callback - void MLMESetSignalStatusCallback (SignalStatusCallback); + /** + * Set callback + * \param cb the callback function + */ + void MLMESetSignalStatusCallback (SignalStatusCallback cb); /// Reports about transmission success/failure void TransmissionSuccess (); void TransmissionFailure (); //\} - ///\brief Statistics + /** + * \brief Statistics + * \param os the output stream + */ void Report (std::ostream & os) const; private: /// Peer link events, see 802.11s draft 11B.3.3.2 @@ -126,9 +144,14 @@ class PeerLink : public Object TOR1, ///< Timeout of retry timer TOR2, ///< also timeout of retry timer TOC, ///< Timeout of confirm timer - TOH, ///< Timeout of holding (graceful closing) timer + TOH ///< Timeout of holding (graceful closing) timer }; - /// State transition + /** + * State transition + * + * \param event the event to update the state machine + * \param reasoncode the reason for the state transition + */ void StateMachine (PeerEvent event, PmpReasonCode = REASON11S_RESERVED); /** * \name Link response to received management frames @@ -138,13 +161,40 @@ class PeerLink : public Object * * \{ */ - /// Close link + /** + * Close link + * + * \param localLinkID the local link ID + * \param peerLinkID the peer link ID + * \param reason the reason to close + */ void Close (uint16_t localLinkID, uint16_t peerLinkID, PmpReasonCode reason); - /// Accept open link + /** + * Accept open link + * + * \param localLinkId the local link ID + * \param conf the IE configuration + * \param peerMp the peer MP + */ void OpenAccept (uint16_t localLinkId, IeConfiguration conf, Mac48Address peerMp); - /// Reject open link + /** + * Reject open link + * + * \param localLinkId the local link ID + * \param conf the IE configuration + * \param peerMp the peer MP + * \param reason the reason to close + */ void OpenReject (uint16_t localLinkId, IeConfiguration conf, Mac48Address peerMp, PmpReasonCode reason); - /// Confirm accept + /** + * Confirm accept + * + * \param localLinkId the local link ID + * \param peerLinkId the peer link ID + * \param peerAid the peer AID + * \param conf the IE configuration + * \param peerMp the peer MP + */ void ConfirmAccept ( uint16_t localLinkId, uint16_t peerLinkId, @@ -152,7 +202,15 @@ class PeerLink : public Object IeConfiguration conf, Mac48Address peerMp ); - /// Confirm reject + /** + * Confirm reject + * + * \param localLinkId the local link ID + * \param peerLinkId the peer link ID + * \param conf the IE configuration + * \param peerMp the peer MP + * \param reason the reason to close + */ void ConfirmReject ( uint16_t localLinkId, uint16_t peerLinkId, @@ -161,13 +219,18 @@ class PeerLink : public Object PmpReasonCode reason ); //\} - /// True if link is established + /** + * \returns True if link is established + */ bool LinkIsEstab () const; - /// True if link is idle. Link can be deleted in this state + /** + * \returns True if link is idle. Link can be deleted in this state + */ bool LinkIsIdle () const; /** * Set pointer to MAC-plugin, which is responsible for sending peer * link management frames + * \param plugin the peer management protocol MAC */ void SetMacPlugin (Ptr plugin); /** @@ -203,9 +266,16 @@ class PeerLink : public Object void BeaconLoss (); private: - /// assignment operator - PeerLink& operator= (const PeerLink &); - /// type conversion operator + /** + * assignment operator + * \param link the peer link + * \returns the peer link assigned + */ + PeerLink& operator= (const PeerLink & link); + /** + * type conversion operator + * \returns the peer link + */ PeerLink (const PeerLink &); /// The number of interface I am associated with diff --git a/src/mesh/model/dot11s/peer-management-protocol-mac.h b/src/mesh/model/dot11s/peer-management-protocol-mac.h index 111c9d4719b..b6b4b2acf37 100644 --- a/src/mesh/model/dot11s/peer-management-protocol-mac.h +++ b/src/mesh/model/dot11s/peer-management-protocol-mac.h @@ -95,12 +95,19 @@ class PeerManagementProtocolMac : public MeshWifiInterfaceMacPlugin // \} private: - /// assignment operator - PeerManagementProtocolMac& operator= (const PeerManagementProtocolMac &); + /** + * assignment operator + * + * \param peer the object to assign + * \returns the assigned value + */ + PeerManagementProtocolMac& operator= (const PeerManagementProtocolMac & peer); /// type conversion operator PeerManagementProtocolMac (const PeerManagementProtocolMac &); + /// allow PeerManagementProtocol class access friend access friend class PeerManagementProtocol; + /// allow PeerLink class access friend access friend class PeerLink; ///\name Create peer link management frames // \{ @@ -173,7 +180,10 @@ class PeerManagementProtocolMac : public MeshWifiInterfaceMacPlugin IePeerManagement peerElement, IeConfiguration meshConfig ); - ///\brief debug only, used to print established links + /** + * \brief debug only, used to print established links + * \returns the MAC address + */ Mac48Address GetAddress () const; /// Statistics structure struct Statistics diff --git a/src/mesh/model/dot11s/peer-management-protocol.h b/src/mesh/model/dot11s/peer-management-protocol.h index afd8ff2e1e5..fb99aceede3 100644 --- a/src/mesh/model/dot11s/peer-management-protocol.h +++ b/src/mesh/model/dot11s/peer-management-protocol.h @@ -103,8 +103,7 @@ class PeerManagementProtocol : public Object * to peer address when only one interface) * \param aid is association ID, which peer has assigned to us * \param peerManagementElement is peer link management element - * \param meshConfig is mesh configuration element taken from the peer - * management frame + * \param meshConfig is mesh configuration element taken from the peer management frame */ void ReceivePeerLinkFrame ( uint32_t interface, @@ -232,12 +231,24 @@ class PeerManagementProtocol : public Object typedef std::map > PeerManagementProtocolMacMap; private: - /// assignment operator - PeerManagementProtocol& operator= (const PeerManagementProtocol &); + /** + * assignment operator + * + * \param peer the value to assign + * \returns the assigned value + */ + PeerManagementProtocol& operator= (const PeerManagementProtocol & peer); /// type conversion operator PeerManagementProtocol (const PeerManagementProtocol &); - /// Initiate link functon + /** + * Initiate link functon + * + * \param interface the interface to use + * \param peerAddress the peer address + * \param peerMeshPointAddress the peer mesh point address + * \returns the peer link + */ Ptr InitiateLink ( uint32_t interface, Mac48Address peerAddress, @@ -245,6 +256,9 @@ class PeerManagementProtocol : public Object ); /** * \name External peer-chooser + * \param interface the interface to use + * \param peerAddress the peer address + * \returns true is should send an open */ bool ShouldSendOpen (uint32_t interface, Mac48Address peerAddress); /** @@ -321,7 +335,10 @@ class PeerManagementProtocol : public Object * \param t */ Statistics (uint16_t t = 0); - /// Print function + /** + * Print function + * \param os the output stream to print to + */ void Print (std::ostream & os) const; }; struct Statistics m_stats; ///< statistics diff --git a/src/mesh/model/flame/flame-protocol.h b/src/mesh/model/flame/flame-protocol.h index ef151b65c77..46a11adb6f5 100644 --- a/src/mesh/model/flame/flame-protocol.h +++ b/src/mesh/model/flame/flame-protocol.h @@ -97,12 +97,31 @@ class FlameProtocol : public MeshL2RoutingProtocol ~FlameProtocol (); void DoDispose (); - /// Route request, inherited from MeshL2RoutingProtocol - bool RequestRoute (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, - Ptr packet, uint16_t protocolType, RouteReplyCallback routeReply); - /// Cleanup flame headers! + /** + * Route request, inherited from MeshL2RoutingProtocol + * + * \param sourceIface the source interface + * \param source the source address + * \param destination the destination address + * \param packet the packet to route + * \param protocolType the protocol type + * \param routeReply the route reply + * \returns if route exists + */ + bool RequestRoute (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, + Ptr packet, uint16_t protocolType, RouteReplyCallback routeReply); + /** + * Cleanup flame headers! + * + * \param fromIface the from interface + * \param source the source address + * \param destination the destination address + * \param packet the packet + * \param protocolType the protocol type + * \returns if the route removed + */ bool RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source, - const Mac48Address destination, Ptr packet, uint16_t& protocolType); + const Mac48Address destination, Ptr packet, uint16_t& protocolType); /** * \brief Install FLAME on given mesh point. * \returns true if successful @@ -126,8 +145,13 @@ class FlameProtocol : public MeshL2RoutingProtocol /// Reset statistics function void ResetStats (); private: - /// assignment operator - FlameProtocol& operator= (const FlameProtocol &); + /** + * assignment operator + * + * \param flame the object to assign + * \returns the assigned value + */ + FlameProtocol& operator= (const FlameProtocol & flame); /// type conversion operator FlameProtocol (const FlameProtocol &); @@ -173,7 +197,10 @@ class FlameProtocol : public MeshL2RoutingProtocol uint32_t txBytes; ///< transmit bytes uint16_t droppedTtl; ///< dropped TTL uint16_t totalDropped; ///< total dropped - /// Print function + /** + * Print function + * \param os the output stream to print to + */ void Print (std::ostream & os) const; /// constructor Statistics (); diff --git a/src/mesh/model/flame/flame-rtable.h b/src/mesh/model/flame/flame-rtable.h index eff98349fa3..b66058608a0 100644 --- a/src/mesh/model/flame/flame-rtable.h +++ b/src/mesh/model/flame/flame-rtable.h @@ -66,9 +66,16 @@ class FlameRtable : public Object seqnum (s) { } - /// True for valid route + /** + * \returns True for valid route + */ bool IsValid () const; - /// Compare route lookup results, used by tests + /** + * Compare route lookup results, used by tests + * + * \param o the object to compare + * \returns true if equal + */ bool operator== (const LookupResult & o) const; }; public: @@ -81,7 +88,15 @@ class FlameRtable : public Object ~FlameRtable (); void DoDispose (); - /// Add path + /** + * Add path + * + * \param destination the destination address + * \param retransmitter the retransmitter address + * \param interface the interface + * \param cost the cost + * \param seqnum the sequence number + */ void AddPath ( const Mac48Address destination, const Mac48Address retransmitter, @@ -96,8 +111,13 @@ class FlameRtable : public Object */ LookupResult Lookup (Mac48Address destination); private: - /// assignment operator - FlameRtable& operator= (const FlameRtable &); + /** + * assignment operator + * + * \param table the flame table to assign + * \returns the assigned value + */ + FlameRtable& operator= (const FlameRtable & table); /// type conversion operator FlameRtable (const FlameRtable &); diff --git a/src/mesh/model/mesh-l2-routing-protocol.h b/src/mesh/model/mesh-l2-routing-protocol.h index bbd9ec43d16..93daeaf2031 100644 --- a/src/mesh/model/mesh-l2-routing-protocol.h +++ b/src/mesh/model/mesh-l2-routing-protocol.h @@ -44,7 +44,10 @@ class MeshPointDevice; class MeshL2RoutingProtocol : public Object { public: - /// Never forget to support NS3 object model + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /// virtual D-tor for subclasses virtual ~MeshL2RoutingProtocol (); @@ -112,10 +115,18 @@ class MeshL2RoutingProtocol : public Object */ virtual bool RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source, const Mac48Address destination, Ptr< Packet> packet, uint16_t & protocolType) = 0; - /// Set host mesh point, analog of SetNode (...) methods for upper layer protocols. + /** + * Set host mesh point, analog of SetNode (...) methods for upper layer protocols. + * + * \param mp the mesh point device + */ void SetMeshPoint (Ptr mp); - /// Each mesh protocol must be installed on the mesh point to work. + /** + * Each mesh protocol must be installed on the mesh point to work. + * + * \returns the mesh point device + */ Ptr GetMeshPoint () const; protected: diff --git a/src/mesh/model/mesh-point-device.h b/src/mesh/model/mesh-point-device.h index ec21440519d..99de933fda4 100644 --- a/src/mesh/model/mesh-point-device.h +++ b/src/mesh/model/mesh-point-device.h @@ -49,7 +49,10 @@ class Node; class MeshPointDevice : public NetDevice { public: - /// Object type ID for NS3 object system + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /// C-tor create empty (without interfaces and protocols) mesh point MeshPointDevice (); @@ -124,10 +127,27 @@ class MeshPointDevice : public NetDevice //\} private: - /// Receive packet from interface + /** + * Receive packet from interface + * + * \param device the device to receive from + * \param packet the received packet + * \param protocol the protocol + * \param source the source address + * \param destination the destination address + * \param packetType the packet type + */ void ReceiveFromDevice (Ptr device, Ptr packet, uint16_t protocol, Address const &source, Address const &destination, PacketType packetType); - /// Forward packet down to interfaces + /** + * Forward packet down to interfaces + * + * \param incomingPort the incoming port + * \param packet the packet to forward + * \param protocol the protocol + * \param src the source MAC address + * \param dst the destination MAC address + */ void Forward (Ptr incomingPort, Ptr packet, uint16_t protocol, const Mac48Address src, const Mac48Address dst); diff --git a/src/mesh/model/mesh-wifi-beacon.h b/src/mesh/model/mesh-wifi-beacon.h index 969e2622ae9..7b2d8fc7d89 100644 --- a/src/mesh/model/mesh-wifi-beacon.h +++ b/src/mesh/model/mesh-wifi-beacon.h @@ -46,22 +46,38 @@ class MeshWifiBeacon * \param us beacon interval in microseconds */ MeshWifiBeacon (Ssid ssid, SupportedRates rates, uint64_t us); - /// Read standard Wifi beacon header + /** + * Read standard Wifi beacon header + * + * \returns the management beacon header + */ MgtBeaconHeader BeaconHeader () const { return m_header; } - /// Add information element + /** + * Add information element + * + * \param ie the Wifi information element + */ void AddInformationElement (Ptr ie); /** - * Create wifi header for beacon frame. + * Create Wifi header for beacon frame. * * \param address is sender address * \param mpAddress is mesh point address * \returns the WifiMacHeader */ WifiMacHeader CreateHeader (Mac48Address address, Mac48Address mpAddress); - /// Returns a beacon interval of wifi beacon + /** + * Returns the beacon interval of Wifi beacon + * + * \returns the beacon interval time + */ Time GetBeaconInterval () const; - /// Create frame = { beacon header + all information elements sorted by ElementId () } + /** + * Create frame = { beacon header + all information elements sorted by ElementId () } + * + * \returns the frame + */ Ptr CreatePacket (); private: diff --git a/src/mesh/model/mesh-wifi-interface-mac-plugin.h b/src/mesh/model/mesh-wifi-interface-mac-plugin.h index 909c72262e2..081e1dff89a 100644 --- a/src/mesh/model/mesh-wifi-interface-mac-plugin.h +++ b/src/mesh/model/mesh-wifi-interface-mac-plugin.h @@ -43,7 +43,11 @@ class MeshWifiInterfaceMacPlugin : public SimpleRefCount parent) = 0; /** * \brief Process received frame diff --git a/src/mesh/model/mesh-wifi-interface-mac.h b/src/mesh/model/mesh-wifi-interface-mac.h index 3593e9741ef..62d409f1151 100644 --- a/src/mesh/model/mesh-wifi-interface-mac.h +++ b/src/mesh/model/mesh-wifi-interface-mac.h @@ -54,7 +54,10 @@ class UniformRandomVariable; class MeshWifiInterfaceMac : public RegularWifiMac { public: - /// Never forget to support typeid + /** + * \brief Get the type ID. + * \return the object TypeId + */ static TypeId GetTypeId (); /// C-tor MeshWifiInterfaceMac (); @@ -112,7 +115,11 @@ class MeshWifiInterfaceMac : public RegularWifiMac * * Number of channels to use must be limited elsewhere. */ - /// Current channel Id + + /** + * Current channel Id + * \returns the frequency channel + */ uint16_t GetFrequencyChannel () const; /** * Switch frequency channel. @@ -121,7 +128,12 @@ class MeshWifiInterfaceMac : public RegularWifiMac */ void SwitchFrequencyChannel (uint16_t new_id); - /// To be used by plugins sending management frames. + /** + * To be used by plugins sending management frames. + * + * \param frame the management frame + * \param hdr the wifi MAC header + */ void SendManagementFrame (Ptr frame, const WifiMacHeader& hdr); /** * Check supported rates. @@ -141,10 +153,23 @@ class MeshWifiInterfaceMac : public RegularWifiMac void Report (std::ostream &) const; /// Reset statistics void ResetStats (); - /// Enable/disable beacons + /** + * Enable/disable beacons + * + * \param enable enable / disable flag + */ void SetBeaconGeneration (bool enable); - /// Get phy standard in use + /** + * Get phy standard in use + * + * \returns the wifi phy standard + */ WifiPhyStandard GetPhyStandard () const; + /** + * Finish configuration based on the WifiPhyStandard being provided + * + * \param standard the WifiPhyStandard being configured + */ virtual void FinishConfigureStandard (enum WifiPhyStandard standard); /** * Assign a fixed random variable stream number to the random variables @@ -156,15 +181,30 @@ class MeshWifiInterfaceMac : public RegularWifiMac */ int64_t AssignStreams (int64_t stream); private: - /// Frame receive handler - void Receive (Ptr packet, WifiMacHeader const *hdr); - /// Send frame. Frame is supposed to be tagged by routing information. - void ForwardDown (Ptr packet, Mac48Address from, Mac48Address to); + /** + * Frame receive handler + * + * \param packet the received packet + * \param hdr the wifi MAC header + */ + void Receive (Ptr packet, WifiMacHeader const *hdr); + /** + * Send frame. Frame is supposed to be tagged by routing information. + * + * \param packet the packet to forward + * \param from the from address + * \param to the to address + */ + void ForwardDown (Ptr packet, Mac48Address from, Mac48Address to); /// Send beacon void SendBeacon (); /// Schedule next beacon void ScheduleNextBeacon (); - /// Get current beaconing status + /** + * Get current beaconing status + * + * \returns true if beacon active + */ bool GetBeaconGeneration () const; /// Real d-tor virtual void DoDispose (); From 62ab39c9f13e2a4849eee3deff70de60f04be80a Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Sun, 10 Sep 2017 12:45:38 +0200 Subject: [PATCH 231/551] tcp: (fixes 2781) do not go beyond limit in TcpTxBuffer --- src/internet/model/tcp-rx-buffer.cc | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/internet/model/tcp-rx-buffer.cc b/src/internet/model/tcp-rx-buffer.cc index 1f2913518e7..bc1f613b5fd 100644 --- a/src/internet/model/tcp-rx-buffer.cc +++ b/src/internet/model/tcp-rx-buffer.cc @@ -206,7 +206,7 @@ TcpRxBuffer::Add (Ptr p, TcpHeader const& tcph) NS_LOG_LOGIC ("Buffered packet of seqno=" << headSeq << " len=" << p->GetSize ()); // Update variables m_size += p->GetSize (); // Occupancy - for (BufIterator i = m_data.begin (); i != m_data.end (); ++i) + for (i = m_data.begin (); i != m_data.end (); ++i) { if (i->first < m_nextRxSeq) { @@ -285,7 +285,7 @@ TcpRxBuffer::UpdateSackList (const SequenceNumber32 &head, const SequenceNumber3 // Iterates until we examined all blocks in the list (maximum 4) while (it != m_sackList.end ()) { - TcpOptionSack::SackBlock current = *it; + current = *it; // This is a left merge: // [current_first; current_second] [beg_first; beg_second] @@ -339,7 +339,7 @@ TcpRxBuffer::ClearSackList (const SequenceNumber32 &seq) NS_LOG_FUNCTION (this << seq); TcpOptionSack::SackList::iterator it; - for (it = m_sackList.begin (); it != m_sackList.end (); ++it) + for (it = m_sackList.begin (); it != m_sackList.end (); ) { TcpOptionSack::SackBlock block = *it; NS_ASSERT (block.first < block.second); @@ -348,6 +348,10 @@ TcpRxBuffer::ClearSackList (const SequenceNumber32 &seq) { it = m_sackList.erase (it); } + else + { + it++; + } } } From 3e550b51502138506a5f9c59012a4f14414e7f23 Mon Sep 17 00:00:00 2001 From: Tom Henderson Date: Wed, 13 Sep 2017 09:02:46 -0700 Subject: [PATCH 232/551] lte: Fix a maybe-uninitialized compiler warning --- src/lte/model/epc-mme.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/lte/model/epc-mme.cc b/src/lte/model/epc-mme.cc index 384ec738768..0c99ea8c32b 100644 --- a/src/lte/model/epc-mme.cc +++ b/src/lte/model/epc-mme.cc @@ -132,7 +132,8 @@ EpcMme::DoInitialUeMessage (uint64_t mmeUeS1Id, uint16_t enbUeS1Id, uint64_t ims it->second->cellId = gci; EpcS11SapSgw::CreateSessionRequestMessage msg; msg.imsi = imsi; - msg. uli.gci = gci; + msg.uli.gci = gci; + msg.teid = 0; for (std::list::iterator bit = it->second->bearersToBeActivated.begin (); bit != it->second->bearersToBeActivated.end (); ++bit) From 923ef42e42ec2e341574bbc034ed480bf858aec8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Deronne?= Date: Wed, 13 Sep 2017 23:11:38 +0200 Subject: [PATCH 233/551] wifi: Enable beacon jitter by default --- CHANGES.html | 3 +++ examples/wireless/80211e-txop.cc | 8 ++++---- examples/wireless/he-wifi-network.cc | 1 + examples/wireless/ht-wifi-network.cc | 1 + examples/wireless/mixed-network.cc | 2 +- examples/wireless/mixed-wired-wireless.cc | 1 - examples/wireless/simple-ht-hidden-stations.cc | 2 +- examples/wireless/vht-wifi-network.cc | 1 + examples/wireless/wifi-aggregation.cc | 8 ++++---- examples/wireless/wifi-backward-compatibility.cc | 3 +-- src/wifi/model/ap-wifi-mac.cc | 2 +- 11 files changed, 18 insertions(+), 14 deletions(-) diff --git a/CHANGES.html b/CHANGES.html index e7de8cffbea..2cee77ab303 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -173,6 +173,9 @@

          Changed behavior:

        • Queue discs that can operate both in packet mode and byte mode (Red, CoDel, Pie) define their own enum QueueDiscMode instead of using QueueBase::QueueMode.
          • + +
        • The default value of the EnableBeaconJitter attribute in ApWifiMac was changed from false to true. +
          • diff --git a/examples/wireless/80211e-txop.cc b/examples/wireless/80211e-txop.cc index a2dcc2539fe..8e3935e95a2 100644 --- a/examples/wireless/80211e-txop.cc +++ b/examples/wireless/80211e-txop.cc @@ -100,7 +100,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "QosSupported", BooleanValue (true), "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceA = wifi.Install (phy, mac, wifiApNodes.Get (0)); //Network B @@ -115,7 +115,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "QosSupported", BooleanValue (true), "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceB = wifi.Install (phy, mac, wifiApNodes.Get (1)); //Modify EDCA configuration (TXOP limit) for AC_BE @@ -140,7 +140,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "QosSupported", BooleanValue (true), "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceC = wifi.Install (phy, mac, wifiApNodes.Get (2)); //Network D @@ -155,7 +155,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "QosSupported", BooleanValue (true), "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceD = wifi.Install (phy, mac, wifiApNodes.Get (3)); //Modify EDCA configuration (TXOP limit) for AC_VO diff --git a/examples/wireless/he-wifi-network.cc b/examples/wireless/he-wifi-network.cc index 9dcd4bfeac3..88caf382d93 100644 --- a/examples/wireless/he-wifi-network.cc +++ b/examples/wireless/he-wifi-network.cc @@ -125,6 +125,7 @@ int main (int argc, char *argv[]) staDevice = wifi.Install (phy, mac, wifiStaNode); mac.SetType ("ns3::ApWifiMac", + "EnableBeaconJitter", BooleanValue (false), "Ssid", SsidValue (ssid)); NetDeviceContainer apDevice; diff --git a/examples/wireless/ht-wifi-network.cc b/examples/wireless/ht-wifi-network.cc index 05778a7ccd6..216e2709735 100644 --- a/examples/wireless/ht-wifi-network.cc +++ b/examples/wireless/ht-wifi-network.cc @@ -141,6 +141,7 @@ int main (int argc, char *argv[]) staDevice = wifi.Install (phy, mac, wifiStaNode); mac.SetType ("ns3::ApWifiMac", + "EnableBeaconJitter", BooleanValue (false), "Ssid", SsidValue (ssid)); NetDeviceContainer apDevice; diff --git a/examples/wireless/mixed-network.cc b/examples/wireless/mixed-network.cc index 6db509596f3..2b3e9482524 100644 --- a/examples/wireless/mixed-network.cc +++ b/examples/wireless/mixed-network.cc @@ -193,7 +193,7 @@ Experiment::Run (Parameters params) wifi.SetStandard (params.apType); mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true), + "EnableBeaconJitter", BooleanValue (false), "BE_MaxAmpduSize", UintegerValue (0), "BE_BlockAckThreshold", UintegerValue (2), "RifsSupported", BooleanValue (params.rifsSupported), diff --git a/examples/wireless/mixed-wired-wireless.cc b/examples/wireless/mixed-wired-wireless.cc index 614f6116335..483b1bc7acc 100644 --- a/examples/wireless/mixed-wired-wireless.cc +++ b/examples/wireless/mixed-wired-wireless.cc @@ -296,7 +296,6 @@ main (int argc, char *argv[]) // setup ap. macInfra.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true), "BeaconInterval", TimeValue (Seconds (2.5))); NetDeviceContainer apDevices = wifiInfra.Install (wifiPhy, macInfra, backbone.Get (i)); // Collect all of these new devices diff --git a/examples/wireless/simple-ht-hidden-stations.cc b/examples/wireless/simple-ht-hidden-stations.cc index 1cda4194ba9..f4d2af66d48 100644 --- a/examples/wireless/simple-ht-hidden-stations.cc +++ b/examples/wireless/simple-ht-hidden-stations.cc @@ -106,7 +106,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true), + "EnableBeaconJitter", BooleanValue (false), "BE_MaxAmpduSize", UintegerValue (maxAmpduSize)); NetDeviceContainer apDevice; diff --git a/examples/wireless/vht-wifi-network.cc b/examples/wireless/vht-wifi-network.cc index 2d15a28ebb9..1fbfeaafe26 100644 --- a/examples/wireless/vht-wifi-network.cc +++ b/examples/wireless/vht-wifi-network.cc @@ -130,6 +130,7 @@ int main (int argc, char *argv[]) staDevice = wifi.Install (phy, mac, wifiStaNode); mac.SetType ("ns3::ApWifiMac", + "EnableBeaconJitter", BooleanValue (false), "Ssid", SsidValue (ssid)); NetDeviceContainer apDevice; diff --git a/examples/wireless/wifi-aggregation.cc b/examples/wireless/wifi-aggregation.cc index 588b1e28bff..35b183fcd25 100644 --- a/examples/wireless/wifi-aggregation.cc +++ b/examples/wireless/wifi-aggregation.cc @@ -109,7 +109,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceA = wifi.Install (phy, mac, wifiApNodes.Get (0)); //Network B @@ -123,7 +123,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceB = wifi.Install (phy, mac, wifiApNodes.Get (1)); //Network C @@ -138,7 +138,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceC = wifi.Install (phy, mac, wifiApNodes.Get (2)); //Network D @@ -153,7 +153,7 @@ int main (int argc, char *argv[]) mac.SetType ("ns3::ApWifiMac", "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "EnableBeaconJitter", BooleanValue (false)); apDeviceD = wifi.Install (phy, mac, wifiApNodes.Get (3)); /* Setting mobility model */ diff --git a/examples/wireless/wifi-backward-compatibility.cc b/examples/wireless/wifi-backward-compatibility.cc index 61cc306ee48..bbf7caf1d07 100644 --- a/examples/wireless/wifi-backward-compatibility.cc +++ b/examples/wireless/wifi-backward-compatibility.cc @@ -133,8 +133,7 @@ int main (int argc, char *argv[]) wifi.SetRemoteStationManager ("ns3::" + apRaa + "WifiManager"); mac.SetType ("ns3::ApWifiMac", - "Ssid", SsidValue (ssid), - "BeaconGeneration", BooleanValue (true)); + "Ssid", SsidValue (ssid)); NetDeviceContainer apDevice; apDevice = wifi.Install (phy, mac, wifiApNode); diff --git a/src/wifi/model/ap-wifi-mac.cc b/src/wifi/model/ap-wifi-mac.cc index c3930bc3046..64147d83663 100644 --- a/src/wifi/model/ap-wifi-mac.cc +++ b/src/wifi/model/ap-wifi-mac.cc @@ -55,7 +55,7 @@ ApWifiMac::GetTypeId (void) MakePointerChecker ()) .AddAttribute ("EnableBeaconJitter", "If beacons are enabled, whether to jitter the initial send event.", - BooleanValue (false), + BooleanValue (true), MakeBooleanAccessor (&ApWifiMac::m_enableBeaconJitter), MakeBooleanChecker ()) .AddAttribute ("BeaconGeneration", From 59cd4d5f557c929e97127abe3d3e427bfc3fb306 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Thu, 14 Sep 2017 18:12:19 +0200 Subject: [PATCH 234/551] traffic-control: (fixes #2751) Ensure queue discs keep correct statistics --- CHANGES.html | 8 + RELEASE_NOTES | 1 + examples/traffic-control/traffic-control.cc | 22 +- src/network/utils/queue.h | 4 + src/traffic-control/doc/queue-discs.rst | 24 +- src/traffic-control/model/codel-queue-disc.cc | 12 +- .../model/fq-codel-queue-disc.cc | 2 +- .../model/pfifo-fast-queue-disc.cc | 8 +- src/traffic-control/model/pie-queue-disc.cc | 8 +- src/traffic-control/model/queue-disc.cc | 269 +++++++++++------- src/traffic-control/model/queue-disc.h | 197 +++++++------ src/traffic-control/model/red-queue-disc.cc | 8 +- 12 files changed, 338 insertions(+), 225 deletions(-) diff --git a/CHANGES.html b/CHANGES.html index 2cee77ab303..9ede259519e 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -95,6 +95,14 @@

          New API:

        • MqQueueDisc, a multi-queue aware queue disc modelled after the mq qdisc in Linux, has been introduced.
          • +
        • Added QueueDisc::GetStats() which returns detailed statistics about the operations of a queue disc. + Consequently, a number of methods of the QueueDisc class have been removed: GetTotalReceivedPackets(), + GetTotalReceivedBytes(), GetTotalDroppedPackets(), GetTotalDroppedBytes(), + GetTotalRequeuedPackets(), GetTotalRequeuedBytes(). +
          • +
        • Two new methods, QueueDisc::DropBeforeEnqueue() and QueueDisc::DropAfterDequeue() have + been introduced to replace QueueDisc::Drop(). Correspondingly, two new trace sources have been added to the QueueDisc class: DropBeforeEnqueue and DropAfterDequeue. +

          • Changes to existing API:

            diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 55957649e26..2b29ce9ee75 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -107,6 +107,7 @@ Bugs fixed - Bug 2733 - Ideal wifi manager cannot handle NSS higher than 1 - Bug 2741 - IPv4 fragmentation fails when last fragment have to be re-fragmented. - Bug 2744 - 802.11n/ac with RTS/CTS is crashing for a large number of nodes +- Bug 2751 - QueueDisc::Enqueue() order of operations - Bug 2757 - 802.11n/ac/ax maximum TXOP is not properly enforced - Bug 2758 - IPv4 sockets bound to unicast receive also subnet-directed broadcasts - Bug 2759 - Packets sent to broadcast address are converted to subnet-directed broadcast diff --git a/examples/traffic-control/traffic-control.cc b/examples/traffic-control/traffic-control.cc index 95e2ced0ca2..2febdb46133 100644 --- a/examples/traffic-control/traffic-control.cc +++ b/examples/traffic-control/traffic-control.cc @@ -170,11 +170,11 @@ main (int argc, char *argv[]) Ptr classifier = DynamicCast (flowmon.GetClassifier ()); std::map stats = monitor->GetFlowStats (); std::cout << std::endl << "*** Flow monitor statistics ***" << std::endl; - std::cout << " Tx Packets: " << stats[1].txPackets << std::endl; - std::cout << " Tx Bytes: " << stats[1].txBytes << std::endl; + std::cout << " Tx Packets/Bytes: " << stats[1].txPackets + << " / " << stats[1].txBytes << std::endl; std::cout << " Offered Load: " << stats[1].txBytes * 8.0 / (stats[1].timeLastTxPacket.GetSeconds () - stats[1].timeFirstTxPacket.GetSeconds ()) / 1000000 << " Mbps" << std::endl; - std::cout << " Rx Packets: " << stats[1].rxPackets << std::endl; - std::cout << " Rx Bytes: " << stats[1].rxBytes << std::endl; + std::cout << " Rx Packets/Bytes: " << stats[1].rxPackets + << " / " << stats[1].rxBytes << std::endl; uint32_t packetsDroppedByQueueDisc = 0; uint64_t bytesDroppedByQueueDisc = 0; if (stats[1].packetsDropped.size () > Ipv4FlowProbe::DROP_QUEUE_DISC) @@ -182,8 +182,8 @@ main (int argc, char *argv[]) packetsDroppedByQueueDisc = stats[1].packetsDropped[Ipv4FlowProbe::DROP_QUEUE_DISC]; bytesDroppedByQueueDisc = stats[1].bytesDropped[Ipv4FlowProbe::DROP_QUEUE_DISC]; } - std::cout << " Packets Dropped by Queue Disc: " << packetsDroppedByQueueDisc << std::endl; - std::cout << " Bytes Dropped by Queue Disc: " << bytesDroppedByQueueDisc << std::endl; + std::cout << " Packets/Bytes Dropped by Queue Disc: " << packetsDroppedByQueueDisc + << " / " << bytesDroppedByQueueDisc << std::endl; uint32_t packetsDroppedByNetDevice = 0; uint64_t bytesDroppedByNetDevice = 0; if (stats[1].packetsDropped.size () > Ipv4FlowProbe::DROP_QUEUE) @@ -191,8 +191,8 @@ main (int argc, char *argv[]) packetsDroppedByNetDevice = stats[1].packetsDropped[Ipv4FlowProbe::DROP_QUEUE]; bytesDroppedByNetDevice = stats[1].bytesDropped[Ipv4FlowProbe::DROP_QUEUE]; } - std::cout << " Packets Dropped by NetDevice: " << packetsDroppedByNetDevice << std::endl; - std::cout << " Bytes Dropped by NetDevice: " << bytesDroppedByNetDevice << std::endl; + std::cout << " Packets/Bytes Dropped by NetDevice: " << packetsDroppedByNetDevice + << " / " << bytesDroppedByNetDevice << std::endl; std::cout << " Throughput: " << stats[1].rxBytes * 8.0 / (stats[1].timeLastRxPacket.GetSeconds () - stats[1].timeFirstRxPacket.GetSeconds ()) / 1000000 << " Mbps" << std::endl; std::cout << " Mean delay: " << stats[1].delaySum.GetSeconds () / stats[1].rxPackets << std::endl; std::cout << " Mean jitter: " << stats[1].jitterSum.GetSeconds () / (stats[1].rxPackets - 1) << std::endl; @@ -212,10 +212,6 @@ main (int argc, char *argv[]) std::cout << " Rx Bytes: " << totalPacketsThr << std::endl; std::cout << " Average Goodput: " << thr << " Mbit/s" << std::endl; std::cout << std::endl << "*** TC Layer statistics ***" << std::endl; - std::cout << " Packets dropped by the TC layer: " << q->GetTotalDroppedPackets () << std::endl; - std::cout << " Bytes dropped by the TC layer: " << q->GetTotalDroppedBytes () << std::endl; - std::cout << " Packets dropped by the netdevice: " << queue->GetTotalDroppedPackets () << std::endl; - std::cout << " Packets requeued by the TC layer: " << q->GetTotalRequeuedPackets () << std::endl; - + std::cout << q->GetStats () << std::endl; return 0; } diff --git a/src/network/utils/queue.h b/src/network/utils/queue.h index 6085f1fa97f..80626a982c2 100644 --- a/src/network/utils/queue.h +++ b/src/network/utils/queue.h @@ -552,6 +552,10 @@ Queue::DoRemove (ConstIterator pos) m_nBytes -= item->GetSize (); m_nPackets--; + // packets are first dequeued and then dropped + NS_LOG_LOGIC ("m_traceDequeue (p)"); + m_traceDequeue (item); + DropAfterDequeue (item); } return item; diff --git a/src/traffic-control/doc/queue-discs.rst b/src/traffic-control/doc/queue-discs.rst index bc1d84279b8..ac9dd110385 100644 --- a/src/traffic-control/doc/queue-discs.rst +++ b/src/traffic-control/doc/queue-discs.rst @@ -50,10 +50,26 @@ queue disc and within the device. The traffic control layer interacts with a queue disc in a simple manner: after requesting to enqueue a packet, the traffic control layer requests the qdisc to "run", i.e., to dequeue a set of packets, until a predefined number ("quota") of packets is dequeued -or the netdevice stops the queue disc. A netdevice may stop the queue disc when its -transmission queue(s) is/are (almost) full. Also, a netdevice may wake the -queue disc when its transmission queue(s) is/are (almost) empty. Waking a queue disc -is equivalent to make it run. +or the netdevice stops the queue disc. A netdevice shall +stop the queue disc when its transmission queue does not have room for another +packet. Also, a netdevice shall wake the queue disc when it detects that there +is room for another packet in its transmission queue, but the transmission queue +is stopped. Waking a queue disc is equivalent to make it run. + +Every queue disc collects statistics about the total number of packets/bytes +received from the upper layers (in case of root queue disc) or from the parent +queue disc (in case of child queue disc), enqueued, dequeued, requeued, dropped, +dropped before enqueue, dropped after dequeue, stored in the queue disc and +sent to the netdevice or to the parent queue disc. Note that packets that are +dequeued may be requeued, i.e., retained by the traffic control infrastructure, +if the netdevice is not ready to receive them. Requeued packets are not part +of the queue disc. The following identities hold: + +* dropped = dropped before enqueue + dropped after dequeue +* received = dropped before enqueue + enqueued +* queued = enqueued - dequeued +* sent = dequeued - dropped after dequeue (- 1 if there is a requeued packet) + Design ========== diff --git a/src/traffic-control/model/codel-queue-disc.cc b/src/traffic-control/model/codel-queue-disc.cc index 6ffae47ffe9..3961db8a337 100644 --- a/src/traffic-control/model/codel-queue-disc.cc +++ b/src/traffic-control/model/codel-queue-disc.cc @@ -281,7 +281,7 @@ CoDelQueueDisc::DoEnqueue (Ptr item) if (m_mode == QUEUE_DISC_MODE_PACKETS && (GetInternalQueue (0)->GetNPackets () + 1 > m_maxPackets)) { NS_LOG_LOGIC ("Queue full (at max packets) -- droppping pkt"); - Drop (item); + DropBeforeEnqueue (item); ++m_dropOverLimit; return false; } @@ -289,7 +289,7 @@ CoDelQueueDisc::DoEnqueue (Ptr item) if (m_mode == QUEUE_DISC_MODE_BYTES && (GetInternalQueue (0)->GetNBytes () + item->GetSize () > m_maxBytes)) { NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- droppping pkt"); - Drop (item); + DropBeforeEnqueue (item); ++m_dropOverLimit; return false; } @@ -300,8 +300,8 @@ CoDelQueueDisc::DoEnqueue (Ptr item) bool retval = GetInternalQueue (0)->Enqueue (item); - // If Queue::Enqueue fails, QueueDisc::Drop is called by the internal queue - // because QueueDisc::AddInternalQueue sets the drop callback + // If Queue::Enqueue fails, QueueDisc::DropBeforeEnqueue is called by the + // internal queue because QueueDisc::AddInternalQueue sets the trace callback NS_LOG_LOGIC ("Number packets " << GetInternalQueue (0)->GetNPackets ()); NS_LOG_LOGIC ("Number bytes " << GetInternalQueue (0)->GetNBytes ()); @@ -400,7 +400,7 @@ CoDelQueueDisc::DoDequeue (void) // rates so high that the next drop should happen now, // hence the while loop. NS_LOG_LOGIC ("Sojourn time is still above target and it's time for next drop; dropping " << item); - Drop (item); + DropAfterDequeue (item); ++m_dropCount; ++m_count; @@ -440,7 +440,7 @@ CoDelQueueDisc::DoDequeue (void) // Drop the first packet and enter dropping state unless the queue is empty NS_LOG_LOGIC ("Sojourn time goes above target, dropping the first packet " << item << " and entering the dropping state"); ++m_dropCount; - Drop (item); + DropAfterDequeue (item); item = GetInternalQueue (0)->Dequeue (); diff --git a/src/traffic-control/model/fq-codel-queue-disc.cc b/src/traffic-control/model/fq-codel-queue-disc.cc index a2df93794b0..674eef47f77 100644 --- a/src/traffic-control/model/fq-codel-queue-disc.cc +++ b/src/traffic-control/model/fq-codel-queue-disc.cc @@ -162,7 +162,7 @@ FqCoDelQueueDisc::DoEnqueue (Ptr item) if (ret == PacketFilter::PF_NO_MATCH) { NS_LOG_ERROR ("No filter has been able to classify this packet, drop it."); - Drop (item); + DropBeforeEnqueue (item); return false; } diff --git a/src/traffic-control/model/pfifo-fast-queue-disc.cc b/src/traffic-control/model/pfifo-fast-queue-disc.cc index bfc372f4444..3348a4f0686 100644 --- a/src/traffic-control/model/pfifo-fast-queue-disc.cc +++ b/src/traffic-control/model/pfifo-fast-queue-disc.cc @@ -65,10 +65,10 @@ PfifoFastQueueDisc::DoEnqueue (Ptr item) { NS_LOG_FUNCTION (this << item); - if (GetNPackets () > m_limit) + if (GetNPackets () >= m_limit) { NS_LOG_LOGIC ("Queue disc limit exceeded -- dropping packet"); - Drop (item); + DropBeforeEnqueue (item); return false; } @@ -83,8 +83,8 @@ PfifoFastQueueDisc::DoEnqueue (Ptr item) bool retval = GetInternalQueue (band)->Enqueue (item); - // If Queue::Enqueue fails, QueueDisc::Drop is called by the internal queue - // because QueueDisc::AddInternalQueue sets the drop callback + // If Queue::Enqueue fails, QueueDisc::DropBeforeEnqueue is called by the + // internal queue because QueueDisc::AddInternalQueue sets the trace callback NS_LOG_LOGIC ("Number packets band " << band << ": " << GetInternalQueue (band)->GetNPackets ()); diff --git a/src/traffic-control/model/pie-queue-disc.cc b/src/traffic-control/model/pie-queue-disc.cc index 36b0c62f54a..4bffd331862 100644 --- a/src/traffic-control/model/pie-queue-disc.cc +++ b/src/traffic-control/model/pie-queue-disc.cc @@ -197,14 +197,14 @@ PieQueueDisc::DoEnqueue (Ptr item) || (GetMode () == QUEUE_DISC_MODE_BYTES && nQueued + item->GetSize () > m_queueLimit)) { // Drops due to queue limit: reactive - Drop (item); + DropBeforeEnqueue (item); m_stats.forcedDrop++; return false; } else if (DropEarly (item, nQueued)) { // Early probability drop: proactive - Drop (item); + DropBeforeEnqueue (item); m_stats.unforcedDrop++; return false; } @@ -212,8 +212,8 @@ PieQueueDisc::DoEnqueue (Ptr item) // No drop bool retval = GetInternalQueue (0)->Enqueue (item); - // If Queue::Enqueue fails, QueueDisc::Drop is called by the internal queue - // because QueueDisc::AddInternalQueue sets the drop callback + // If Queue::Enqueue fails, QueueDisc::DropBeforeEnqueue is called by the + // internal queue because QueueDisc::AddInternalQueue sets the trace callback NS_LOG_LOGIC ("\t bytesInQueue " << GetInternalQueue (0)->GetNBytes ()); NS_LOG_LOGIC ("\t packetsInQueue " << GetInternalQueue (0)->GetNPackets ()); diff --git a/src/traffic-control/model/queue-disc.cc b/src/traffic-control/model/queue-disc.cc index cf06007072d..575d93010c6 100644 --- a/src/traffic-control/model/queue-disc.cc +++ b/src/traffic-control/model/queue-disc.cc @@ -86,6 +86,61 @@ QueueDiscClass::SetQueueDisc (Ptr qd) m_queueDisc = qd; } +QueueDisc::Stats::Stats () + : nTotalReceivedPackets (0), + nTotalReceivedBytes (0), + nTotalSentPackets (0), + nTotalSentBytes (0), + nTotalEnqueuedPackets (0), + nTotalEnqueuedBytes (0), + nTotalDequeuedPackets (0), + nTotalDequeuedBytes (0), + nTotalDroppedPackets (0), + nTotalDroppedPacketsBeforeEnqueue (0), + nTotalDroppedPacketsAfterDequeue (0), + nTotalDroppedBytes (0), + nTotalDroppedBytesBeforeEnqueue (0), + nTotalDroppedBytesAfterDequeue (0), + nTotalRequeuedPackets (0), + nTotalRequeuedBytes (0) +{ +} + +void +QueueDisc::Stats::Print (std::ostream &os) const +{ + os << std::endl << "Packets/Bytes received: " + << nTotalReceivedPackets << " / " + << nTotalReceivedBytes + << std::endl << "Packets/Bytes enqueued: " + << nTotalEnqueuedPackets << " / " + << nTotalEnqueuedBytes + << std::endl << "Packets/Bytes dequeued: " + << nTotalDequeuedPackets << " / " + << nTotalDequeuedBytes + << std::endl << "Packets/Bytes requeued: " + << nTotalRequeuedPackets << " / " + << nTotalRequeuedBytes + << std::endl << "Packets/Bytes dropped: " + << nTotalDroppedPackets << " / " + << nTotalDroppedBytes + << std::endl << "Packets/Bytes dropped before enqueue: " + << nTotalDroppedPacketsBeforeEnqueue << " / " + << nTotalDroppedBytesBeforeEnqueue + << std::endl << "Packets/Bytes dropped after dequeue: " + << nTotalDroppedPacketsAfterDequeue << " / " + << nTotalDroppedBytesAfterDequeue + << std::endl << "Packets/Bytes sent: " + << nTotalSentPackets << " / " + << nTotalSentBytes + << std::endl; +} + +std::ostream & operator << (std::ostream &os, const QueueDisc::Stats &stats) +{ + stats.Print (os); + return os; +} NS_OBJECT_ENSURE_REGISTERED (QueueDisc); @@ -123,6 +178,12 @@ TypeId QueueDisc::GetTypeId (void) .AddTraceSource ("Drop", "Drop a packet stored in the queue disc", MakeTraceSourceAccessor (&QueueDisc::m_traceDrop), "ns3::QueueDiscItem::TracedCallback") + .AddTraceSource ("DropBeforeEnqueue", "Drop a packet before enqueue", + MakeTraceSourceAccessor (&QueueDisc::m_traceDropBeforeEnqueue), + "ns3::QueueDiscItem::TracedCallback") + .AddTraceSource ("DropAfterDequeue", "Drop a packet after dequeue", + MakeTraceSourceAccessor (&QueueDisc::m_traceDropAfterDequeue), + "ns3::QueueDiscItem::TracedCallback") .AddTraceSource ("PacketsInQueue", "Number of packets currently stored in the queue disc", MakeTraceSourceAccessor (&QueueDisc::m_nPackets), @@ -138,12 +199,6 @@ TypeId QueueDisc::GetTypeId (void) QueueDisc::QueueDisc () : m_nPackets (0), m_nBytes (0), - m_nTotalReceivedPackets (0), - m_nTotalReceivedBytes (0), - m_nTotalDroppedPackets (0), - m_nTotalDroppedBytes (0), - m_nTotalRequeuedPackets (0), - m_nTotalRequeuedBytes (0), m_running (false) { NS_LOG_FUNCTION (this); @@ -194,60 +249,37 @@ QueueDisc::DoInitialize (void) Object::DoInitialize (); } -uint32_t -QueueDisc::GetNPackets () const -{ - NS_LOG_FUNCTION (this); - return m_nPackets; -} - -uint32_t -QueueDisc::GetNBytes (void) const -{ - NS_LOG_FUNCTION (this); - return m_nBytes; -} - -uint32_t -QueueDisc::GetTotalReceivedPackets (void) const +const QueueDisc::Stats& +QueueDisc::GetStats (void) { - NS_LOG_FUNCTION (this); - return m_nTotalReceivedPackets; -} + NS_ASSERT (m_stats.nTotalDroppedPackets == m_stats.nTotalDroppedPacketsBeforeEnqueue + + m_stats.nTotalDroppedPacketsAfterDequeue); + NS_ASSERT (m_stats.nTotalDroppedBytes == m_stats.nTotalDroppedBytesBeforeEnqueue + + m_stats.nTotalDroppedBytesAfterDequeue); -uint32_t -QueueDisc::GetTotalReceivedBytes (void) const -{ - NS_LOG_FUNCTION (this); - return m_nTotalReceivedBytes; -} + // the total number of sent packets is only updated here to avoid to increase it + // after a dequeue and then having to decrease it if the packet is dropped after + // dequeue or requeued + m_stats.nTotalSentPackets = m_stats.nTotalDequeuedPackets - (m_requeued ? 1 : 0) + - m_stats.nTotalDroppedPacketsAfterDequeue; + m_stats.nTotalSentBytes = m_stats.nTotalDequeuedBytes - (m_requeued ? m_requeued->GetSize () : 0) + - m_stats.nTotalDroppedBytesAfterDequeue; -uint32_t -QueueDisc::GetTotalDroppedPackets (void) const -{ - NS_LOG_FUNCTION (this); - return m_nTotalDroppedPackets; + return m_stats; } uint32_t -QueueDisc:: GetTotalDroppedBytes (void) const -{ - NS_LOG_FUNCTION (this); - return m_nTotalDroppedBytes; -} - -uint32_t -QueueDisc::GetTotalRequeuedPackets (void) const +QueueDisc::GetNPackets () const { NS_LOG_FUNCTION (this); - return m_nTotalRequeuedPackets; + return m_nPackets; } uint32_t -QueueDisc:: GetTotalRequeuedBytes (void) const +QueueDisc::GetNBytes (void) const { NS_LOG_FUNCTION (this); - return m_nTotalRequeuedBytes; + return m_nBytes; } void @@ -282,9 +314,16 @@ void QueueDisc::AddInternalQueue (Ptr queue) { NS_LOG_FUNCTION (this); - // set the drop callback on the internal queue, so that the queue disc is - // notified of packets dropped by the internal queue - queue->TraceConnectWithoutContext ("Drop", MakeCallback (&QueueDisc::Drop, this)); + // set various callbacks on the internal queue, so that the queue disc is + // notified of packets enqueued, dequeued or dropped by the internal queue + queue->TraceConnectWithoutContext ("Enqueue", + MakeCallback (&QueueDisc::PacketEnqueued, this)); + queue->TraceConnectWithoutContext ("Dequeue", + MakeCallback (&QueueDisc::PacketDequeued, this)); + queue->TraceConnectWithoutContext ("DropBeforeEnqueue", + MakeCallback (&QueueDisc::DropBeforeEnqueue, this)); + queue->TraceConnectWithoutContext ("DropAfterDequeue", + MakeCallback (&QueueDisc::DropAfterDequeue, this)); m_queues.push_back (queue); } @@ -330,9 +369,16 @@ QueueDisc::AddQueueDiscClass (Ptr qdClass) // such queue discs do not implement the enqueue/dequeue methods NS_ABORT_MSG_IF (qdClass->GetQueueDisc ()->GetWakeMode () == WAKE_CHILD, "A queue disc with WAKE_CHILD as wake mode can only be a root queue disc"); - // set the parent drop callback on the child queue disc, so that it can notify - // packet drops to the parent queue disc - qdClass->GetQueueDisc ()->SetParentDropCallback (MakeCallback (&QueueDisc::Drop, this)); + // set the parent callbacks on the child queue disc, so that it can notify + // the parent queue disc of packets enqueued, dequeued or dropped + qdClass->GetQueueDisc ()->TraceConnectWithoutContext ("Enqueue", + MakeCallback (&QueueDisc::PacketEnqueued, this)); + qdClass->GetQueueDisc ()->TraceConnectWithoutContext ("Dequeue", + MakeCallback (&QueueDisc::PacketDequeued, this)); + qdClass->GetQueueDisc ()->TraceConnectWithoutContext ("DropBeforeEnqueue", + MakeCallback (&QueueDisc::DropBeforeEnqueue, this)); + qdClass->GetQueueDisc ()->TraceConnectWithoutContext ("DropAfterDequeue", + MakeCallback (&QueueDisc::DropAfterDequeue, this)); m_classes.push_back (qdClass); } @@ -370,49 +416,57 @@ QueueDisc::GetWakeMode (void) const } void -QueueDisc::SetParentDropCallback (ParentDropCallback cb) +QueueDisc::PacketEnqueued (Ptr item) { - m_parentDropCallback = cb; + m_nPackets++; + m_nBytes += item->GetSize (); + m_stats.nTotalEnqueuedPackets++; + m_stats.nTotalEnqueuedBytes += item->GetSize (); + + NS_LOG_LOGIC ("m_traceEnqueue (p)"); + m_traceEnqueue (item); } void -QueueDisc::Drop (Ptr item) +QueueDisc::PacketDequeued (Ptr item) { - NS_LOG_FUNCTION (this << item); + m_nPackets--; + m_nBytes -= item->GetSize (); + m_stats.nTotalDequeuedPackets++; + m_stats.nTotalDequeuedBytes += item->GetSize (); - // if the wake mode of this queue disc is WAKE_CHILD, packets are directly - // enqueued/dequeued from the child queue discs, thus this queue disc does not - // keep valid packets/bytes counters and no actions need to be performed. - if (this->GetWakeMode () == WAKE_CHILD) - { - return; - } + NS_LOG_LOGIC ("m_traceDequeue (p)"); + m_traceDequeue (item); +} - NS_ASSERT_MSG (m_nPackets >= 1u, "No packet in the queue disc, cannot drop"); - NS_ASSERT_MSG (m_nBytes >= item->GetSize (), "The size of the packet that" - << " is reported to be dropped is greater than the amount of bytes" - << "stored in the queue disc"); +void +QueueDisc::DropBeforeEnqueue (Ptr item) +{ + NS_LOG_FUNCTION (this << item); - m_nPackets--; - m_nBytes -= item->GetSize (); - m_nTotalDroppedPackets++; - m_nTotalDroppedBytes += item->GetSize (); + m_stats.nTotalDroppedPackets++; + m_stats.nTotalDroppedBytes += item->GetSize (); + m_stats.nTotalDroppedPacketsBeforeEnqueue++; + m_stats.nTotalDroppedBytesBeforeEnqueue += item->GetSize (); - NS_LOG_LOGIC ("m_traceDrop (p)"); + NS_LOG_LOGIC ("m_traceDropBeforeEnqueue (p)"); m_traceDrop (item); - - NotifyParentDrop (item); + m_traceDropBeforeEnqueue (item); } void -QueueDisc::NotifyParentDrop (Ptr item) +QueueDisc::DropAfterDequeue (Ptr item) { NS_LOG_FUNCTION (this << item); - // the parent drop callback is clearly null on root queue discs - if (!m_parentDropCallback.IsNull ()) - { - m_parentDropCallback (item); - } + + m_stats.nTotalDroppedPackets++; + m_stats.nTotalDroppedBytes += item->GetSize (); + m_stats.nTotalDroppedPacketsAfterDequeue++; + m_stats.nTotalDroppedBytesAfterDequeue += item->GetSize (); + + NS_LOG_LOGIC ("m_traceDropAfterDequeue (p)"); + m_traceDrop (item); + m_traceDropAfterDequeue (item); } bool @@ -420,15 +474,29 @@ QueueDisc::Enqueue (Ptr item) { NS_LOG_FUNCTION (this << item); - m_nPackets++; - m_nBytes += item->GetSize (); - m_nTotalReceivedPackets++; - m_nTotalReceivedBytes += item->GetSize (); + m_stats.nTotalReceivedPackets++; + m_stats.nTotalReceivedBytes += item->GetSize (); - NS_LOG_LOGIC ("m_traceEnqueue (p)"); - m_traceEnqueue (item); + bool retval = DoEnqueue (item); - return DoEnqueue (item); + // DoEnqueue may return false because: + // 1) the internal queue is full + // -> the DropBeforeEnqueue method of this queue disc is automatically called + // because QueueDisc::AddInternalQueue sets the trace callback + // 2) the child queue disc dropped the packet + // -> the DropBeforeEnqueue method of this queue disc is automatically called + // because QueueDisc::AddQueueDiscClass sets the trace callback + // 3) it dropped the packet + // -> DoEnqueue has to explicitly call DropBeforeEnqueue + // Thus, we do not have to call DropBeforeEnqueue here. + + // check that the received packet was either enqueued or dropped + NS_ASSERT (m_stats.nTotalReceivedPackets == m_stats.nTotalDroppedPacketsBeforeEnqueue + + m_stats.nTotalEnqueuedPackets); + NS_ASSERT (m_stats.nTotalReceivedBytes == m_stats.nTotalDroppedBytesBeforeEnqueue + + m_stats.nTotalEnqueuedBytes); + + return retval; } Ptr @@ -436,17 +504,10 @@ QueueDisc::Dequeue (void) { NS_LOG_FUNCTION (this); - Ptr item; - item = DoDequeue (); + Ptr item = DoDequeue (); - if (item != 0) - { - m_nPackets--; - m_nBytes -= item->GetSize (); - - NS_LOG_LOGIC ("m_traceDequeue (p)"); - m_traceDequeue (item); - } + NS_ASSERT (m_nPackets == m_stats.nTotalEnqueuedPackets - m_stats.nTotalDequeuedPackets); + NS_ASSERT (m_nBytes == m_stats.nTotalEnqueuedBytes - m_stats.nTotalDequeuedBytes); return item; } @@ -530,12 +591,6 @@ QueueDisc::DequeuePacket () { item = m_requeued; m_requeued = 0; - - m_nPackets--; - m_nBytes -= item->GetSize (); - - NS_LOG_LOGIC ("m_traceDequeue (p)"); - m_traceDequeue (item); } } else @@ -566,10 +621,8 @@ QueueDisc::Requeue (Ptr item) m_requeued = item; /// \todo netif_schedule (q); - m_nPackets++; // it's still part of the queue - m_nBytes += item->GetSize (); - m_nTotalRequeuedPackets++; - m_nTotalRequeuedBytes += item->GetSize (); + m_stats.nTotalRequeuedPackets++; + m_stats.nTotalRequeuedBytes += item->GetSize (); NS_LOG_LOGIC ("m_traceRequeue (p)"); m_traceRequeue (item); diff --git a/src/traffic-control/model/queue-disc.h b/src/traffic-control/model/queue-disc.h index fdf4cd80e0a..2b74f80dc97 100644 --- a/src/traffic-control/model/queue-disc.h +++ b/src/traffic-control/model/queue-disc.h @@ -107,19 +107,80 @@ class QueueDiscClass : public Object { * An attempt is made, also, to enqueue each packet in the "same" queue both within the * queue disc and within the device. * - * The traffic control layer interacts with a queue disc in a simple manner: after requesting - * to enqueue a packet, the traffic control layer requests the qdisc to "run", i.e., to - * dequeue a set of packets, until a predefined number ("quota") of packets is dequeued - * or the netdevice stops the queue disc. A netdevice may stop the queue disc when its - * transmission queue(s) is/are (almost) full. Also, a netdevice may wake the - * queue disc when its transmission queue(s) is/are (almost) empty. Waking a queue disc - * is equivalent to make it run. + * The traffic control layer interacts with a queue disc in a simple manner: after + * requesting to enqueue a packet, the traffic control layer requests the qdisc to + * "run", i.e., to dequeue a set of packets, until a predefined number ("quota") + * of packets is dequeued or the netdevice stops the queue disc. A netdevice shall + * stop the queue disc when its transmission queue does not have room for another + * packet. Also, a netdevice shall wake the queue disc when it detects that there + * is room for another packet in its transmission queue, but the transmission queue + * is stopped. Waking a queue disc is equivalent to make it run. + * + * Every queue disc collects statistics about the total number of packets/bytes + * received from the upper layers (in case of root queue disc) or from the parent + * queue disc (in case of child queue disc), enqueued, dequeued, requeued, dropped, + * dropped before enqueue, dropped after dequeue, queued in the queue disc and + * sent to the netdevice or to the parent queue disc. Note that packets that are + * dequeued may be requeued, i.e., retained by the traffic control infrastructure, + * if the netdevice is not ready to receive them. Requeued packets are not part + * of the queue disc. The following identities hold: + * - dropped = dropped before enqueue + dropped after dequeue + * - received = dropped before enqueue + enqueued + * - queued = enqueued - dequeued + * - sent = dequeued - dropped after dequeue (- 1 if there is a requeued packet) * * The design and implementation of this class is heavily inspired by Linux. * For more details, see the traffic-control model page. */ class QueueDisc : public Object { public: + + /// \brief Structure that keeps the queue disc statistics + struct Stats + { + /// Total received packets + uint32_t nTotalReceivedPackets; + /// Total received bytes + uint64_t nTotalReceivedBytes; + /// Total sent packets -- this value is not kept up to date, call GetStats first + uint32_t nTotalSentPackets; + /// Total sent bytes -- this value is not kept up to date, call GetStats first + uint64_t nTotalSentBytes; + /// Total enqueued packets + uint32_t nTotalEnqueuedPackets; + /// Total enqueued bytes + uint64_t nTotalEnqueuedBytes; + /// Total dequeued packets + uint32_t nTotalDequeuedPackets; + /// Total dequeued bytes + uint64_t nTotalDequeuedBytes; + /// Total dropped packets + uint32_t nTotalDroppedPackets; + /// Total packets dropped before enqueue + uint32_t nTotalDroppedPacketsBeforeEnqueue; + /// Total packets dropped after dequeue + uint32_t nTotalDroppedPacketsAfterDequeue; + /// Total dropped bytes + uint64_t nTotalDroppedBytes; + /// Total bytes dropped before enqueue + uint64_t nTotalDroppedBytesBeforeEnqueue; + /// Total bytes dropped after dequeue + uint64_t nTotalDroppedBytesAfterDequeue; + /// Total requeued packets + uint32_t nTotalRequeuedPackets; + /// Total requeued bytes + uint64_t nTotalRequeuedBytes; + + /// constructor + Stats (); + + /** + * \brief Print the statistics. + * \param os output stream in which the data should be printed. + */ + void Print (std::ostream &os) const; + }; + /** * \brief Get the type ID. * \return the object TypeId @@ -133,12 +194,7 @@ class QueueDisc : public Object { * \brief Get the number of packets stored by the queue disc * \return the number of packets stored by the queue disc. * - * Note that the number of packets stored by the queue disc is updated as soon - * as a packet is received by the queue disc and before actually enqueuing the - * packet (i.e., before calling DoEnqueue). Thus, while implementing the DoEnqueue - * method of a subclass, keep in mind that GetNPackets returns the number of - * packets stored in the queue disc, including the packet that we are trying - * to enqueue. + * The requeued packet, if any, is counted. */ uint32_t GetNPackets (void) const; @@ -146,50 +202,15 @@ class QueueDisc : public Object { * \brief Get the amount of bytes stored by the queue disc * \return the amount of bytes stored by the queue disc. * - * Note that the amount of bytes stored by the queue disc is updated as soon - * as a packet is received by the queue disc and before actually enqueuing the - * packet (i.e., before calling DoEnqueue). Thus, while implementing the DoEnqueue - * method of a subclass, keep in mind that GetNBytes returns the amount of - * bytes stored in the queue disc, including the size of the packet that we are - * trying to enqueue. + * The requeued packet, if any, is counted. */ uint32_t GetNBytes (void) const; /** - * \brief Get the total number of received packets - * \return the total number of received packets. - */ - uint32_t GetTotalReceivedPackets (void) const; - - /** - * \brief Get the total amount of received bytes - * \return the total amount of received bytes. + * \brief Retrieve all the collected statistics. + * \return the collected statistics. */ - uint32_t GetTotalReceivedBytes (void) const; - - /** - * \brief Get the total number of dropped packets - * \return the total number of dropped packets. - */ - uint32_t GetTotalDroppedPackets (void) const; - - /** - * \brief Get the total amount of dropped bytes - * \return the total amount of dropped bytes. - */ - uint32_t GetTotalDroppedBytes (void) const; - - /** - * \brief Get the total number of requeued packets - * \return the total number of requeued packets. - */ - uint32_t GetTotalRequeuedPackets (void) const; - - /** - * \brief Get the total amount of requeued bytes - * \return the total amount of requeued bytes. - */ - uint32_t GetTotalRequeuedBytes (void) const; + const Stats& GetStats (void); /** * \brief Set the NetDevice on which this queue discipline is installed. @@ -341,18 +362,6 @@ class QueueDisc : public Object { */ virtual WakeMode GetWakeMode (void) const; - /// Callback invoked by a child queue disc to notify the parent of a packet drop - typedef Callback > ParentDropCallback; - - /** - * \brief Set the parent drop callback - * \param cb the callback to set - * - * Called when a queue disc class is added to a queue disc in order to set a - * callback to the Drop method of the parent queue disc. - */ - virtual void SetParentDropCallback (ParentDropCallback cb); - protected: /** * \brief Dispose of the object @@ -369,11 +378,22 @@ class QueueDisc : public Object { void DoInitialize (void); /** - * \brief Drop a packet + * \brief Perform the actions required when the queue disc is notified of + * a packet dropped before enqueue + * \param item item that was dropped + * This method must be called by subclasses to notify parent (this class) of a packet + * dropped before enqueue + */ + void DropBeforeEnqueue (Ptr item); + + /** + * \brief Perform the actions required when the queue disc is notified of + * a packet dropped after dequeue * \param item item that was dropped - * This method is called by subclasses to notify parent (this class) of packet drops. + * This method must be called by subclasses to notify parent (this class) of a packet + * dropped after dequeue */ - void Drop (Ptr item); + void DropAfterDequeue (Ptr item); private: /** @@ -393,12 +413,6 @@ class QueueDisc : public Object { */ QueueDisc &operator = (const QueueDisc &o); - /** - * \brief Notify the parent queue disc of a packet drop - * \param item item that was dropped - */ - void NotifyParentDrop (Ptr item); - /** * This function actually enqueues a packet into the queue disc. * \param item item to enqueue @@ -472,6 +486,20 @@ class QueueDisc : public Object { */ bool Transmit (Ptr item); + /** + * \brief Perform the actions required when the queue disc is notified of + * a packet enqueue + * \param item item that was enqueued + */ + void PacketEnqueued (Ptr item); + + /** + * \brief Perform the actions required when the queue disc is notified of + * a packet dequeue + * \param item item that was dequeued + */ + void PacketDequeued (Ptr item); + static const uint32_t DEFAULT_QUOTA = 64; //!< Default quota (as in /proc/sys/net/core/dev_weight) std::vector > m_queues; //!< Internal queues @@ -481,29 +509,36 @@ class QueueDisc : public Object { TracedValue m_nPackets; //!< Number of packets in the queue TracedValue m_nBytes; //!< Number of bytes in the queue - uint32_t m_nTotalReceivedPackets; //!< Total received packets - uint32_t m_nTotalReceivedBytes; //!< Total received bytes - uint32_t m_nTotalDroppedPackets; //!< Total dropped packets - uint32_t m_nTotalDroppedBytes; //!< Total dropped bytes - uint32_t m_nTotalRequeuedPackets; //!< Total requeued packets - uint32_t m_nTotalRequeuedBytes; //!< Total requeued bytes + Stats m_stats; //!< The collected statistics uint32_t m_quota; //!< Maximum number of packets dequeued in a qdisc run Ptr m_device; //!< The NetDevice on which this queue discipline is installed Ptr m_devQueueIface; //!< NetDevice queue interface bool m_running; //!< The queue disc is performing multiple dequeue operations Ptr m_requeued; //!< The last packet that failed to be transmitted - ParentDropCallback m_parentDropCallback; //!< Parent drop callback /// Traced callback: fired when a packet is enqueued TracedCallback > m_traceEnqueue; /// Traced callback: fired when a packet is dequeued TracedCallback > m_traceDequeue; - /// Traced callback: fired when a packet is requeued + /// Traced callback: fired when a packet is requeued TracedCallback > m_traceRequeue; /// Traced callback: fired when a packet is dropped TracedCallback > m_traceDrop; + /// Traced callback: fired when a packet is dropped before enqueue + TracedCallback > m_traceDropBeforeEnqueue; + /// Traced callback: fired when a packet is dropped after dequeue + TracedCallback > m_traceDropAfterDequeue; }; +/** + * \brief Stream insertion operator. + * + * \param os the stream + * \param stats the queue disc statistics + * \returns a reference to the stream + */ +std::ostream& operator<< (std::ostream& os, const QueueDisc::Stats &stats); + } // namespace ns3 #endif /* QueueDisc */ diff --git a/src/traffic-control/model/red-queue-disc.cc b/src/traffic-control/model/red-queue-disc.cc index 742df887f34..49791b8e538 100644 --- a/src/traffic-control/model/red-queue-disc.cc +++ b/src/traffic-control/model/red-queue-disc.cc @@ -457,7 +457,7 @@ RedQueueDisc::DoEnqueue (Ptr item) { NS_LOG_DEBUG ("\t Dropping due to Prob Mark " << m_qAvg); m_stats.unforcedDrop++; - Drop (item); + DropBeforeEnqueue (item); return false; } NS_LOG_DEBUG ("\t Marking due to Prob Mark " << m_qAvg); @@ -469,7 +469,7 @@ RedQueueDisc::DoEnqueue (Ptr item) { NS_LOG_DEBUG ("\t Dropping due to Hard Mark " << m_qAvg); m_stats.forcedDrop++; - Drop (item); + DropBeforeEnqueue (item); if (m_isNs1Compat) { m_count = 0; @@ -488,8 +488,8 @@ RedQueueDisc::DoEnqueue (Ptr item) m_stats.qLimDrop++; } - // If Queue::Enqueue fails, QueueDisc::Drop is called by the internal queue - // because QueueDisc::AddInternalQueue sets the drop callback + // If Queue::Enqueue fails, QueueDisc::DropBeforeEnqueue is called by the + // internal queue because QueueDisc::AddInternalQueue sets the trace callback NS_LOG_LOGIC ("Number packets " << GetInternalQueue (0)->GetNPackets ()); NS_LOG_LOGIC ("Number bytes " << GetInternalQueue (0)->GetNBytes ()); From 090d37b19e6627605dc4afbeee75f74463bf8871 Mon Sep 17 00:00:00 2001 From: Stefano Avallone Date: Thu, 14 Sep 2017 18:12:23 +0200 Subject: [PATCH 235/551] traffic-control: Trace sojourn times within queue discs --- CHANGES.html | 5 +++++ examples/traffic-control/traffic-control.cc | 11 ++++++++--- src/network/utils/queue-item.cc | 14 ++++++++++++++ src/network/utils/queue-item.h | 14 ++++++++++++++ src/traffic-control/doc/queue-discs.rst | 7 +++++++ src/traffic-control/model/queue-disc.cc | 13 +++++++++++++ src/traffic-control/model/queue-disc.h | 8 ++++++++ 7 files changed, 69 insertions(+), 3 deletions(-) diff --git a/CHANGES.html b/CHANGES.html index 9ede259519e..e2f7365fa4d 100644 --- a/CHANGES.html +++ b/CHANGES.html @@ -103,6 +103,11 @@

            New API:

          • Two new methods, QueueDisc::DropBeforeEnqueue() and QueueDisc::DropAfterDequeue() have been introduced to replace QueueDisc::Drop(). Correspondingly, two new trace sources have been added to the QueueDisc class: DropBeforeEnqueue and DropAfterDequeue.
            • +
          • A new trace source, SojournTime, is exported by the QueueDisc base class to provide the + sojourn time of every packet dequeued from a queue disc. This has been made possible by adding a + timestamp to QueueDiscItem objects, which can be set/get through the new GetTimeStamp() and + SetTimeStamp() methods of the QueueDiscItem class. +

          Changes to existing API:

            diff --git a/examples/traffic-control/traffic-control.cc b/examples/traffic-control/traffic-control.cc index 2febdb46133..7a0fd116859 100644 --- a/examples/traffic-control/traffic-control.cc +++ b/examples/traffic-control/traffic-control.cc @@ -78,6 +78,12 @@ DevicePacketsInQueueTrace (uint32_t oldValue, uint32_t newValue) std::cout << "DevicePacketsInQueue " << oldValue << " to " << newValue << std::endl; } +void +SojournTimeTrace (Time oldValue, Time newValue) +{ + std::cout << "Sojourn time " << newValue << std::endl; +} + int main (int argc, char *argv[]) { @@ -120,9 +126,8 @@ main (int argc, char *argv[]) Ptr q = qdiscs.Get (1); q->TraceConnectWithoutContext ("PacketsInQueue", MakeCallback (&TcPacketsInQueueTrace)); - // Alternatively: - // Config::ConnectWithoutContext ("/NodeList/1/$ns3::TrafficControlLayer/RootQueueDiscList/0/PacketsInQueue", - // MakeCallback (&TcPacketsInQueueTrace)); + Config::ConnectWithoutContext ("/NodeList/1/$ns3::TrafficControlLayer/RootQueueDiscList/0/SojournTime", + MakeCallback (&SojournTimeTrace)); Ptr nd = devices.Get (1); Ptr ptpnd = DynamicCast (nd); diff --git a/src/network/utils/queue-item.cc b/src/network/utils/queue-item.cc index 259bbc58c14..aab3b330d13 100644 --- a/src/network/utils/queue-item.cc +++ b/src/network/utils/queue-item.cc @@ -115,6 +115,20 @@ QueueDiscItem::SetTxQueueIndex (uint8_t txq) m_txq = txq; } +Time +QueueDiscItem::GetTimeStamp (void) const +{ + NS_LOG_FUNCTION (this); + return m_tstamp; +} + +void +QueueDiscItem::SetTimeStamp (Time t) +{ + NS_LOG_FUNCTION (this << t); + m_tstamp = t; +} + void QueueDiscItem::Print (std::ostream& os) const { diff --git a/src/network/utils/queue-item.h b/src/network/utils/queue-item.h index 3d267d89abf..18fb7c6359f 100644 --- a/src/network/utils/queue-item.h +++ b/src/network/utils/queue-item.h @@ -23,6 +23,7 @@ #include "ns3/ptr.h" #include "ns3/simple-ref-count.h" #include +#include "ns3/nstime.h" namespace ns3 { @@ -180,6 +181,18 @@ class QueueDiscItem : public QueueItem { */ void SetTxQueueIndex (uint8_t txq); + /** + * \brief Get the timestamp included in this item + * \return the timestamp included in this item. + */ + Time GetTimeStamp (void) const; + + /** + * \brief Set the timestamp included in this item + * \param t the timestamp to include in this item. + */ + void SetTimeStamp (Time t); + /** * \brief Add the header to the packet * @@ -226,6 +239,7 @@ class QueueDiscItem : public QueueItem { Address m_address; //!< MAC destination address uint16_t m_protocol; //!< L3 Protocol number uint8_t m_txq; //!< Transmission queue index + Time m_tstamp; //!< timestamp when the packet was enqueued }; } // namespace ns3 diff --git a/src/traffic-control/doc/queue-discs.rst b/src/traffic-control/doc/queue-discs.rst index ac9dd110385..fe9e7208629 100644 --- a/src/traffic-control/doc/queue-discs.rst +++ b/src/traffic-control/doc/queue-discs.rst @@ -70,6 +70,13 @@ of the queue disc. The following identities hold: * queued = enqueued - dequeued * sent = dequeued - dropped after dequeue (- 1 if there is a requeued packet) +The QueueDisc base class provides the SojournTime trace source, which provides +the sojourn time of every packet dequeued from a queue disc, including packets +that are dropped or requeued after being dequeued. The sojourn time is taken +when the packet is dequeued from the queue disc, hence it does not account for +the additional time the packet is retained within the queue disc in case it is +requeued. + Design ========== diff --git a/src/traffic-control/model/queue-disc.cc b/src/traffic-control/model/queue-disc.cc index 575d93010c6..95f14b5161f 100644 --- a/src/traffic-control/model/queue-disc.cc +++ b/src/traffic-control/model/queue-disc.cc @@ -25,6 +25,7 @@ #include "ns3/packet.h" #include "ns3/socket.h" #include "ns3/unused.h" +#include "ns3/simulator.h" #include "queue-disc.h" #include #include "ns3/net-device-queue-interface.h" @@ -192,6 +193,10 @@ TypeId QueueDisc::GetTypeId (void) "Number of bytes currently stored in the queue disc", MakeTraceSourceAccessor (&QueueDisc::m_nBytes), "ns3::TracedValueCallback::Uint32") + .AddTraceSource ("SojournTime", + "Sojourn time of the last packet dequeued from the queue disc", + MakeTraceSourceAccessor (&QueueDisc::m_sojourn), + "ns3::Time::TracedValueCallback") ; return tid; } @@ -199,6 +204,7 @@ TypeId QueueDisc::GetTypeId (void) QueueDisc::QueueDisc () : m_nPackets (0), m_nBytes (0), + m_sojourn (0), m_running (false) { NS_LOG_FUNCTION (this); @@ -435,6 +441,8 @@ QueueDisc::PacketDequeued (Ptr item) m_stats.nTotalDequeuedPackets++; m_stats.nTotalDequeuedBytes += item->GetSize (); + m_sojourn = Simulator::Now () - item->GetTimeStamp (); + NS_LOG_LOGIC ("m_traceDequeue (p)"); m_traceDequeue (item); } @@ -479,6 +487,11 @@ QueueDisc::Enqueue (Ptr item) bool retval = DoEnqueue (item); + if (retval) + { + item->SetTimeStamp (Simulator::Now ()); + } + // DoEnqueue may return false because: // 1) the internal queue is full // -> the DropBeforeEnqueue method of this queue disc is automatically called diff --git a/src/traffic-control/model/queue-disc.h b/src/traffic-control/model/queue-disc.h index 2b74f80dc97..7763f891a17 100644 --- a/src/traffic-control/model/queue-disc.h +++ b/src/traffic-control/model/queue-disc.h @@ -129,6 +129,13 @@ class QueueDiscClass : public Object { * - queued = enqueued - dequeued * - sent = dequeued - dropped after dequeue (- 1 if there is a requeued packet) * + * The QueueDisc base class provides the SojournTime trace source, which provides + * the sojourn time of every packet dequeued from a queue disc, including packets + * that are dropped or requeued after being dequeued. The sojourn time is taken + * when the packet is dequeued from the queue disc, hence it does not account for + * the additional time the packet is retained within the queue disc in case it is + * requeued. + * * The design and implementation of this class is heavily inspired by Linux. * For more details, see the traffic-control model page. */ @@ -508,6 +515,7 @@ class QueueDisc : public Object { TracedValue m_nPackets; //!< Number of packets in the queue TracedValue m_nBytes; //!< Number of bytes in the queue + TracedValue

          Changes to existing API:

          diff --git a/src/traffic-control/model/codel-queue-disc.cc b/src/traffic-control/model/codel-queue-disc.cc index 3961db8a337..257fdd6a811 100644 --- a/src/traffic-control/model/codel-queue-disc.cc +++ b/src/traffic-control/model/codel-queue-disc.cc @@ -65,85 +65,6 @@ static uint32_t CoDelGetTime (void) return ns >> CODEL_SHIFT; } -/** - * CoDel time stamp, used to carry CoDel time informations. - */ -class CoDelTimestampTag : public Tag -{ -public: - CoDelTimestampTag (); - /** - * \brief Get the type ID. - * \return the object TypeId - */ - static TypeId GetTypeId (void); - virtual TypeId GetInstanceTypeId (void) const; - - virtual uint32_t GetSerializedSize (void) const; - virtual void Serialize (TagBuffer i) const; - virtual void Deserialize (TagBuffer i); - virtual void Print (std::ostream &os) const; - - /** - * Gets the Tag creation time - * @return the time object stored in the tag - */ - Time GetTxTime (void) const; -private: - uint64_t m_creationTime; //!< Tag creation time -}; - -CoDelTimestampTag::CoDelTimestampTag () - : m_creationTime (Simulator::Now ().GetTimeStep ()) -{ -} - -TypeId -CoDelTimestampTag::GetTypeId (void) -{ - static TypeId tid = TypeId ("ns3::CoDelTimestampTag") - .SetParent () - .AddConstructor () - .AddAttribute ("CreationTime", - "The time at which the timestamp was created", - StringValue ("0.0s"), - MakeTimeAccessor (&CoDelTimestampTag::GetTxTime), - MakeTimeChecker ()) - ; - return tid; -} - -TypeId -CoDelTimestampTag::GetInstanceTypeId (void) const -{ - return GetTypeId (); -} - -uint32_t -CoDelTimestampTag::GetSerializedSize (void) const -{ - return 8; -} -void -CoDelTimestampTag::Serialize (TagBuffer i) const -{ - i.WriteU64 (m_creationTime); -} -void -CoDelTimestampTag::Deserialize (TagBuffer i) -{ - m_creationTime = i.ReadU64 (); -} -void -CoDelTimestampTag::Print (std::ostream &os) const -{ - os << "CreationTime=" << m_creationTime; -} -Time -CoDelTimestampTag::GetTxTime (void) const -{ - return TimeStep (m_creationTime); -} NS_OBJECT_ENSURE_REGISTERED (CoDelQueueDisc); @@ -200,10 +121,6 @@ TypeId CoDelQueueDisc::GetTypeId (void) "Dropping state", MakeTraceSourceAccessor (&CoDelQueueDisc::m_dropping), "ns3::TracedValueCallback::Bool") - .AddTraceSource ("Sojourn", - "Time in the queue", - MakeTraceSourceAccessor (&CoDelQueueDisc::m_sojourn), - "ns3::Time::TracedValueCallback") .AddTraceSource ("DropNext", "Time until next packet drop", MakeTraceSourceAccessor (&CoDelQueueDisc::m_dropNext), @@ -227,8 +144,7 @@ CoDelQueueDisc::CoDelQueueDisc () m_state2 (0), m_state3 (0), m_states (0), - m_dropOverLimit (0), - m_sojourn (0) + m_dropOverLimit (0) { NS_LOG_FUNCTION (this); } @@ -280,7 +196,7 @@ CoDelQueueDisc::DoEnqueue (Ptr item) if (m_mode == QUEUE_DISC_MODE_PACKETS && (GetInternalQueue (0)->GetNPackets () + 1 > m_maxPackets)) { - NS_LOG_LOGIC ("Queue full (at max packets) -- droppping pkt"); + NS_LOG_LOGIC ("Queue full (at max packets) -- dropping pkt"); DropBeforeEnqueue (item); ++m_dropOverLimit; return false; @@ -288,16 +204,12 @@ CoDelQueueDisc::DoEnqueue (Ptr item) if (m_mode == QUEUE_DISC_MODE_BYTES && (GetInternalQueue (0)->GetNBytes () + item->GetSize () > m_maxBytes)) { - NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- droppping pkt"); + NS_LOG_LOGIC ("Queue full (packet would exceed max bytes) -- dropping pkt"); DropBeforeEnqueue (item); ++m_dropOverLimit; return false; } - // Tag packet with current time for DoDequeue() to compute sojourn time - CoDelTimestampTag tag; - p->AddPacketTag (tag); - bool retval = GetInternalQueue (0)->Enqueue (item); // If Queue::Enqueue fails, QueueDisc::DropBeforeEnqueue is called by the @@ -313,7 +225,6 @@ bool CoDelQueueDisc::OkToDrop (Ptr item, uint32_t now) { NS_LOG_FUNCTION (this); - CoDelTimestampTag tag; bool okToDrop; if (!item) @@ -322,12 +233,8 @@ CoDelQueueDisc::OkToDrop (Ptr item, uint32_t now) return false; } - bool found = item->GetPacket ()->RemovePacketTag (tag); - NS_ASSERT_MSG (found, "found a packet without an input timestamp tag"); - NS_UNUSED (found); //silence compiler warning - Time delta = Simulator::Now () - tag.GetTxTime (); - NS_LOG_INFO ("Sojourn time " << delta.GetSeconds ()); - m_sojourn = delta; + Time delta = Simulator::Now () - item->GetTimeStamp (); + NS_LOG_INFO ("Sojourn time " << delta.ToDouble (Time::MS) << "ms"); uint32_t sojournTime = Time2CoDel (delta); if (CoDelTimeBefore (sojournTime, Time2CoDel (m_target)) diff --git a/src/traffic-control/model/codel-queue-disc.h b/src/traffic-control/model/codel-queue-disc.h index e44314459c4..1f71fb2813a 100644 --- a/src/traffic-control/model/codel-queue-disc.h +++ b/src/traffic-control/model/codel-queue-disc.h @@ -254,7 +254,6 @@ class CoDelQueueDisc : public QueueDisc uint32_t m_states; //!< Total number of times we are in state 1, state 2, or state 3 uint32_t m_dropOverLimit; //!< The number of packets dropped due to full queue QueueDiscMode m_mode; //!< The operating mode (Bytes or packets) - TracedValue