code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231
values | license stringclasses 13
values | size int64 1 2.01M |
|---|---|---|---|---|---|
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef SS_SERVICE_FLOW_MANAGER_H
#define SS_SERVICE_FLOW_MANAGER_H
#include <stdint.h>
#include "ns3/event-id.h"
#include "mac-messages.h"
#include "ns3/buffer.h"
#include "service-flow-manager.h"
#include "ss-net-device.h"
namespace ns3 {
class Packet;
class ServiceFlow;
class WimaxNetDevice;
class WimaxConnection;
class SubscriberStationNetDevice;
/**
* \ingroup wimax
*/
class SsServiceFlowManager : public ServiceFlowManager
{
public:
enum ConfirmationCode // as per Table 384 (not all codes implemented)
{
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
*/
SsServiceFlowManager (Ptr<SubscriberStationNetDevice> device);
~SsServiceFlowManager (void);
void DoDispose (void);
/**
* \brief add a service flow to the list
* \param serviceFlow the service flow to add
*/
void AddServiceFlow (ServiceFlow *serviceFlow);
/**
* \brief add a service flow to the list
* \param serviceFlow the service flow to add
*/
void AddServiceFlow (ServiceFlow serviceFlow);
/**
* \brief sets the maximum retries on DSA request message
* \param maxDsaReqRetries the maximum retries on DSA request message
*/
void SetMaxDsaReqRetries (uint8_t maxDsaReqRetries);
/**
* \return the maximum retries on DSA request message
*/
uint8_t GetMaxDsaReqRetries (void) const;
EventId GetDsaRspTimeoutEvent (void) const;
EventId GetDsaAckTimeoutEvent (void) const;
void InitiateServiceFlows (void);
DsaReq CreateDsaReq (const ServiceFlow *serviceFlow);
Ptr<Packet> CreateDsaAck (void);
void ScheduleDsaReq (const ServiceFlow *serviceFlow);
void ProcessDsaRsp (const DsaRsp &dsaRsp);
private:
Ptr<SubscriberStationNetDevice> m_device;
uint32_t m_sfidIndex;
uint8_t m_maxDsaReqRetries;
EventId m_dsaRspTimeoutEvent;
EventId m_dsaAckTimeoutEvent;
DsaReq m_dsaReq;
DsaAck m_dsaAck;
uint16_t m_currentTransactionId;
uint16_t m_transactionIdIndex;
uint8_t m_dsaReqRetries;
// pointer to the service flow currently being configured
ServiceFlow *m_pendingServiceFlow;
};
} // namespace ns3
#endif /* SS_SERVICE_FLOW_MANAGER_H */
| zy901002-gpsr | src/wimax/model/ss-service-flow-manager.h | C++ | gpl2 | 3,109 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 INRIA
* 2009 TELEMATICS LAB, Politecnico di Bari
*
* 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: Giuseppe Piro <g.piro@poliba.it>
*/
#include "bs-uplink-scheduler-rtps.h"
#include "bs-net-device.h"
#include "ns3/simulator.h"
#include "cid.h"
#include "burst-profile-manager.h"
#include "ss-manager.h"
#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "bs-link-manager.h"
#include "bandwidth-manager.h"
NS_LOG_COMPONENT_DEFINE ("UplinkSchedulerRtps");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED ( UplinkSchedulerRtps);
UplinkSchedulerRtps::UplinkSchedulerRtps ()
{
SetBs (0);
SetTimeStampIrInterval (Seconds (0));
SetNrIrOppsAllocated (0);
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
SetDcdTimeStamp (Simulator::Now ());
SetUcdTimeStamp (Simulator::Now ());
}
UplinkSchedulerRtps::UplinkSchedulerRtps (Ptr<BaseStationNetDevice> bs)
{
SetBs (bs);
SetTimeStampIrInterval (Seconds (0));
SetNrIrOppsAllocated (0);
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
SetDcdTimeStamp (Simulator::Now ());
SetUcdTimeStamp (Simulator::Now ());
}
UplinkSchedulerRtps::~UplinkSchedulerRtps (void)
{
SetBs (0);
m_uplinkAllocations.clear ();
}
TypeId
UplinkSchedulerRtps::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::UplinkSchedulerRtps").SetParent<UplinkScheduler> ();
return tid;
}
std::list<OfdmUlMapIe>
UplinkSchedulerRtps::GetUplinkAllocations (void) const
{
return m_uplinkAllocations;
}
void
UplinkSchedulerRtps::GetChannelDescriptorsToUpdate (bool &updateDcd, bool &updateUcd, bool &sendDcd, bool &sendUcd)
{
/*DCD and UCD shall actually be updated when channel or burst profile definitions
change. burst profiles are updated based on number of SSs, network conditions and etc.
for now temporarily assuming DCD/UCD shall be updated everytime */
uint32_t randNr = rand ();
if (randNr % 5 == 0 || GetBs ()->GetNrDcdSent () == 0)
{
sendDcd = true;
}
randNr = rand ();
if (randNr % 5 == 0 || GetBs ()->GetNrUcdSent () == 0)
{
sendUcd = true;
}
// -------------------------------------
// additional, just to send more frequently
if (!sendDcd)
{
randNr = rand ();
if (randNr % 4 == 0)
{
sendDcd = true;
}
}
if (!sendUcd)
{
randNr = rand ();
if (randNr % 4 == 0)
{
sendUcd = true;
}
}
// -------------------------------------
Time timeSinceLastDcd = Simulator::Now () - GetDcdTimeStamp ();
Time timeSinceLastUcd = Simulator::Now () - GetUcdTimeStamp ();
if (timeSinceLastDcd > GetBs ()->GetDcdInterval ())
{
sendDcd = true;
SetDcdTimeStamp (Simulator::Now ());
}
if (timeSinceLastUcd > GetBs ()->GetUcdInterval ())
{
sendUcd = true;
SetUcdTimeStamp (Simulator::Now ());
}
}
uint32_t
UplinkSchedulerRtps::CalculateAllocationStartTime (void)
{
return GetBs ()->GetNrDlSymbols () * GetBs ()->GetPhy ()->GetPsPerSymbol () + GetBs ()->GetTtg ();
}
void
UplinkSchedulerRtps::AddUplinkAllocation (OfdmUlMapIe &ulMapIe,
const uint32_t &allocationSize,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
ulMapIe.SetDuration (allocationSize);
ulMapIe.SetStartTime (symbolsToAllocation);
m_uplinkAllocations.push_back (ulMapIe);
symbolsToAllocation += allocationSize;
availableSymbols -= allocationSize;
}
void
UplinkSchedulerRtps::Schedule (void)
{
m_uplinkAllocations.clear ();
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
bool allocationForDsa = false;
uint32_t symbolsToAllocation = 0;
uint32_t allocationSize = 0; // size in symbols
uint32_t availableSymbols = GetBs ()->GetNrUlSymbols ();
WimaxPhy::ModulationType modulationType;
Cid cid;
AllocateInitialRangingInterval (symbolsToAllocation, availableSymbols);
std::vector<SSRecord*> *ssRecords = GetBs ()->GetSSManager ()->GetSSRecords ();
NS_LOG_INFO ("UL Scheduler start, availableSymbols = " << availableSymbols);
for (std::vector<SSRecord*>::iterator iter = ssRecords->begin (); iter != ssRecords->end (); ++iter)
{
SSRecord *ssRecord = *iter;
if (ssRecord->GetIsBroadcastSS ())
{
continue;
}
cid = ssRecord->GetBasicCid ();
OfdmUlMapIe ulMapIe;
ulMapIe.SetCid (cid);
if (ssRecord->GetPollForRanging () && ssRecord->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_CONTINUE)
{
// SS's ranging is not yet complete
// allocating invited initial ranging interval
ulMapIe.SetUiuc (OfdmUlBurstProfile::UIUC_INITIAL_RANGING);
allocationSize = GetBs ()->GetRangReqOppSize ();
SetIsInvIrIntrvlAllocated (true);
if (availableSymbols >= allocationSize)
{
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
}
else
{
break;
}
}
else
{
modulationType = ssRecord->GetModulationType ();
// need to update because modulation/FEC to UIUC mapping may vary over time
ulMapIe.SetUiuc (GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_UPLINK));
// establish service flows for SS
if (ssRecord->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_SUCCESS
&& !ssRecord->GetAreServiceFlowsAllocated ())
{
// allocating grant (with arbitrary size) to allow SS to send DSA messages DSA-REQ and DSA-ACK
// only one DSA allocation per frame
if (!allocationForDsa)
{
allocationSize = GetBs ()->GetPhy ()->GetNrSymbols (sizeof(DsaReq), modulationType);
if (availableSymbols >= allocationSize)
{
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
allocationForDsa = true;
}
else
{
break;
}
}
}
else
{
// all service flows associated to SS are established now
/*allocating grants for data transmission for UGS flows (Data Grant Burst Type IEs, 6.3.7.4.3.3)
(grant has been referred by different names e.g. transmission opportunity, slot, uplink allocation, etc)*/
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_UGS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
// allocate unicast polls for rtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_RTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// allocate unicast polls for nrtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_NRTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// finally allocate unicast polls for BE flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_BE,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
}
}
}
/*
* Uplink Scheduler for rtPS Connection
*/
if (availableSymbols)
{
ULSchedulerRTPSConnection (symbolsToAllocation, availableSymbols);
}
// UL Scheduler for nrtPS and BE flows
if (availableSymbols)
{
for (std::vector<SSRecord*>::iterator iter = ssRecords->begin (); iter != ssRecords->end (); ++iter)
{
SSRecord *ssRecord = *iter;
if (ssRecord->GetIsBroadcastSS ())
{
continue;
}
if (!ssRecord->GetPollForRanging () && ssRecord->GetRangingStatus ()
!= WimaxNetDevice::RANGING_STATUS_CONTINUE && ssRecord->GetAreServiceFlowsAllocated ())
{
OfdmUlMapIe ulMapIe;
cid = ssRecord->GetBasicCid ();
ulMapIe.SetCid (cid);
modulationType = ssRecord->GetModulationType ();
ulMapIe.SetUiuc (GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_UPLINK));
// allocate unicast polls for nrtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceBandwidthRequests (ssRecord,
ServiceFlow::SF_TYPE_NRTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// finally allocate unicast polls for BE flows if bandwidth is available
if (availableSymbols)
{
ServiceBandwidthRequests (ssRecord,
ServiceFlow::SF_TYPE_BE,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
}
}
}
OfdmUlMapIe ulMapIeEnd;
ulMapIeEnd.SetCid (Cid::InitialRanging ());
ulMapIeEnd.SetStartTime (symbolsToAllocation);
ulMapIeEnd.SetUiuc (OfdmUlBurstProfile::UIUC_END_OF_MAP);
ulMapIeEnd.SetDuration (0);
m_uplinkAllocations.push_back (ulMapIeEnd);
// setting DL/UL subframe allocation for the next frame
GetBs ()->GetBandwidthManager ()->SetSubframeRatio ();
}
void
UplinkSchedulerRtps::ServiceUnsolicitedGrants (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
uint32_t allocationSize = 0; // size in symbols
uint8_t uiuc = ulMapIe.GetUiuc (); // SS's burst profile
std::vector<ServiceFlow*> serviceFlows = ssRecord->GetServiceFlows (schedulingType);
for (std::vector<ServiceFlow*>::iterator iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
ServiceFlow *serviceFlow = *iter;
/* in case of rtPS, nrtPS and BE, allocating unicast polls for bandwidth requests (Request IEs, 6.3.7.4.3.1).
in case of UGS, allocating grants for data transmission (Data Grant Burst Type IEs, 6.3.7.4.3.3) (grant has
been referred in this code by different names e.g. transmission opportunity, slot, allocation, etc) */
allocationSize = GetBs ()->GetBandwidthManager ()->CalculateAllocationSize (ssRecord, serviceFlow);
// verifying that minimum reserved traffic rate of nrtPS flow is maintained
if (serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_NRTPS)
{
Time currentTime = Simulator::Now ();
ServiceFlowRecord *record = serviceFlow->GetRecord ();
if (currentTime - record->GetGrantTimeStamp () > Seconds (1))
{
uint32_t bps = (record->GetBwSinceLastExpiry () * 8);
if (bps < serviceFlow->GetMinReservedTrafficRate ())
{
ServiceBandwidthRequests (serviceFlow,
schedulingType,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
record->SetBwSinceLastExpiry (0);
record->SetGrantTimeStamp (currentTime);
}
}
}
if (availableSymbols < allocationSize)
{
break;
}
if (allocationSize > 0)
{
ulMapIe.SetStartTime (symbolsToAllocation);
if (serviceFlow->GetSchedulingType () != ServiceFlow::SF_TYPE_UGS)
{
// special burst profile with most robust modulation type is used for unicast polls (Request IEs)
ulMapIe.SetUiuc (OfdmUlBurstProfile::UIUC_REQ_REGION_FULL);
}
}
else
{
continue;
}
if (serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_UGS)
{
NS_LOG_DEBUG ("BS uplink scheduler, UGS allocation, size: " << allocationSize << " symbols");
}
else
{
NS_LOG_DEBUG ("BS uplink scheduler, " << serviceFlow->GetSchedulingTypeStr () << " unicast poll, size: "
<< allocationSize << " symbols" << ", modulation: BPSK 1/2");
}
NS_LOG_DEBUG (", CID: " << serviceFlow->GetConnection ()->GetCid () << ", SFID: " << serviceFlow->GetSfid ());
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
ulMapIe.SetUiuc (uiuc);
}
}
void
UplinkSchedulerRtps::ServiceBandwidthRequests (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
std::vector<ServiceFlow*> serviceFlows = ssRecord->GetServiceFlows (schedulingType);
for (std::vector<ServiceFlow*>::iterator iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
if (!ServiceBandwidthRequests (*iter,
schedulingType,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols))
{
break;
}
}
}
bool
UplinkSchedulerRtps::ServiceBandwidthRequests (ServiceFlow *serviceFlow,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
uint32_t allocSizeBytes = 0;
uint32_t allocSizeSymbols = 0;
uint16_t sduSize = 0;
ServiceFlowRecord *record = serviceFlow->GetRecord ();
sduSize = serviceFlow->GetSduSize ();
uint32_t requiredBandwidth = record->GetRequestedBandwidth () - record->GetGrantedBandwidth ();
if (requiredBandwidth > 0)
{
if (sduSize > 0)
{
// if SDU size is mentioned, allocate grant of that size
allocSizeBytes = sduSize;
allocSizeSymbols = GetBs ()->GetPhy ()->GetNrSymbols (sduSize, modulationType);
}
else
{
allocSizeBytes = requiredBandwidth;
allocSizeSymbols = GetBs ()->GetPhy ()->GetNrSymbols (requiredBandwidth, modulationType);
}
if (availableSymbols >= allocSizeSymbols)
{
NS_LOG_DEBUG ("BS uplink scheduler, " << serviceFlow->GetSchedulingTypeStr () << " allocation, size: "
<< allocSizeSymbols << " symbols" << ", CID: " << serviceFlow->GetConnection ()->GetCid () << ", SFID: "
<< serviceFlow->GetSfid () << ", bw requested: " << record->GetRequestedBandwidth () << ", bw granted: "
<< record->GetGrantedBandwidth ());
record->UpdateGrantedBandwidth (allocSizeBytes);
if (schedulingType == ServiceFlow::SF_TYPE_NRTPS)
{
record->SetBwSinceLastExpiry (allocSizeBytes);
}
AddUplinkAllocation (ulMapIe, allocSizeSymbols, symbolsToAllocation, availableSymbols);
}
else
{
return false;
}
}
return true;
}
void
UplinkSchedulerRtps::ULSchedulerRTPSConnection (uint32_t &symbolsToAllocation, uint32_t &availableSymbols)
{
NS_LOG_INFO ("\tUL Scheduler for rtPS flows");
NS_LOG_INFO ("\t\tavailableSymbols = " << availableSymbols);
ServiceFlowRecord *record_[100];
uint32_t allocSizeSymbols_[100]; // symbolsRequired for each SSRecord
OfdmUlMapIe ulMapIe_[100];
OfdmUlMapIe ulMapIe;
WimaxPhy::ModulationType modulationType_[100];
WimaxPhy::ModulationType modulationType;
int nbAllocation = 0;
uint32_t allocSizeBytes;
uint32_t totAllocSizeSymbols = 0;
Cid cid;
std::vector<SSRecord*> *ssRecords = GetBs ()->GetSSManager ()->GetSSRecords ();
for (std::vector<SSRecord*>::iterator iter = ssRecords->begin (); iter != ssRecords->end (); ++iter)
{
SSRecord *ssRecord = *iter;
if (ssRecord->GetIsBroadcastSS ())
{
continue;
}
if (!ssRecord->GetPollForRanging () && ssRecord->GetRangingStatus () != WimaxNetDevice::RANGING_STATUS_CONTINUE
&& ssRecord->GetAreServiceFlowsAllocated ())
{
cid = ssRecord->GetBasicCid ();
ulMapIe.SetCid (cid);
modulationType = ssRecord->GetModulationType ();
ulMapIe.SetUiuc (GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_UPLINK));
std::vector<ServiceFlow*> serviceFlows = ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_RTPS);
for (std::vector<ServiceFlow*>::iterator iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
record_[nbAllocation] = (*iter2)->GetRecord ();
uint32_t requiredBandwidth = record_[nbAllocation]->GetRequestedBandwidth ()
- record_[nbAllocation]->GetGrantedBandwidth ();
if (requiredBandwidth > 0)
{
modulationType_[nbAllocation] = modulationType;
ulMapIe_[nbAllocation] = ulMapIe;
allocSizeBytes = requiredBandwidth;
allocSizeSymbols_[nbAllocation] = GetBs ()->GetPhy ()->GetNrSymbols (allocSizeBytes,
modulationType_[nbAllocation]);
totAllocSizeSymbols += allocSizeSymbols_[nbAllocation];
NS_LOG_INFO ("\t\tUL Scheduler for CID = " << (*iter2)->GetConnection ()->GetCid ());
NS_LOG_INFO ("\t\t\trequiredBandwidth = " << record_[nbAllocation]->GetRequestedBandwidth ()
<< ", allocSizeSymbols = " << allocSizeSymbols_[nbAllocation] << ", modulationType = "
<< modulationType_[nbAllocation]);
nbAllocation += 1;
}
}
}
}
NS_LOG_INFO ("\t\ttotAllocSizeSymbols = " << totAllocSizeSymbols);
// Channel Saturation
while (totAllocSizeSymbols > availableSymbols)
{
NS_LOG_INFO ("\tUL Channel Saturation: totAllocSizeSymbols > availableSymbols");
double delta = double(availableSymbols) / double(totAllocSizeSymbols);
NS_LOG_INFO ("\t\tdelta = " << delta);
totAllocSizeSymbols = 0;
for (int i = 0; i < nbAllocation; i++)
{
NS_LOG_INFO ("\t\tprevious allocSizeSymbols_[" << i << "] = " << allocSizeSymbols_[i]);
allocSizeSymbols_[i] = (uint32_t) floor (allocSizeSymbols_[i] * delta);
totAllocSizeSymbols += allocSizeSymbols_[i];
NS_LOG_INFO ("\t\tnew allocSizeSymbols_[" << i << "] = " << allocSizeSymbols_[i]);
}
NS_LOG_INFO ("\t\ttotAllocSizeSymbols = " << totAllocSizeSymbols);
}
// Uplink Bandwidth Allocation
for (int i = 0; i < nbAllocation; i++)
{
AddUplinkAllocation (ulMapIe_[i], allocSizeSymbols_[i], symbolsToAllocation, availableSymbols);
allocSizeBytes = GetBs ()->GetPhy ()->GetNrBytes (allocSizeSymbols_[i], modulationType_[i]);
NS_LOG_INFO ("\t\tUpdateGrantedBandwidth for " << i << " = " << allocSizeBytes);
if (record_[i]->GetRequestedBandwidth () < allocSizeBytes)
{
// the flow need new poll to set the newer requredBandwidth
record_[i]->SetGrantedBandwidth (0);
record_[i]->SetRequestedBandwidth (0);
}
else
{
record_[i]->UpdateGrantedBandwidth (allocSizeBytes);
}
}
}
void
UplinkSchedulerRtps::AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols)
{
Time ssUlStartTime = Seconds (CalculateAllocationStartTime () * GetBs ()->GetPsDuration ().GetSeconds ());
SetNrIrOppsAllocated (GetBs ()->GetLinkManager ()->CalculateRangingOppsToAllocate ());
uint32_t allocationSize = GetNrIrOppsAllocated () * GetBs ()->GetRangReqOppSize ();
Time timeSinceLastIrInterval = Simulator::Now () - GetTimeStampIrInterval ();
// adding one frame because may be the time has not elapsed now but will elapse before the next frame is sent
if (timeSinceLastIrInterval + GetBs ()->GetPhy ()->GetFrameDuration () > GetBs ()->GetInitialRangingInterval ()
&& availableSymbols >= allocationSize)
{
SetIsIrIntrvlAllocated (true);
OfdmUlMapIe ulMapIeIr;
ulMapIeIr.SetCid (GetBs ()->GetBroadcastConnection ()->GetCid ());
ulMapIeIr.SetStartTime (symbolsToAllocation);
ulMapIeIr.SetUiuc (OfdmUlBurstProfile::UIUC_INITIAL_RANGING);
NS_LOG_DEBUG ("BS uplink scheduler, initial ranging allocation, size: " << allocationSize << " symbols"
<< ", modulation: BPSK 1/2");
// marking start and end of each TO, only for debugging
for (uint8_t i = 0; i < GetNrIrOppsAllocated (); i++)
{
GetBs ()->MarkRangingOppStart (ssUlStartTime + Seconds (symbolsToAllocation
* GetBs ()->GetSymbolDuration ().GetSeconds ()) + Seconds (i * GetBs ()->GetRangReqOppSize ()
* GetBs ()->GetSymbolDuration ().GetSeconds ()));
}
AddUplinkAllocation (ulMapIeIr, allocationSize, symbolsToAllocation, availableSymbols);
SetTimeStampIrInterval (Simulator::Now ());
}
}
void
UplinkSchedulerRtps::SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow)
{
uint8_t delayNrFrames = 1;
uint32_t bitsPerSecond = serviceFlow->GetMinReservedTrafficRate ();
WimaxPhy::ModulationType modulation;
uint32_t bytesPerFrame =
(uint32_t ((double)(bitsPerSecond) * GetBs ()->GetPhy ()->GetFrameDuration ().GetSeconds ())) / 8;
uint32_t frameDurationMSec = GetBs ()->GetPhy ()->GetFrameDuration ().GetMilliSeconds ();
switch (serviceFlow->GetSchedulingType ())
{
case ServiceFlow::SF_TYPE_UGS:
{
if (serviceFlow->GetIsMulticast () == true)
{
modulation = serviceFlow->GetModulation ();
}
else
{
modulation = ssRecord->GetModulationType ();
}
uint32_t grantSize = GetBs ()->GetPhy ()->GetNrSymbols (bytesPerFrame, modulation);
serviceFlow->GetRecord ()->SetGrantSize (grantSize);
uint32_t toleratedJitter = serviceFlow->GetToleratedJitter ();
if (toleratedJitter > frameDurationMSec)
{
delayNrFrames = (uint8_t)(toleratedJitter / frameDurationMSec);
}
uint16_t interval = delayNrFrames * frameDurationMSec;
serviceFlow->SetUnsolicitedGrantInterval (interval);
}
break;
case ServiceFlow::SF_TYPE_RTPS:
{
if (serviceFlow->GetSduSize () > bytesPerFrame)
{
delayNrFrames = (uint8_t)(serviceFlow->GetSduSize () / bytesPerFrame);
}
uint16_t interval = delayNrFrames * frameDurationMSec;
serviceFlow->SetUnsolicitedPollingInterval (interval);
}
break;
case ServiceFlow::SF_TYPE_NRTPS:
{
// no real-time guarantees are given to NRTPS, serviced based on available bandwidth
}
break;
case ServiceFlow::SF_TYPE_BE:
{
// no real-time guarantees are given to BE, serviced based on available bandwidth
}
break;
default:
NS_FATAL_ERROR ("Invalid scheduling type");
}
}
void
UplinkSchedulerRtps::InitOnce ()
{
}
void
UplinkSchedulerRtps::ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr)
{
}
void
UplinkSchedulerRtps::OnSetRequestedBandwidth (ServiceFlowRecord *sfr)
{
// m_grantedBandwidth must be reset to zero
uint32_t grantedBandwidth = 0;
sfr->SetGrantedBandwidth (grantedBandwidth);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler-rtps.cc | C++ | gpl2 | 27,721 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "service-flow.h"
#include "service-flow-record.h"
#include "ns3/simulator.h"
#include "wimax-tlv.h"
namespace ns3 {
ServiceFlow::ServiceFlow (Direction direction)
{
InitValues ();
m_direction = direction;
m_type = SF_TYPE_PROVISIONED;
m_record = new ServiceFlowRecord ();
m_sfid = 0;
m_connection = 0;
m_isEnabled = false;
m_isMulticast = false;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
}
ServiceFlow::ServiceFlow ()
: m_sfid (0),
m_direction (SF_DIRECTION_DOWN),
m_type (SF_TYPE_PROVISIONED),
m_connection (0),
m_isEnabled (false),
m_record (new ServiceFlowRecord ())
{
InitValues ();
m_isMulticast = false;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
}
ServiceFlow::ServiceFlow (uint32_t sfid, Direction direction, Ptr<WimaxConnection> connection)
{
InitValues ();
m_record = new ServiceFlowRecord ();
m_isEnabled = false;
m_connection = connection;
m_connection->SetServiceFlow (this);
m_type = SF_TYPE_PROVISIONED;
m_direction = direction;
m_sfid = sfid;
m_isMulticast = false;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
}
ServiceFlow::ServiceFlow (Tlv tlv)
{
InitValues ();
m_connection = 0;
m_isEnabled = 0;
m_record = new ServiceFlowRecord ();
NS_ASSERT_MSG (tlv.GetType () == Tlv::UPLINK_SERVICE_FLOW || tlv.GetType () == Tlv::DOWNLINK_SERVICE_FLOW,
"Invalid TLV");
SfVectorTlvValue * param;
param = (SfVectorTlvValue*)(tlv.PeekValue ());
if (tlv.GetType () == Tlv::UPLINK_SERVICE_FLOW)
{
m_direction = SF_DIRECTION_UP;
}
else
{
m_direction = SF_DIRECTION_DOWN;
}
for (std::vector<Tlv*>::const_iterator iter = param->Begin (); iter != param->End (); ++iter)
{
switch ((*iter)->GetType ())
{
case SfVectorTlvValue::SFID:
{
m_sfid = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::CID:
{
uint16_t cid = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
m_connection = CreateObject<WimaxConnection> (cid, Cid::TRANSPORT);
break;
}
case SfVectorTlvValue::QoS_Parameter_Set_Type:
{
m_qosParamSetType = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Traffic_Priority:
{
m_trafficPriority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Maximum_Sustained_Traffic_Rate:
{
m_maxSustainedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Maximum_Traffic_Burst:
{
m_maxTrafficBurst = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Minimum_Reserved_Traffic_Rate:
{
m_minReservedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Minimum_Tolerable_Traffic_Rate:
{
m_minTolerableTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Service_Flow_Scheduling_Type:
{
m_schedulingType = (ServiceFlow::SchedulingType)((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Request_Transmission_Policy:
{
m_requestTransmissionPolicy = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Tolerated_Jitter:
{
m_toleratedJitter = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Maximum_Latency:
{
m_maximumLatency = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::Fixed_length_versus_Variable_length_SDU_Indicator:
{
m_fixedversusVariableSduIndicator = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case SfVectorTlvValue::CS_Specification:
{
m_csSpecification = (enum CsSpecification)(((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ());
break;
}
case SfVectorTlvValue::IPV4_CS_Parameters:
{
m_convergenceSublayerParam = CsParameters (*(*iter));
break;
}
}
}
m_isMulticast = false;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
}
ServiceFlow::~ServiceFlow (void)
{
if (m_record != 0)
{
delete m_record;
m_record = 0;
}
m_connection = 0;
}
void
ServiceFlow::SetDirection (Direction direction)
{
m_direction = direction;
}
ServiceFlow::Direction
ServiceFlow::GetDirection (void) const
{
return m_direction;
}
void
ServiceFlow::SetType (Type type)
{
m_type = type;
}
ServiceFlow::Type
ServiceFlow::GetType (void) const
{
return m_type;
}
void
ServiceFlow::SetConnection (Ptr<WimaxConnection> connection)
{
m_connection = connection;
m_connection->SetServiceFlow (this);
}
Ptr<WimaxConnection>
ServiceFlow::GetConnection (void) const
{
return m_connection;
}
void
ServiceFlow::SetIsEnabled (bool isEnabled)
{
m_isEnabled = isEnabled;
}
bool
ServiceFlow::GetIsEnabled (void) const
{
return m_isEnabled;
}
void
ServiceFlow::SetRecord (ServiceFlowRecord *record)
{
m_record = record;
}
ServiceFlowRecord*
ServiceFlow::GetRecord (void) const
{
return m_record;
}
Ptr<WimaxMacQueue>
ServiceFlow::GetQueue (void) const
{
if (!m_connection)
{
return 0;
}
return m_connection->GetQueue ();
}
enum ServiceFlow::SchedulingType
ServiceFlow::GetSchedulingType (void) const
{
return m_schedulingType;
}
bool
ServiceFlow::HasPackets (void) const
{
if (!m_connection)
{
return false;
}
return m_connection->HasPackets ();
}
bool
ServiceFlow::HasPackets (MacHeaderType::HeaderType packetType) const
{
if (!m_connection)
{
return false;
}
return m_connection->HasPackets (packetType);
}
void
ServiceFlow::CleanUpQueue (void)
{
GenericMacHeader hdr;
Time timeStamp;
Ptr<Packet> packet;
Time currentTime = Simulator::Now ();
if (m_connection)
{
while (m_connection->HasPackets ())
{
packet = m_connection->GetQueue ()->Peek (hdr, timeStamp);
if (currentTime - timeStamp > MilliSeconds (GetMaximumLatency ()))
{
m_connection->Dequeue ();
}
else
{
break;
}
}
}
}
void
ServiceFlow::PrintQoSParameters (void) const
{
}
// ==============================================================================
uint32_t
ServiceFlow::GetSfid (void) const
{
return m_sfid;
}
uint16_t
ServiceFlow::GetCid (void) const
{
if (m_connection == 0)
{
return 0;
}
return m_connection->GetCid ().GetIdentifier ();
}
std::string
ServiceFlow::GetServiceClassName () const
{
return m_serviceClassName;
}
uint8_t
ServiceFlow::GetQosParamSetType (void) const
{
return m_qosParamSetType;
}
uint8_t
ServiceFlow::GetTrafficPriority (void) const
{
return m_trafficPriority;
}
uint32_t
ServiceFlow::GetMaxSustainedTrafficRate (void) const
{
return m_maxSustainedTrafficRate;
}
uint32_t
ServiceFlow::GetMaxTrafficBurst (void) const
{
return m_maxTrafficBurst;
}
uint32_t
ServiceFlow::GetMinReservedTrafficRate (void) const
{
return m_minReservedTrafficRate;
}
uint32_t
ServiceFlow::GetMinTolerableTrafficRate (void) const
{
return m_minTolerableTrafficRate;
}
enum
ServiceFlow::SchedulingType ServiceFlow::GetServiceSchedulingType (void) const
{
return m_schedulingType;
}
uint32_t
ServiceFlow::GetRequestTransmissionPolicy (void) const
{
return m_requestTransmissionPolicy;
}
uint32_t
ServiceFlow::GetToleratedJitter (void) const
{
return m_toleratedJitter;
}
uint32_t
ServiceFlow::GetMaximumLatency (void) const
{
return m_maximumLatency;
}
uint8_t
ServiceFlow::GetFixedversusVariableSduIndicator (void) const
{
return m_fixedversusVariableSduIndicator;
}
uint8_t
ServiceFlow::GetSduSize (void) const
{
return m_sduSize;
}
uint16_t
ServiceFlow::GetTargetSAID (void) const
{
return m_targetSAID;
}
uint8_t
ServiceFlow::GetArqEnable (void) const
{
return m_arqEnable;
}
uint16_t
ServiceFlow::GetArqWindowSize (void) const
{
return m_arqWindowSize;
}
uint16_t
ServiceFlow::GetArqRetryTimeoutTx (void) const
{
return m_arqRetryTimeoutTx;
}
uint16_t
ServiceFlow::GetArqRetryTimeoutRx (void) const
{
return m_arqRetryTimeoutRx;
}
uint16_t
ServiceFlow::GetArqBlockLifeTime (void) const
{
return m_arqBlockLifeTime;
}
uint16_t
ServiceFlow::GetArqSyncLoss (void) const
{
return m_arqSyncLoss;
}
uint8_t
ServiceFlow::GetArqDeliverInOrder (void) const
{
return m_arqDeliverInOrder;
}
uint16_t
ServiceFlow::GetArqPurgeTimeout (void) const
{
return m_arqPurgeTimeout;
}
uint16_t
ServiceFlow::GetArqBlockSize (void) const
{
return m_arqBlockSize;
}
enum
ServiceFlow::CsSpecification ServiceFlow::GetCsSpecification (void) const
{
return m_csSpecification;
}
CsParameters
ServiceFlow::GetConvergenceSublayerParam (void) const
{
return m_convergenceSublayerParam;
}
uint16_t
ServiceFlow::GetUnsolicitedGrantInterval (void) const
{
return m_unsolicitedGrantInterval;
}
uint16_t
ServiceFlow::GetUnsolicitedPollingInterval (void) const
{
return m_unsolicitedPollingInterval;
}
bool
ServiceFlow::GetIsMulticast (void) const
{
return m_isMulticast;
}
enum WimaxPhy::ModulationType
ServiceFlow::GetModulation (void) const
{
return m_modulationType;
}
// ==============================================================================
void
ServiceFlow::SetSfid (uint32_t sfid)
{
m_sfid = sfid;
}
void
ServiceFlow::SetServiceClassName (std::string name)
{
m_serviceClassName = name;
}
void
ServiceFlow::SetQosParamSetType (uint8_t type)
{
m_qosParamSetType = type;
}
void
ServiceFlow::SetTrafficPriority (uint8_t priority)
{
m_trafficPriority = priority;
}
void
ServiceFlow::SetMaxSustainedTrafficRate (uint32_t maxSustainedRate)
{
m_maxSustainedTrafficRate = maxSustainedRate;
}
void
ServiceFlow::SetMaxTrafficBurst (uint32_t maxTrafficBurst)
{
m_maxTrafficBurst = maxTrafficBurst;
}
void
ServiceFlow::SetMinReservedTrafficRate (uint32_t minResvRate)
{
m_minReservedTrafficRate = minResvRate;
}
void
ServiceFlow::SetMinTolerableTrafficRate (uint32_t minJitter)
{
m_minTolerableTrafficRate = minJitter;
}
void
ServiceFlow::SetServiceSchedulingType (enum ServiceFlow::SchedulingType schedType)
{
m_schedulingType = schedType;
}
void
ServiceFlow::SetRequestTransmissionPolicy (uint32_t policy)
{
m_requestTransmissionPolicy = policy;
}
void
ServiceFlow::SetToleratedJitter (uint32_t jitter)
{
m_toleratedJitter = jitter;
}
void
ServiceFlow::SetMaximumLatency (uint32_t MaximumLatency)
{
m_maximumLatency = MaximumLatency;
}
void
ServiceFlow::SetFixedversusVariableSduIndicator (uint8_t sduIndicator)
{
m_fixedversusVariableSduIndicator = sduIndicator;
}
void
ServiceFlow::SetSduSize (uint8_t sduSize)
{
m_sduSize = sduSize;
}
void
ServiceFlow::SetTargetSAID (uint16_t targetSaid)
{
m_targetSAID = targetSaid;
}
void
ServiceFlow::SetArqEnable (uint8_t arqEnable)
{
m_arqEnable = arqEnable;
}
void
ServiceFlow::SetArqWindowSize (uint16_t arqWindowSize)
{
m_arqWindowSize = arqWindowSize;
}
void
ServiceFlow::SetArqRetryTimeoutTx (uint16_t timeout)
{
m_arqRetryTimeoutTx = timeout;
}
void
ServiceFlow::SetArqRetryTimeoutRx (uint16_t timeout)
{
m_arqRetryTimeoutRx = timeout;
}
void
ServiceFlow::SetArqBlockLifeTime (uint16_t lifeTime)
{
m_arqBlockLifeTime = lifeTime;
}
void
ServiceFlow::SetArqSyncLoss (uint16_t syncLoss)
{
m_arqSyncLoss = syncLoss;
}
void
ServiceFlow::SetArqDeliverInOrder (uint8_t inOrder)
{
m_arqDeliverInOrder = inOrder;
}
void
ServiceFlow::SetArqPurgeTimeout (uint16_t timeout)
{
m_arqPurgeTimeout = timeout;
}
void
ServiceFlow::SetArqBlockSize (uint16_t size)
{
m_arqBlockSize = size;
}
void
ServiceFlow::SetCsSpecification (enum ServiceFlow::CsSpecification spec)
{
m_csSpecification = spec;
}
void
ServiceFlow::SetConvergenceSublayerParam (CsParameters csparam)
{
m_convergenceSublayerParam = csparam;
}
void
ServiceFlow::SetUnsolicitedGrantInterval (uint16_t unsolicitedGrantInterval)
{
m_unsolicitedGrantInterval = unsolicitedGrantInterval;
}
void
ServiceFlow::SetUnsolicitedPollingInterval (uint16_t unsolicitedPollingInterval)
{
m_unsolicitedPollingInterval = unsolicitedPollingInterval;
}
void
ServiceFlow::SetIsMulticast (bool isMulticast)
{
m_isMulticast = isMulticast;
}
void
ServiceFlow::SetModulation (enum WimaxPhy::ModulationType modulationType)
{
m_modulationType = modulationType;
}
void
ServiceFlow::InitValues (void)
{
m_sfid = 0;
m_serviceClassName = "";
m_qosParamSetType = 0;
m_trafficPriority = 0;
m_maxSustainedTrafficRate = 0;
m_maxTrafficBurst = 0;
m_minReservedTrafficRate = 0;
m_minTolerableTrafficRate = 0;
m_schedulingType = ServiceFlow::SF_TYPE_NONE;
m_requestTransmissionPolicy = 0;
m_toleratedJitter = 0;
m_maximumLatency = 0;
m_fixedversusVariableSduIndicator = 0;
m_sduSize = 0;
m_targetSAID = 0;
m_arqEnable = 0;
m_arqWindowSize = 0;
m_arqRetryTimeoutTx = 0;
m_arqRetryTimeoutRx = 0;
m_csSpecification = ServiceFlow::IPV4;
m_unsolicitedGrantInterval = 0;
m_unsolicitedPollingInterval = 0;
m_arqBlockLifeTime = 0;
m_arqSyncLoss = 0;
m_arqDeliverInOrder = 0;
m_arqPurgeTimeout = 0;
m_arqBlockSize = 0;
m_direction = ServiceFlow::SF_DIRECTION_DOWN;
m_type = ServiceFlow::SF_TYPE_ACTIVE;
m_isMulticast = false;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
}
void
ServiceFlow::CopyParametersFrom (ServiceFlow sf)
{
m_serviceClassName = sf.GetServiceClassName ();
m_qosParamSetType = sf.GetQosParamSetType ();
m_trafficPriority = sf.GetTrafficPriority ();
m_maxSustainedTrafficRate = sf.GetMaxSustainedTrafficRate ();
m_maxTrafficBurst = sf.GetMaxTrafficBurst ();
m_minReservedTrafficRate = sf.GetMinReservedTrafficRate ();
m_minTolerableTrafficRate = sf.GetMinTolerableTrafficRate ();
m_schedulingType = sf.GetServiceSchedulingType ();
m_requestTransmissionPolicy = sf.GetRequestTransmissionPolicy ();
m_toleratedJitter = sf.GetToleratedJitter ();
m_maximumLatency = sf.GetMaximumLatency ();
m_fixedversusVariableSduIndicator = sf.GetFixedversusVariableSduIndicator ();
m_sduSize = sf.GetSduSize ();
m_targetSAID = sf.GetTargetSAID ();
m_arqEnable = sf.GetArqEnable ();
m_arqWindowSize = sf.GetArqWindowSize ();
m_arqRetryTimeoutTx = sf.GetArqRetryTimeoutTx ();
m_arqRetryTimeoutRx = sf.GetArqRetryTimeoutRx ();
m_csSpecification = sf.GetCsSpecification ();
m_convergenceSublayerParam = sf.GetConvergenceSublayerParam ();
m_unsolicitedGrantInterval = sf.GetUnsolicitedGrantInterval ();
m_unsolicitedPollingInterval = sf.GetUnsolicitedPollingInterval ();
m_direction = sf.GetDirection ();
m_isMulticast = sf.GetIsMulticast ();
m_modulationType = sf.GetModulation ();
}
ServiceFlow::ServiceFlow (const ServiceFlow & sf)
{
m_sfid = sf.GetSfid ();
m_serviceClassName = sf.GetServiceClassName ();
m_qosParamSetType = sf.GetQosParamSetType ();
m_trafficPriority = sf.GetTrafficPriority ();
m_maxSustainedTrafficRate = sf.GetMaxSustainedTrafficRate ();
m_maxTrafficBurst = sf.GetMaxTrafficBurst ();
m_minReservedTrafficRate = sf.GetMinReservedTrafficRate ();
m_minTolerableTrafficRate = sf.GetMinTolerableTrafficRate ();
m_schedulingType = sf.GetServiceSchedulingType ();
m_requestTransmissionPolicy = sf.GetRequestTransmissionPolicy ();
m_toleratedJitter = sf.GetToleratedJitter ();
m_maximumLatency = sf.GetMaximumLatency ();
m_fixedversusVariableSduIndicator = sf.GetFixedversusVariableSduIndicator ();
m_sduSize = sf.GetSduSize ();
m_targetSAID = sf.GetTargetSAID ();
m_arqEnable = sf.GetArqEnable ();
m_arqWindowSize = sf.GetArqWindowSize ();
m_arqRetryTimeoutTx = sf.GetArqRetryTimeoutTx ();
m_arqRetryTimeoutRx = sf.GetArqRetryTimeoutRx ();
m_csSpecification = sf.GetCsSpecification ();
m_convergenceSublayerParam = sf.GetConvergenceSublayerParam ();
m_unsolicitedGrantInterval = sf.GetUnsolicitedGrantInterval ();
m_unsolicitedPollingInterval = sf.GetUnsolicitedPollingInterval ();
m_direction = sf.GetDirection ();
m_type = sf.GetType ();
m_connection = sf.GetConnection ();
m_isEnabled = sf.GetIsEnabled ();
m_record = new ServiceFlowRecord ();
(*m_record) = (*sf.GetRecord ());
m_isMulticast = sf.GetIsMulticast ();
m_modulationType = sf.GetModulation ();
}
ServiceFlow &
ServiceFlow::operator = (ServiceFlow const& o)
{
m_sfid = o.GetSfid ();
m_serviceClassName = o.GetServiceClassName ();
m_qosParamSetType = o.GetQosParamSetType ();
m_trafficPriority = o.GetTrafficPriority ();
m_maxSustainedTrafficRate = o.GetMaxSustainedTrafficRate ();
m_maxTrafficBurst = o.GetMaxTrafficBurst ();
m_minReservedTrafficRate = o.GetMinReservedTrafficRate ();
m_minTolerableTrafficRate = o.GetMinTolerableTrafficRate ();
m_schedulingType = o.GetServiceSchedulingType ();
m_requestTransmissionPolicy = o.GetRequestTransmissionPolicy ();
m_toleratedJitter = o.GetToleratedJitter ();
m_maximumLatency = o.GetMaximumLatency ();
m_fixedversusVariableSduIndicator = o.GetFixedversusVariableSduIndicator ();
m_sduSize = o.GetSduSize ();
m_targetSAID = o.GetTargetSAID ();
m_arqEnable = o.GetArqEnable ();
m_arqWindowSize = o.GetArqWindowSize ();
m_arqRetryTimeoutTx = o.GetArqRetryTimeoutTx ();
m_arqRetryTimeoutRx = o.GetArqRetryTimeoutRx ();
m_csSpecification = o.GetCsSpecification ();
m_convergenceSublayerParam = o.GetConvergenceSublayerParam ();
m_unsolicitedGrantInterval = o.GetUnsolicitedGrantInterval ();
m_unsolicitedPollingInterval = o.GetUnsolicitedPollingInterval ();
m_direction = o.GetDirection ();
m_type = o.GetType ();
m_connection = o.GetConnection ();
m_isEnabled = o.GetIsEnabled ();
m_isMulticast = o.GetIsMulticast ();
m_modulationType = o.GetModulation ();
if (m_record != 0)
{
delete m_record;
}
m_record = new ServiceFlowRecord ();
(*m_record) = (*o.GetRecord ());
return *this;
}
char*
ServiceFlow::GetSchedulingTypeStr (void) const
{
switch (m_schedulingType)
{
case SF_TYPE_UGS:
return (char*) "UGS";
break;
case SF_TYPE_RTPS:
return (char*) "rtPS";
break;
case SF_TYPE_NRTPS:
return (char*) "nrtPS";
break;
case SF_TYPE_BE:
return (char*) "BE";
break;
default:
NS_FATAL_ERROR ("Invalid scheduling type");
}
return 0;
}
Tlv
ServiceFlow::ToTlv (void) const
{
SfVectorTlvValue tmpSfVector;
tmpSfVector.Add (Tlv (SfVectorTlvValue::SFID, 4, U32TlvValue (m_sfid)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::CID, 2, U16TlvValue (GetCid ())));
tmpSfVector.Add (Tlv (SfVectorTlvValue::QoS_Parameter_Set_Type, 1, U8TlvValue (m_qosParamSetType)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Traffic_Priority, 1, U8TlvValue (m_trafficPriority)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Maximum_Sustained_Traffic_Rate, 4, U32TlvValue (m_maxSustainedTrafficRate)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Maximum_Traffic_Burst, 4, U32TlvValue (m_maxTrafficBurst)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Minimum_Reserved_Traffic_Rate, 4, U32TlvValue (m_minReservedTrafficRate)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Minimum_Tolerable_Traffic_Rate, 4, U32TlvValue (m_minTolerableTrafficRate)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Service_Flow_Scheduling_Type, 1, U8TlvValue (m_schedulingType)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Request_Transmission_Policy, 4, U32TlvValue (m_requestTransmissionPolicy)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Tolerated_Jitter, 4, U32TlvValue (m_toleratedJitter)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Maximum_Latency, 4, U32TlvValue (m_maximumLatency)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Fixed_length_versus_Variable_length_SDU_Indicator,
1,
U8TlvValue (m_fixedversusVariableSduIndicator)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::SDU_Size, 1, U8TlvValue (m_sduSize)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::Target_SAID, 2, U16TlvValue (m_targetSAID)));
tmpSfVector.Add (Tlv (SfVectorTlvValue::CS_Specification, 1, U8TlvValue (m_csSpecification)));
tmpSfVector.Add (m_convergenceSublayerParam.ToTlv ());
if (m_direction == SF_DIRECTION_UP)
{
return Tlv (Tlv::UPLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
}
else
{
return Tlv (Tlv::DOWNLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
}
}
bool
ServiceFlow::CheckClassifierMatch (Ipv4Address srcAddress,
Ipv4Address dstAddress,
uint16_t srcPort,
uint16_t dstPort,
uint8_t proto) const
{
return m_convergenceSublayerParam.GetPacketClassifierRule ().CheckMatch (srcAddress,
dstAddress,
srcPort,
dstPort,
proto);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/service-flow.cc | C++ | gpl2 | 22,705 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include <stdint.h>
#include "burst-profile-manager.h"
#include "bs-net-device.h"
#include "ss-net-device.h"
#include "ss-record.h"
#include "ss-manager.h"
#include "ns3/log.h"
#include "mac-messages.h"
NS_LOG_COMPONENT_DEFINE ("BurstProfileManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BurstProfileManager);
TypeId BurstProfileManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BurstProfileManager")
.SetParent<Object> ();
return tid;
}
BurstProfileManager::BurstProfileManager (Ptr<WimaxNetDevice> device)
: m_device (device)
{
}
BurstProfileManager::~BurstProfileManager (void)
{
m_device = 0;
}
void
BurstProfileManager::DoDispose (void)
{
m_device = 0;
}
uint16_t BurstProfileManager::GetNrBurstProfilesToDefine (void)
{
/*
* 7 modulation types
*/
return 7;
}
WimaxPhy::ModulationType
BurstProfileManager::GetModulationType (uint8_t iuc,
WimaxNetDevice::Direction direction) const
{
if (direction == WimaxNetDevice::DIRECTION_DOWNLINK)
{
std::vector<OfdmDlBurstProfile> dlBurstProfiles =
m_device->GetCurrentDcd ().GetDlBurstProfiles ();
for (std::vector<OfdmDlBurstProfile>::iterator iter =
dlBurstProfiles.begin (); iter != dlBurstProfiles.end (); ++iter)
{
if (iter->GetDiuc () == iuc)
{
return (WimaxPhy::ModulationType) iter->GetFecCodeType ();
}
}
}
else
{
std::vector<OfdmUlBurstProfile> ulBurstProfiles =
m_device->GetCurrentUcd ().GetUlBurstProfiles ();
for (std::vector<OfdmUlBurstProfile>::iterator iter =
ulBurstProfiles.begin (); iter != ulBurstProfiles.end (); ++iter)
{
if (iter->GetUiuc () == iuc)
{
return (WimaxPhy::ModulationType) iter->GetFecCodeType ();
}
}
}
// burst profile got to be there in DCD/UCD, assuming always all profiles are defined in DCD/UCD
NS_FATAL_ERROR ("burst profile got to be there in DCD/UCD");
return (WimaxPhy::ModulationType) -1;
}
uint8_t
BurstProfileManager::GetBurstProfile (
WimaxPhy::ModulationType modulationType,
WimaxNetDevice::Direction direction) const
{
if (direction == WimaxNetDevice::DIRECTION_DOWNLINK)
{
std::vector<OfdmDlBurstProfile> dlBurstProfiles =
m_device->GetCurrentDcd ().GetDlBurstProfiles ();
for (std::vector<OfdmDlBurstProfile>::iterator iter =
dlBurstProfiles.begin (); iter != dlBurstProfiles.end (); ++iter)
{
if (iter->GetFecCodeType () == modulationType)
{
return iter->GetDiuc ();
}
}
}
else
{
std::vector<OfdmUlBurstProfile> ulBurstProfiles =
m_device->GetCurrentUcd ().GetUlBurstProfiles ();
for (std::vector<OfdmUlBurstProfile>::iterator iter =
ulBurstProfiles.begin (); iter != ulBurstProfiles.end (); ++iter)
{
if (iter->GetFecCodeType () == modulationType)
{
return iter->GetUiuc ();
}
}
}
// burst profile got to be there in DCD/UCD, assuming always all profiles are defined in DCD/UCD
NS_FATAL_ERROR ("burst profile got to be there in DCD/UCD");
return ~0;
}
uint8_t
BurstProfileManager::GetBurstProfileForSS (const SSRecord *ssRecord,
const RngReq *rngreq, WimaxPhy::ModulationType &modulationType)
{
/*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, temporarily choosing same burst profile SS requested in RNG-REQ*/
modulationType = GetModulationTypeForSS (ssRecord, rngreq);
return GetBurstProfile (modulationType, WimaxNetDevice::DIRECTION_DOWNLINK);
}
WimaxPhy::ModulationType
BurstProfileManager::GetModulationTypeForSS (const SSRecord *ssRecord, const RngReq *rngreq)
{
return GetModulationType (rngreq->GetReqDlBurstProfile (),
WimaxNetDevice::DIRECTION_DOWNLINK);
}
uint8_t
BurstProfileManager::GetBurstProfileToRequest (void)
{
/*modulation type is currently set by user in simulation script, shall
actually be determined based on SS's distance, power, signal etc*/
return GetBurstProfile (
m_device->GetObject<SubscriberStationNetDevice> ()->GetModulationType (),
WimaxNetDevice::DIRECTION_DOWNLINK);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/burst-profile-manager.cc | C++ | gpl2 | 5,346 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include <string.h>
#include "ns3/snr-to-block-error-rate-manager.h"
#include "ns3/snr-to-block-error-rate-record.h"
#include "default-traces.h"
#include "ns3/log.h"
#include <fstream>
NS_LOG_COMPONENT_DEFINE ("SNRToBlockErrorRateManager");
namespace ns3 {
SNRToBlockErrorRateManager::SNRToBlockErrorRateManager (void)
{
for (int i = 0; i < 7; i++)
{
m_recordModulation[i] = new std::vector<SNRToBlockErrorRateRecord*> ();
}
m_activateLoss = false;
strcpy (m_traceFilePath,"DefaultTraces");
}
SNRToBlockErrorRateManager::~SNRToBlockErrorRateManager (void)
{
ClearRecords ();
for (int i = 0; i < 7; i++)
{
delete m_recordModulation[i];
}
}
void
SNRToBlockErrorRateManager::ClearRecords (void)
{
for (int i = 0; i < 7; i++)
{
for (std::vector<SNRToBlockErrorRateRecord*>::iterator iter = m_recordModulation[i]->begin (); iter
!= m_recordModulation[i]->end (); ++iter)
{
if (*iter)
{
delete (*iter);
(*iter) = 0;
}
}
m_recordModulation[i]->clear ();
}
}
void
SNRToBlockErrorRateManager::ActivateLoss (bool loss)
{
m_activateLoss = loss;
}
void
SNRToBlockErrorRateManager::LoadTraces (void)
{
std::ifstream m_ifTraceFile;
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);
m_ifTraceFile.open (traceFile, std::ifstream::in);
if (m_ifTraceFile.good () == false)
{
NS_LOG_INFO ("Unable to load " << traceFile << "!! Loading default traces...");
LoadDefaultTraces ();
return;
}
while (m_ifTraceFile.good ())
{
m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2;
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[i]->push_back (record);
}
m_ifTraceFile.close ();
}
m_activateLoss = true;
}
void
SNRToBlockErrorRateManager::LoadDefaultTraces (void)
{
double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2;
ClearRecords ();
for (unsigned int j = 0; j < sizeof(modulation0[0]) / sizeof(double); j++)
{
snrValue = modulation0[0][j];
bitErrorRate = modulation0[1][j];
burstErrorRate = modulation0[2][j];
sigma2 = modulation0[3][j];
I1 = modulation0[4][j];
I2 = modulation0[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[0]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation1[0]) / sizeof(double); j++)
{
snrValue = modulation1[0][j];
bitErrorRate = modulation1[1][j];
burstErrorRate = modulation1[2][j];
sigma2 = modulation1[3][j];
I1 = modulation1[4][j];
I2 = modulation1[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[1]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation2[0]) / sizeof(double); j++)
{
snrValue = modulation2[0][j];
bitErrorRate = modulation2[1][j];
burstErrorRate = modulation2[2][j];
sigma2 = modulation2[3][j];
I1 = modulation2[4][j];
I2 = modulation2[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[2]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation3[0]) / sizeof(double); j++)
{
snrValue = modulation3[0][j];
bitErrorRate = modulation3[1][j];
burstErrorRate = modulation3[2][j];
sigma2 = modulation3[3][j];
I1 = modulation3[4][j];
I2 = modulation3[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[3]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation4[0]) / sizeof(double); j++)
{
snrValue = modulation4[0][j];
bitErrorRate = modulation4[1][j];
burstErrorRate = modulation4[2][j];
sigma2 = modulation4[3][j];
I1 = modulation4[4][j];
I2 = modulation4[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[4]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation5[0]) / sizeof(double); j++)
{
snrValue = modulation5[0][j];
bitErrorRate = modulation5[1][j];
burstErrorRate = modulation5[2][j];
sigma2 = modulation5[3][j];
I1 = modulation5[4][j];
I2 = modulation5[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[5]->push_back (record);
}
for (unsigned int j = 0; j < sizeof(modulation6[0]) / sizeof(double); j++)
{
snrValue = modulation6[0][j];
bitErrorRate = modulation6[1][j];
burstErrorRate = modulation6[2][j];
sigma2 = modulation6[3][j];
I1 = modulation6[4][j];
I2 = modulation6[5][j];
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[6]->push_back (record);
}
m_activateLoss = true;
}
void
SNRToBlockErrorRateManager::ReLoadTraces (void)
{
double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2;
ClearRecords ();
std::ifstream m_ifTraceFile;
for (int i = 0; i < 7; i++)
{
char traceFile[1024];
sprintf (traceFile, "%s/Modulation%d.txt", m_traceFilePath, i);
m_ifTraceFile.open (traceFile, std::ifstream::in);
if (m_ifTraceFile.good () == false)
{
NS_LOG_INFO ("Unable to load " << traceFile << "!!Loading default traces...");
LoadDefaultTraces ();
return;
}
while (m_ifTraceFile.good ())
{
m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2;
SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
bitErrorRate,
burstErrorRate,
sigma2,
I1,
I2);
m_recordModulation[i]->push_back (record);
}
m_ifTraceFile.close ();
}
m_activateLoss = true;
}
void
SNRToBlockErrorRateManager::SetTraceFilePath (char *traceFilePath)
{
strcpy (m_traceFilePath, traceFilePath);
}
std::string
SNRToBlockErrorRateManager::GetTraceFilePath (void)
{
return (std::string (m_traceFilePath));
}
double
SNRToBlockErrorRateManager::GetBlockErrorRate (double SNR, uint8_t modulation)
{
if (m_activateLoss == false)
{
return 0;
}
std::vector<SNRToBlockErrorRateRecord *> *record = 0;
record = m_recordModulation[modulation];
if (SNR <= (record->at (0)->GetSNRValue ()))
{
return 1;
}
if (SNR >= (record->at (record->size () - 1)->GetSNRValue ()))
{
return 0;
}
std::vector<SNRToBlockErrorRateRecord*>::const_iterator iter;
unsigned int i;
for (i = 0; i < record->size (); i++)
{
if (SNR < record->at (i)->GetSNRValue ())
{
break;
}
}
double intervalSize = (record->at (i)->GetSNRValue () - record->at (i - 1)->GetSNRValue ());
double coeff1 = (SNR - record->at (i - 1)->GetSNRValue ()) / intervalSize;
double coeff2 = -1 * (SNR - record->at (i)->GetSNRValue ()) / intervalSize;
double BlockErrorRate = coeff2 * (record->at (i - 1)->GetBlockErrorRate ()) + coeff1 * (record->at (i)->GetBlockErrorRate ());
return BlockErrorRate;
}
SNRToBlockErrorRateRecord *
SNRToBlockErrorRateManager::GetSNRToBlockErrorRateRecord (double SNR,
uint8_t modulation)
{
if (m_activateLoss == false)
{
return new SNRToBlockErrorRateRecord (SNR, 0, 0, 0, 0, 0);
}
std::vector<SNRToBlockErrorRateRecord *> *record = 0;
record = m_recordModulation[modulation];
if (SNR <= (record->at (0)->GetSNRValue ()))
{
return
record->at (0)->Copy ();
}
if (SNR >= (record->at (record->size () - 1)->GetSNRValue ()))
{
return
record->at (record->size () - 1)->Copy ();
}
std::vector<SNRToBlockErrorRateRecord*>::const_iterator iter;
unsigned int i;
for (i = 0; i < record->size (); i++)
{
if (SNR < record->at (i)->GetSNRValue ())
{
break;
}
}
double intervalSize = (record->at (i)->GetSNRValue ()
- record->at (i - 1)->GetSNRValue ());
double coeff1 = (SNR - record->at (i - 1)->GetSNRValue ()) / intervalSize;
double coeff2 = -1 * (SNR - record->at (i)->GetSNRValue ()) / intervalSize;
double BER = coeff2 * (record->at (i - 1)->GetBitErrorRate ()) + coeff1 * (record->at (i)->GetBitErrorRate ());
double BlcER = coeff2 * (record->at (i - 1)->GetBlockErrorRate ()) + coeff1 * (record->at (i)->GetBlockErrorRate ());
double sigma2 = coeff2 * (record->at (i - 1)->GetSigma2 ()) + coeff1 * (record->at (i)->GetSigma2 ());
double I1 = coeff2 * (record->at (i - 1)->GetI1 ()) + coeff1 * (record->at (i)->GetI1 ());
double I2 = coeff2 * (record->at (i - 1)->GetI2 ()) + coeff1 * (record->at (i)->GetI2 ());
SNRToBlockErrorRateRecord * SNRToBlockErrorRate = new SNRToBlockErrorRateRecord (SNR, BER, BlcER, sigma2, I1,I2);
return SNRToBlockErrorRate;
}
}
| zy901002-gpsr | src/wimax/model/snr-to-block-error-rate-manager.cc | C++ | gpl2 | 13,965 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
/* BS outbound scheduler as per in Section 6.3.5.1 */
#ifndef BS_SCHEDULER_H
#define BS_SCHEDULER_H
#include <list>
#include "ns3/packet.h"
#include "wimax-phy.h"
#include "ns3/packet-burst.h"
#include "dl-mac-messages.h"
#include "service-flow.h"
namespace ns3 {
class BaseStationNetDevice;
class GenericMacHeader;
class WimaxConnection;
class Cid;
/**
* \ingroup wimax
*/
class BSScheduler : public Object
{
public:
BSScheduler ();
BSScheduler (Ptr<BaseStationNetDevice> bs);
~BSScheduler (void);
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<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > >*
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
* \param diuc downlink iuc
* \param modulationType the modulation type of the burst
* \param burst the downlink burst to add to the downlink sub frame
*/
virtual void AddDownlinkBurst (Ptr<const WimaxConnection> connection,
uint8_t diuc,
WimaxPhy::ModulationType modulationType,
Ptr<PacketBurst> 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<WimaxConnection> &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
* \param availableSymbols maximum number of OFDM symbols to be used by the burst
* \returns a Burst (list of packets)
*/
virtual Ptr<PacketBurst> CreateUgsBurst (ServiceFlow *serviceFlow,
WimaxPhy::ModulationType modulationType,
uint32_t availableSymbols) = 0;
virtual Ptr<BaseStationNetDevice> GetBs (void);
virtual void SetBs (Ptr<BaseStationNetDevice> 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
* \param modulationType the modulation type to be used for the burst
* \returns false if packet fragmentation is not possible, true otherwise
*/
bool CheckForFragmentation (Ptr<WimaxConnection> connection,
int availableSymbols,
WimaxPhy::ModulationType modulationType);
private:
Ptr<BaseStationNetDevice> m_bs;
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *m_downlinkBursts;
};
} // namespace ns3
#endif /* BS_SCHEDULER_H */
| zy901002-gpsr | src/wimax/model/bs-scheduler.h | C++ | gpl2 | 4,108 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "bs-scheduler-simple.h"
#include "ns3/simulator.h"
#include "bs-net-device.h"
#include "ns3/packet-burst.h"
#include "cid.h"
#include "wimax-mac-header.h"
#include "ss-record.h"
#include "wimax-mac-queue.h"
#include "ns3/log.h"
#include "burst-profile-manager.h"
#include "wimax-connection.h"
#include "connection-manager.h"
#include "ss-manager.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
NS_LOG_COMPONENT_DEFINE ("BSSchedulerSimple");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BSSchedulerSimple);
TypeId BSSchedulerSimple::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BSSchedulerSimple").SetParent<Object> ().AddConstructor<BSSchedulerSimple> ();
return tid;
}
BSSchedulerSimple::BSSchedulerSimple ()
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
SetBs (0);
}
BSSchedulerSimple::BSSchedulerSimple (Ptr<BaseStationNetDevice> bs)
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
// m_downlinkBursts is filled by AddDownlinkBurst and emptied by
// wimax-bs-net-device::sendBurst and wimax-ss-net-device::sendBurst
SetBs (bs);
}
BSSchedulerSimple::~BSSchedulerSimple (void)
{
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *downlinkBursts = m_downlinkBursts;
std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > pair;
while (downlinkBursts->size ())
{
pair = downlinkBursts->front ();
pair.second = 0;
delete pair.first;
}
SetBs (0);
delete m_downlinkBursts;
m_downlinkBursts = 0;
}
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > >*
BSSchedulerSimple::GetDownlinkBursts (void) const
{
return m_downlinkBursts;
}
void BSSchedulerSimple::AddDownlinkBurst (Ptr<const WimaxConnection> connection,
uint8_t diuc,
WimaxPhy::ModulationType modulationType,
Ptr<PacketBurst> burst)
{
OfdmDlMapIe *dlMapIe = new OfdmDlMapIe ();
dlMapIe->SetCid (connection->GetCid ());
dlMapIe->SetDiuc (diuc);
NS_LOG_INFO ("BS scheduler, burst size: " << burst->GetSize () << " bytes" << ", pkts: " << burst->GetNPackets ()
<< ", connection: " << connection->GetTypeStr () << ", CID: " << connection->GetCid ());
if (connection->GetType () == Cid::TRANSPORT)
{
NS_LOG_INFO (", SFID: " << connection->GetServiceFlow ()->GetSfid () << ", service: "
<< connection->GetServiceFlow ()->GetSchedulingTypeStr ());
}
NS_LOG_INFO (", modulation: " << modulationType << ", DIUC: " << (uint32_t) diuc);
m_downlinkBursts->push_back (std::make_pair (dlMapIe, burst));
}
void BSSchedulerSimple::Schedule (void)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst;
ServiceFlow::SchedulingType schedulingType = ServiceFlow::SF_TYPE_NONE;
uint32_t availableSymbols = GetBs ()->GetNrDlSymbols ();
while (SelectConnection (connection))
{
if (connection != GetBs ()->GetInitialRangingConnection () && connection != GetBs ()->GetBroadcastConnection ())
{
/* determines modulation/DIUC only once per burst as it is always same for a particular CID */
if (connection->GetType () == Cid::MULTICAST)
{
modulationType = connection->GetServiceFlow ()->GetModulation ();
}
else
{
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
}
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
}
else if (connection == GetBs ()->GetInitialRangingConnection () || connection
== GetBs ()->GetBroadcastConnection ())
{
modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
}
if (connection->GetType () == Cid::TRANSPORT || connection->GetType () == Cid::MULTICAST)
{
schedulingType = (ServiceFlow::SchedulingType) connection->GetSchedulingType ();
}
if (schedulingType == ServiceFlow::SF_TYPE_UGS)
{
nrSymbolsRequired = connection->GetServiceFlow ()->GetRecord ()->GetGrantSize ();
if (nrSymbolsRequired < availableSymbols)
{
burst = CreateUgsBurst (connection->GetServiceFlow (), modulationType, nrSymbolsRequired);
}
else
{
burst = CreateUgsBurst (connection->GetServiceFlow (), modulationType, availableSymbols);
}
if (burst->GetNPackets () != 0)
{
uint32_t BurstSizeSymbols = GetBs ()->GetPhy ()->GetNrSymbols (burst->GetSize (), modulationType);
AddDownlinkBurst (connection, diuc, modulationType, burst);
if (availableSymbols <= BurstSizeSymbols)
{
availableSymbols -= BurstSizeSymbols; // XXX: Overflows but don't know how to fix
break;
}
}
}
else
{
burst = Create<PacketBurst> ();
while (connection->HasPackets () == true)
{
uint32_t FirstPacketSize = connection->GetQueue ()->GetFirstPacketRequiredByte (MacHeaderType::HEADER_TYPE_GENERIC);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (FirstPacketSize, modulationType);
if (availableSymbols < nrSymbolsRequired && CheckForFragmentation (connection,
availableSymbols,
modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
availableSymbols = 0;
}
else if (availableSymbols >= nrSymbolsRequired)
{
packet = connection->Dequeue ();
availableSymbols -= nrSymbolsRequired;
}
else
{
break;
}
burst->AddPacket (packet);
}
AddDownlinkBurst (connection, diuc, modulationType, burst);
}
if (availableSymbols == 0)
{
break;
}
}
if (m_downlinkBursts->size ())
{
NS_LOG_DEBUG ("BS scheduler, number of bursts: " << m_downlinkBursts->size () << ", symbols left: "
<< availableSymbols << std::endl << "BS scheduler, queues:" << " IR "
<< GetBs ()->GetInitialRangingConnection ()->GetQueue ()->GetSize () << " broadcast "
<< GetBs ()->GetBroadcastConnection ()->GetQueue ()->GetSize () << " basic "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::BASIC, ServiceFlow::SF_TYPE_NONE) << " primary "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::PRIMARY, ServiceFlow::SF_TYPE_NONE) << " transport "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::TRANSPORT, ServiceFlow::SF_TYPE_ALL));
}
}
bool BSSchedulerSimple::SelectConnection (Ptr<WimaxConnection> &connection)
{
connection = 0;
Time currentTime = Simulator::Now ();
std::vector<Ptr<WimaxConnection> >::const_iterator iter1;
std::vector<ServiceFlow*>::iterator iter2;
ServiceFlowRecord *serviceFlowRecord;
NS_LOG_INFO ("BS Scheduler: Selecting connection...");
if (GetBs ()->GetBroadcastConnection ()->HasPackets ())
{
NS_LOG_INFO ("Return GetBroadcastConnection");
connection = GetBs ()->GetBroadcastConnection ();
return true;
}
else if (GetBs ()->GetInitialRangingConnection ()->HasPackets ())
{
NS_LOG_INFO ("Return GetInitialRangingConnection");
connection = GetBs ()->GetInitialRangingConnection ();
return true;
}
else
{
std::vector<Ptr<WimaxConnection> > connections;
std::vector<ServiceFlow*> serviceFlows;
connections = GetBs ()->GetConnectionManager ()->GetConnections (Cid::BASIC);
for (iter1 = connections.begin (); iter1 != connections.end (); ++iter1)
{
if ((*iter1)->HasPackets ())
{
NS_LOG_INFO ("Return Basic");
connection = *iter1;
return true;
}
}
connections = GetBs ()->GetConnectionManager ()->GetConnections (Cid::PRIMARY);
for (iter1 = connections.begin (); iter1 != connections.end (); ++iter1)
{
if ((*iter1)->HasPackets ())
{
NS_LOG_INFO ("Return Primary");
connection = *iter1;
return true;
}
}
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_UGS);
for (iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
serviceFlowRecord = (*iter2)->GetRecord ();
NS_LOG_INFO ("processing UGS: HAS PACKET=" << (*iter2)->HasPackets () << "max Latency = "
<< MilliSeconds ((*iter2)->GetMaximumLatency ()) << "Delay = " << ((currentTime
- serviceFlowRecord->GetDlTimeStamp ()) + GetBs ()->GetPhy ()->GetFrameDuration ()));
// if latency would exceed in case grant is allocated in next frame then allocate in current frame
if ((*iter2)->HasPackets () && ((currentTime - serviceFlowRecord->GetDlTimeStamp ())
+ GetBs ()->GetPhy ()->GetFrameDuration ()) > MilliSeconds ((*iter2)->GetMaximumLatency ()))
{
serviceFlowRecord->SetDlTimeStamp (currentTime);
connection = (*iter2)->GetConnection ();
NS_LOG_INFO ("Return UGS SF: CID = " << (*iter2)->GetCid () << "SFID = " << (*iter2)->GetSfid ());
return true;
}
}
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_RTPS);
for (iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
serviceFlowRecord = (*iter2)->GetRecord ();
// if latency would exceed in case poll is allocated in next frame then allocate in current frame
if ((*iter2)->HasPackets () && ((currentTime - serviceFlowRecord->GetDlTimeStamp ())
+ GetBs ()->GetPhy ()->GetFrameDuration ()) > MilliSeconds ((*iter2)->GetMaximumLatency ()))
{
serviceFlowRecord->SetDlTimeStamp (currentTime);
connection = (*iter2)->GetConnection ();
NS_LOG_INFO ("Return RTPS SF: CID = " << (*iter2)->GetCid () << "SFID = " << (*iter2)->GetSfid ());
return true;
}
}
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_NRTPS);
for (iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
serviceFlowRecord = (*iter2)->GetRecord ();
if ((*iter2)->HasPackets ())
{
NS_LOG_INFO ("Return NRTPS SF: CID = " << (*iter2)->GetCid () << "SFID = " << (*iter2)->GetSfid ());
connection = (*iter2)->GetConnection ();
return true;
}
}
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_BE);
for (iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
serviceFlowRecord = (*iter2)->GetRecord ();
if ((*iter2)->HasPackets ())
{
NS_LOG_INFO ("Return BE SF: CID = " << (*iter2)->GetCid () << "SFID = " << (*iter2)->GetSfid ());
connection = (*iter2)->GetConnection ();
return true;
}
}
}
NS_LOG_INFO ("NO connection is selected!");
return false;
}
Ptr<PacketBurst> BSSchedulerSimple::CreateUgsBurst (ServiceFlow *serviceFlow,
WimaxPhy::ModulationType modulationType,
uint32_t availableSymbols)
{
Time timeStamp;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
uint32_t nrSymbolsRequired = 0;
// serviceFlow->CleanUpQueue ();
Ptr<WimaxConnection> connection = serviceFlow->GetConnection ();
while (serviceFlow->HasPackets ())
{
uint32_t FirstPacketSize = connection->GetQueue ()->GetFirstPacketRequiredByte (MacHeaderType::HEADER_TYPE_GENERIC);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (FirstPacketSize,modulationType);
if (availableSymbols < nrSymbolsRequired && CheckForFragmentation (connection,
availableSymbols,
modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
availableSymbols = 0;
}
else
{
packet = connection->Dequeue ();
availableSymbols -= nrSymbolsRequired;
}
burst->AddPacket (packet);
if (availableSymbols <= 0)
{
break;
}
}
return burst;
}
}
| zy901002-gpsr | src/wimax/model/bs-scheduler-simple.cc | C++ | gpl2 | 15,191 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include <stdint.h>
namespace ns3 {
/*
* CRC8 table on the polynomial:
* x^8 + x^2 + x^1 + x^0
*/
static uint8_t crc8table[256] = {
0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12,
0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E,
0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A,
0x5D, 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6,
0xD1, 0xC4, 0xC3, 0xCA, 0xCD, 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82,
0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, 0xC7, 0xC0, 0xC9,
0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED,
0xEA, 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81,
0x86, 0x93, 0x94, 0x9D, 0x9A, 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35,
0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A, 0x57, 0x50, 0x59,
0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D,
0x7A, 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF,
0xB8, 0xAD, 0xAA, 0xA3, 0xA4, 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB,
0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, 0x69, 0x6E, 0x67,
0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43,
0x44, 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F,
0x28, 0x3D, 0x3A, 0x33, 0x34, 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C,
0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, 0x3E, 0x39, 0x30,
0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14,
0x13, 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98,
0x9F, 0x8A, 0x8D, 0x84, 0x83, 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC,
0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
};
uint8_t
CRC8Calculate (const uint8_t *data, int length)
{
uint8_t crc = 0;
for (int i = 0; i < length; i++)
{
crc = crc8table[data[i] ^ crc];
}
return crc;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/crc8.cc | C++ | gpl2 | 2,819 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef DL_FRAME_PREFIX_IE_H
#define DL_FRAME_PREFIX_IE_H
#include <stdint.h>
#include "ns3/header.h"
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
*/
class DlFramePrefixIe
{
public:
DlFramePrefixIe ();
~DlFramePrefixIe ();
void SetRateId (uint8_t rateId);
void SetDiuc (uint8_t diuc);
void SetPreamblePresent (uint8_t preamblePresent);
void SetLength (uint16_t length);
void SetStartTime (uint16_t startTime);
uint8_t GetRateId (void) const;
uint8_t GetDiuc (void) const;
uint8_t GetPreamblePresent (void) const;
uint16_t GetLength (void) const;
uint16_t GetStartTime (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
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;
// shall actually contain m_startTime if DIUC is 0. see Table 225, page 452
};
} // namespace ns3
#endif /* DL_FRAME_PREFIX_IE_H */
#ifndef OFDM_DOWNLINK_FRAME_PREFIX_H
#define OFDM_DOWNLINK_FRAME_PREFIX_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/mac48-address.h"
namespace ns3 {
class OfdmDownlinkFramePrefix : public Header
{
public:
OfdmDownlinkFramePrefix ();
~OfdmDownlinkFramePrefix ();
void SetBaseStationId (Mac48Address baseStationId);
void SetFrameNumber (uint32_t frameNumber);
void SetConfigurationChangeCount (uint8_t configurationChangeCount);
void AddDlFramePrefixElement (DlFramePrefixIe dlFramePrefixElement);
void SetHcs (uint8_t hcs);
Mac48Address GetBaseStationId (void) const;
uint32_t GetFrameNumber (void) const;
uint8_t GetConfigurationChangeCount (void) const;
std::vector<DlFramePrefixIe> GetDlFramePrefixElements (void) const;
uint8_t GetHcs (void) const;
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<DlFramePrefixIe> m_dlFramePrefixElements; // vector of dl frame prefix elements
uint8_t m_hcs; // Header Check Sequence
};
} // namespace ns3
#endif /* OFDM_DOWNLINK_FRAME_PREFIX_H */
| zy901002-gpsr | src/wimax/model/ofdm-downlink-frame-prefix.h | C++ | gpl2 | 3,468 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
/* SS outbound scheduler as per in Section 6.3.5.1 */
#ifndef SS_SCHEDULER_H
#define SS_SCHEDULER_H
#include <stdint.h>
#include "ns3/packet.h"
#include "ns3/packet-burst.h"
#include "wimax-phy.h"
#include "wimax-mac-header.h"
namespace ns3 {
class SubscriberStationNetDevice;
class WimaxConnection;
/**
* \ingroup wimax
*/
class SSScheduler : public Object
{
public:
static TypeId GetTypeId (void);
SSScheduler (Ptr<SubscriberStationNetDevice> ss);
~SSScheduler (void);
void SetPollMe (bool pollMe);
bool GetPollMe (void) const;
/**
* \return a list of packet to be sent in the next opportunity
* \param availableSymbols the available resources in symbols
* \param modulationType the used modulation
* \param packetType the type of packets to select from
* \param connection the connection from wich packets will be selected
*/
Ptr<PacketBurst> Schedule (uint16_t availableSymbols,
WimaxPhy::ModulationType modulationType,
MacHeaderType::HeaderType packetType, Ptr<WimaxConnection> &connection);
void DoDispose (void);
protected:
private:
SSScheduler (const SSScheduler &);
SSScheduler & operator= (const SSScheduler &);
Ptr<WimaxConnection> SelectConnection (void);
Ptr<SubscriberStationNetDevice> m_ss;
bool m_pollMe;
};
} // namespace ns3
#endif /* SS_SCHEDULER_H */
| zy901002-gpsr | src/wimax/model/ss-scheduler.h | C++ | gpl2 | 2,210 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include <stdint.h>
#include "ul-mac-messages.h"
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (Ucd);
UcdChannelEncodings::UcdChannelEncodings (void)
: m_bwReqOppSize (0),
m_rangReqOppSize (0),
m_frequency (0)
{
}
UcdChannelEncodings::~UcdChannelEncodings (void)
{
}
void
UcdChannelEncodings::SetBwReqOppSize (uint16_t bwReqOppSize)
{
m_bwReqOppSize = bwReqOppSize;
}
void
UcdChannelEncodings::SetRangReqOppSize (uint16_t rangReqOppSize)
{
m_rangReqOppSize = rangReqOppSize;
}
void
UcdChannelEncodings::SetFrequency (uint32_t frequency)
{
m_frequency = frequency;
}
uint16_t
UcdChannelEncodings::GetBwReqOppSize (void) const
{
return m_bwReqOppSize;
}
uint16_t
UcdChannelEncodings::GetRangReqOppSize (void) const
{
return m_rangReqOppSize;
}
uint32_t
UcdChannelEncodings::GetFrequency (void) const
{
return m_frequency;
}
uint16_t
UcdChannelEncodings::GetSize (void) const
{
return 2 + 2 + 4;
}
Buffer::Iterator
UcdChannelEncodings::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_bwReqOppSize);
i.WriteU16 (m_rangReqOppSize);
i.WriteU32 (m_frequency);
return DoWrite (i);
}
Buffer::Iterator
UcdChannelEncodings::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_bwReqOppSize = i.ReadU16 ();
m_rangReqOppSize = i.ReadU16 ();
m_frequency = i.ReadU32 ();
return DoRead (i);
}
// ----------------------------------------------------------------------------------------------------------
OfdmUcdChannelEncodings::OfdmUcdChannelEncodings (void)
: m_sbchnlReqRegionFullParams (0),
m_sbchnlFocContCodes (0)
{
}
OfdmUcdChannelEncodings::~OfdmUcdChannelEncodings (void)
{
}
void
OfdmUcdChannelEncodings::SetSbchnlReqRegionFullParams (
uint8_t sbchnlReqRegionFullParams)
{
m_sbchnlReqRegionFullParams = sbchnlReqRegionFullParams;
}
void
OfdmUcdChannelEncodings::SetSbchnlFocContCodes (uint8_t sbchnlFocContCodes)
{
m_sbchnlFocContCodes = sbchnlFocContCodes;
}
uint8_t
OfdmUcdChannelEncodings::GetSbchnlReqRegionFullParams (void) const
{
return m_sbchnlReqRegionFullParams;
}
uint8_t
OfdmUcdChannelEncodings::GetSbchnlFocContCodes (void) const
{
return m_sbchnlFocContCodes;
}
uint16_t
OfdmUcdChannelEncodings::GetSize (void) const
{
return UcdChannelEncodings::GetSize () + 1 + 1;
}
Buffer::Iterator
OfdmUcdChannelEncodings::DoWrite (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_sbchnlReqRegionFullParams);
i.WriteU8 (m_sbchnlFocContCodes);
return i;
}
Buffer::Iterator
OfdmUcdChannelEncodings::DoRead (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_sbchnlReqRegionFullParams = i.ReadU8 ();
m_sbchnlFocContCodes = i.ReadU8 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
OfdmUlBurstProfile::OfdmUlBurstProfile (void)
: m_type (0),
m_length (0),
m_uiuc (0),
m_fecCodeType (0)
{
}
OfdmUlBurstProfile::~OfdmUlBurstProfile (void)
{
}
void
OfdmUlBurstProfile::SetType (uint8_t type)
{
m_type = type;
}
void
OfdmUlBurstProfile::SetLength (uint8_t length)
{
m_length = length;
}
void
OfdmUlBurstProfile::SetUiuc (uint8_t uiuc)
{
m_uiuc = uiuc;
}
void
OfdmUlBurstProfile::SetFecCodeType (uint8_t fecCodeType)
{
m_fecCodeType = fecCodeType;
}
uint8_t
OfdmUlBurstProfile::GetType (void) const
{
return m_type;
}
uint8_t
OfdmUlBurstProfile::GetLength (void) const
{
return m_length;
}
uint8_t
OfdmUlBurstProfile::GetUiuc (void) const
{
return m_uiuc;
}
uint8_t
OfdmUlBurstProfile::GetFecCodeType (void) const
{
return m_fecCodeType;
}
uint16_t
OfdmUlBurstProfile::GetSize (void) const
{
return 1 + 1 + 1 + 1;
}
Buffer::Iterator
OfdmUlBurstProfile::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_type);
i.WriteU8 (m_length);
i.WriteU8 (m_uiuc);
i.WriteU8 (m_fecCodeType);
return i;
}
Buffer::Iterator
OfdmUlBurstProfile::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_type = i.ReadU8 ();
m_length = i.ReadU8 ();
m_uiuc = i.ReadU8 ();
m_fecCodeType = i.ReadU8 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
Ucd::Ucd (void)
: m_configurationChangeCount (0),
m_rangingBackoffStart (0),
m_rangingBackoffEnd (0),
m_requestBackoffStart (0),
m_requestBackoffEnd (
0),
m_nrUlBurstProfiles (0)
{
}
Ucd::~Ucd (void)
{
}
void
Ucd::SetConfigurationChangeCount (uint8_t configurationChangeCount)
{
m_configurationChangeCount = configurationChangeCount;
}
void
Ucd::SetRangingBackoffStart (uint8_t rangingBackoffStart)
{
m_rangingBackoffStart = rangingBackoffStart;
}
void
Ucd::SetRangingBackoffEnd (uint8_t rangingBackoffEnd)
{
m_rangingBackoffEnd = rangingBackoffEnd;
}
void
Ucd::SetRequestBackoffStart (uint8_t requestBackoffStart)
{
m_requestBackoffStart = requestBackoffStart;
}
void
Ucd::SetRequestBackoffEnd (uint8_t requestBackoffEnd)
{
m_requestBackoffEnd = requestBackoffEnd;
}
void
Ucd::SetChannelEncodings (OfdmUcdChannelEncodings channelEncodings)
{
m_channelEncodings = channelEncodings;
}
void
Ucd::AddUlBurstProfile (OfdmUlBurstProfile ulBurstProfile)
{
m_ulBurstProfiles.push_back (ulBurstProfile);
}
void
Ucd::SetNrUlBurstProfiles (uint8_t nrUlBurstProfiles)
{
// number of burst profiles is set to number of UL-MAP IEs after processing UL-MAP
m_nrUlBurstProfiles = nrUlBurstProfiles;
}
uint8_t
Ucd::GetConfigurationChangeCount (void) const
{
return m_configurationChangeCount;
}
uint8_t
Ucd::GetRangingBackoffStart (void) const
{
return m_rangingBackoffStart;
}
uint8_t
Ucd::GetRangingBackoffEnd (void) const
{
return m_rangingBackoffEnd;
}
uint8_t
Ucd::GetRequestBackoffStart (void) const
{
return m_requestBackoffStart;
}
uint8_t
Ucd::GetRequestBackoffEnd (void) const
{
return m_requestBackoffEnd;
}
OfdmUcdChannelEncodings
Ucd::GetChannelEncodings (void) const
{
return m_channelEncodings;
}
std::vector<OfdmUlBurstProfile>
Ucd::GetUlBurstProfiles (void) const
{
return m_ulBurstProfiles;
}
uint8_t
Ucd::GetNrUlBurstProfiles (void) const
{
return m_nrUlBurstProfiles;
}
std::string
Ucd::GetName (void) const
{
return "UCD";
}
TypeId
Ucd::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::Ucd")
.SetParent<Header> ()
.AddConstructor<Ucd> ()
;
return tid;
}
TypeId
Ucd::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
Ucd::Print (std::ostream &os) const
{
os << " configuration change count = "
<< (uint32_t) m_configurationChangeCount << ", ranging backoff start = "
<< (uint32_t) m_rangingBackoffStart << ", ranging backoff end = "
<< (uint32_t) m_rangingBackoffEnd << ", request backoff start = "
<< (uint32_t) m_requestBackoffStart << ", request backoff end = "
<< (uint32_t) m_requestBackoffEnd << ", number of ul burst profiles = "
<< m_ulBurstProfiles.size ();
}
uint32_t
Ucd::GetSerializedSize (void) const
{
uint32_t ulBurstProfilesSize = 0;
for (std::vector<OfdmUlBurstProfile>::const_iterator iter =
m_ulBurstProfiles.begin (); iter != m_ulBurstProfiles.end (); ++iter)
{
OfdmUlBurstProfile burstProfile = *iter;
ulBurstProfilesSize += burstProfile.GetSize ();
}
return 5 + m_channelEncodings.GetSize () + ulBurstProfilesSize;
}
void
Ucd::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_configurationChangeCount);
i.WriteU8 (m_rangingBackoffStart);
i.WriteU8 (m_rangingBackoffEnd);
i.WriteU8 (m_requestBackoffStart);
i.WriteU8 (m_requestBackoffEnd);
i = m_channelEncodings.Write (i);
for (std::vector<OfdmUlBurstProfile>::const_iterator iter =
m_ulBurstProfiles.begin (); iter != m_ulBurstProfiles.end (); ++iter)
{
OfdmUlBurstProfile burstProfile = *iter;
i = burstProfile.Write (i);
}
}
uint32_t
Ucd::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_configurationChangeCount = i.ReadU8 ();
m_rangingBackoffStart = i.ReadU8 ();
m_rangingBackoffEnd = i.ReadU8 ();
m_requestBackoffStart = i.ReadU8 ();
m_requestBackoffEnd = i.ReadU8 ();
i = m_channelEncodings.Read (i);
for (uint8_t j = 0; j < m_nrUlBurstProfiles; j++)
{
OfdmUlBurstProfile burstProfile;
i = burstProfile.Read (i);
AddUlBurstProfile (burstProfile);
}
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------
OfdmUlMapIe::OfdmUlMapIe (void)
: m_cid (),
m_startTime (0),
m_subchannelIndex (0),
m_uiuc (0),
m_duration (0),
m_midambleRepetitionInterval (0)
{
}
OfdmUlMapIe::~OfdmUlMapIe (void)
{
}
void
OfdmUlMapIe::SetCid (Cid cid)
{
m_cid = cid;
}
void
OfdmUlMapIe::SetStartTime (uint16_t startTime)
{
m_startTime = startTime;
}
void
OfdmUlMapIe::SetSubchannelIndex (uint8_t subchannelIndex)
{
m_subchannelIndex = subchannelIndex;
}
void
OfdmUlMapIe::SetUiuc (uint8_t uiuc)
{
m_uiuc = uiuc;
}
void
OfdmUlMapIe::SetDuration (uint16_t duration)
{
m_duration = duration;
}
void
OfdmUlMapIe::SetMidambleRepetitionInterval (
uint8_t midambleRepetitionInterval)
{
m_midambleRepetitionInterval = midambleRepetitionInterval;
}
Cid
OfdmUlMapIe::GetCid (void) const
{
return m_cid;
}
uint16_t
OfdmUlMapIe::GetStartTime (void) const
{
return m_startTime;
}
uint8_t
OfdmUlMapIe::GetSubchannelIndex (void) const
{
return m_subchannelIndex;
}
uint8_t
OfdmUlMapIe::GetUiuc (void) const
{
return m_uiuc;
}
uint16_t
OfdmUlMapIe::GetDuration (void) const
{
return m_duration;
}
uint8_t
OfdmUlMapIe::GetMidambleRepetitionInterval (void) const
{
return m_midambleRepetitionInterval;
}
uint16_t
OfdmUlMapIe::GetSize (void) const
{
return 2 + 2 + 1 + 1 + 2 + 1;
}
Buffer::Iterator
OfdmUlMapIe::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_cid.GetIdentifier ());
i.WriteU16 (m_startTime);
i.WriteU8 (m_subchannelIndex);
i.WriteU8 (m_uiuc);
i.WriteU16 (m_duration);
i.WriteU8 (m_midambleRepetitionInterval);
return i;
}
Buffer::Iterator
OfdmUlMapIe::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_cid = i.ReadU16 ();
m_startTime = i.ReadU16 ();
m_subchannelIndex = i.ReadU8 ();
m_uiuc = i.ReadU8 ();
m_duration = i.ReadU16 ();
m_midambleRepetitionInterval = i.ReadU8 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (UlMap);
UlMap::UlMap (void)
: m_reserved (0),
m_ucdCount (0),
m_allocationStartTime (0)
{
}
UlMap::~UlMap (void)
{
}
void
UlMap::SetUcdCount (uint8_t ucdCount)
{
m_ucdCount = ucdCount;
}
void
UlMap::SetAllocationStartTime (uint32_t allocationStartTime)
{
m_allocationStartTime = allocationStartTime;
}
void
UlMap::AddUlMapElement (OfdmUlMapIe ulMapElement)
{
m_ulMapElements.push_back (ulMapElement);
}
uint8_t
UlMap::GetUcdCount (void) const
{
return m_ucdCount;
}
uint32_t
UlMap::GetAllocationStartTime (void) const
{
return m_allocationStartTime;
}
std::list<OfdmUlMapIe>
UlMap::GetUlMapElements (void) const
{
return m_ulMapElements;
}
std::string
UlMap::GetName (void) const
{
return "UL-MAP";
}
TypeId
UlMap::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::UlMap")
.SetParent<Header> ()
.AddConstructor<UlMap> ()
;
return tid;
}
TypeId
UlMap::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
UlMap::Print (std::ostream &os) const
{
os << " ucd count = " << (uint32_t) m_ucdCount
<< ", allocation start time = " << m_allocationStartTime
<< ", number of ul-map elements = " << m_ulMapElements.size ();
}
uint32_t
UlMap::GetSerializedSize (void) const
{
uint32_t ulMapElementsSize = 0;
for (std::list<OfdmUlMapIe>::const_iterator iter = m_ulMapElements.begin (); iter
!= m_ulMapElements.end (); ++iter)
{
OfdmUlMapIe ulMapIe = *iter;
ulMapElementsSize += ulMapIe.GetSize ();
}
return 1 + 1 + 4 + ulMapElementsSize;
}
void
UlMap::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_reserved);
i.WriteU8 (m_ucdCount);
i.WriteU32 (m_allocationStartTime);
for (std::list<OfdmUlMapIe>::const_iterator iter = m_ulMapElements.begin (); iter
!= m_ulMapElements.end (); ++iter)
{
OfdmUlMapIe ulMapIe = *iter;
i = ulMapIe.Write (i);
}
}
uint32_t
UlMap::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_reserved = i.ReadU8 ();
m_ucdCount = i.ReadU8 ();
m_allocationStartTime = i.ReadU32 ();
m_ulMapElements.clear (); // only for printing, otherwise it shows wrong number of elements
while (true)
{
OfdmUlMapIe ulMapIe;
i = ulMapIe.Read (i);
AddUlMapElement (ulMapIe);
if (ulMapIe.GetUiuc () == 14) // End of Map IE
{
break;
}
}
return i.GetDistanceFrom (start);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ul-mac-messages.cc | C++ | gpl2 | 14,014 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef SIMPLE_OFDM_WIMAX_PHY_H
#define SIMPLE_OFDM_WIMAX_PHY_H
#include <stdint.h>
#include <list>
#include "ns3/callback.h"
#include "ns3/nstime.h"
#include "ns3/event-id.h"
#include "wimax-phy.h"
#include "bvec.h"
#include "ns3/snr-to-block-error-rate-manager.h"
#include "wimax-connection.h"
namespace ns3 {
class WimaxChannel;
class WimaxNetDevice;
class NetDevice;
class Packet;
class SimpleOfdmWimaxChannel;
/**
* \ingroup wimax
*/
class SimpleOfdmWimaxPhy : public WimaxPhy
{
public:
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
};
static TypeId GetTypeId (void);
SimpleOfdmWimaxPhy (void);
SimpleOfdmWimaxPhy (char * tracesPath);
~SimpleOfdmWimaxPhy (void);
/**
* \brief if called with true it will enable the loss model
* \param loss set to true to enable the loss model
*/
void ActivateLoss (bool loss);
/**
* \brief Set the path of the repository containing the traces
* \param tracesPath the path to the repository.
* see snr-to-block-error-rate-manager.h for more details.
*/
void SetSNRToBlockErrorRateTracesPath (char * tracesPath);
/**
* Attach the physical layer to a channel.
* \param channel the channel to which the physical layer will be attached
*/
void DoAttach (Ptr<WimaxChannel> channel);
/**
* \brief set the callback function to call when a burst is received
*/
void SetReceiveCallback (Callback<void, Ptr<PacketBurst>, Ptr<WimaxConnection> > callback);
/**
* \brief Sends a burst on the channel
* \param burst the burst to send
* \param modulationType the modulation that will be used to send this burst
* \param direction set to uplink or downlink
*/
void Send (Ptr<PacketBurst> burst, WimaxPhy::ModulationType modulationType, uint8_t direction);
/**
* \brief Sends a burst on the channel
* \see SendParams
*/
void Send (SendParams *params);
/**
* \brief returns the type this physical layer
* \return always WimaxPhy::simpleOfdmWimaxPhy;
*/
WimaxPhy::PhyType GetPhyType (void) const;
/**
* \brief start the reception of a fec block
* \param burstSize the burst size
* \param isFirstBlock true if this block is the first one, false otherwise
* \param frequency the frequency in wich the fec block is being received
* \param modulationType the modulation used to transmit this fec Block
* \param direction set to uplink and downlink
* \param rxPower the received power.
* \param burst the burst to be sent
*/
void StartReceive (uint32_t burstSize,
bool isFirstBlock,
uint64_t frequency,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
double rxPower,
Ptr<PacketBurst> burst);
/**
* \return the bandwidth
*/
uint32_t GetBandwidth (void) const;
/**
* \brief Set the bandwidth
* \param BW the bandwidth
*/
void SetBandwidth (uint32_t BW);
/**
* \return the transmission power
*/
double GetTxPower (void) const;
/**
* \brief set the transmission power
* \param txPower the transmission power
*/
void SetTxPower (double txPower);
/**
* \return the noise figure
*/
double GetNoiseFigure (void) const;
/**
* \brief set the noise figure of the device
* \param nf the noise figure
*/
void SetNoiseFigure (double nf);
/**
* Public method used to fire a PhyTxBegin trace. Implemented for encapsulation
* purposes.
*/
void NotifyTxBegin (Ptr<PacketBurst> burst);
/**
* Public method used to fire a PhyTxEnd trace. Implemented for encapsulation
* purposes.
*/
void NotifyTxEnd (Ptr<PacketBurst> burst);
/**
* Public method used to fire a PhyTxDrop trace. Implemented for encapsulation
* purposes.
*/
void NotifyTxDrop (Ptr<PacketBurst> burst);
/**
* Public method used to fire a PhyRxBegin trace. Implemented for encapsulation
* purposes.
*/
void NotifyRxBegin (Ptr<PacketBurst> burst);
/**
* Public method used to fire a PhyRxEnd trace. Implemented for encapsulation
* purposes.
*/
void NotifyRxEnd (Ptr<PacketBurst> burst);
/**
* Public method used to fire a PhyRxDrop trace. Implemented for encapsulation
* purposes.
*/
void NotifyRxDrop (Ptr<PacketBurst> burst);
private:
Time DoGetTransmissionTime (uint32_t size, WimaxPhy::ModulationType modulationType) const;
uint64_t DoGetNrSymbols (uint32_t size, WimaxPhy::ModulationType modulationType) const;
uint64_t DoGetNrBytes (uint32_t symbols, WimaxPhy::ModulationType modulationType) const;
bvec ConvertBurstToBits (Ptr<const PacketBurst> burst);
Ptr<PacketBurst> ConvertBitsToBurst (bvec buffer);
void CreateFecBlocks (const bvec &buffer, WimaxPhy::ModulationType modulationType);
bvec RecreateBuffer ();
uint32_t GetFecBlockSize (WimaxPhy::ModulationType type) const;
uint32_t GetCodedFecBlockSize (WimaxPhy::ModulationType modulationType) const;
void SetBlockParameters (uint32_t burstSize, WimaxPhy::ModulationType modulationType);
uint16_t GetNrBlocks (uint32_t burstSize, WimaxPhy::ModulationType modulationType) const;
void DoDispose (void);
void EndSend (void);
void EndSendFecBlock (WimaxPhy::ModulationType modulationType, uint8_t direction);
void EndReceive (Ptr<const PacketBurst> burst);
void EndReceiveFecBlock (uint32_t burstSize,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
uint8_t drop,
Ptr<PacketBurst> burst);
void StartSendDummyFecBlock (bool isFirstBlock,
WimaxPhy::ModulationType modulationType,
uint8_t direction);
Time GetBlockTransmissionTime (WimaxPhy::ModulationType modulationType) const;
void DoSetDataRates (void);
void InitSimpleOfdmWimaxPhy (void);
void GetModulationFecParams (WimaxPhy::ModulationType modulationType, uint8_t &bitsPerSymbol, double &fecCode) const;
uint32_t CalculateDataRate (WimaxPhy::ModulationType modulationType) const;
uint32_t DoGetDataRate (WimaxPhy::ModulationType modulationType) const;
uint16_t DoGetTtg (void) const;
uint16_t DoGetRtg (void) const;
uint8_t DoGetFrameDurationCode (void) const;
Time DoGetFrameDuration (uint8_t frameDurationCode) const;
void DoSetPhyParameters (void);
uint16_t DoGetNfft (void) const;
void DoSetNfft (uint16_t);
double DoGetSamplingFactor (void) const;
double DoGetSamplingFrequency (void) const;
double DoGetGValue (void) const;
void DoSetGValue (double);
double GetRxGain (void) const;
void SetRxGain (double rxgain);
double GetTxGain (void) const;
void SetTxGain (double txgain);
std::string GetTraceFilePath (void) const;
void SetTraceFilePath (std::string path);
uint16_t m_fecBlockSize; // in bits, size of FEC block transmitted after PHY operations
uint32_t m_currentBurstSize;
std::list<bvec> *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<bvec> *m_fecBlocks;
Time m_blockTime;
TracedCallback<Ptr<const PacketBurst> > m_traceRx;
TracedCallback<Ptr<const PacketBurst> > m_traceTx;
// 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;
// parameters to store for a per burst life-time
uint16_t m_nrBlocks;
uint16_t m_nrRemainingBlocksToSend;
Ptr<PacketBurst> 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;
/**
* The trace source fired when a packet begins the transmission process on
* the medium.
*
* \see class CallBackTraceSource
*/
TracedCallback <Ptr<PacketBurst > > m_phyTxBeginTrace;
/**
* The trace source fired when a packet ends the transmission process on
* the medium.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<PacketBurst > > m_phyTxEndTrace;
/**
* The trace source fired when the phy layer drops a packet as it tries
* to transmit it.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<PacketBurst > > m_phyTxDropTrace;
/**
* The trace source fired when a packet begins the reception process from
* the medium.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<PacketBurst > > m_phyRxBeginTrace;
/**
* The trace source fired when a packet ends the reception process from
* the medium.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<PacketBurst > > m_phyRxEndTrace;
/**
* The trace source fired when the phy layer drops a packet it has received.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<PacketBurst > > m_phyRxDropTrace;
SNRToBlockErrorRateManager * m_snrToBlockErrorRateManager;
};
} // namespace ns3
#endif /* OFDM_WIMAX_PHY_H */
| zy901002-gpsr | src/wimax/model/simple-ofdm-wimax-phy.h | C++ | gpl2 | 10,307 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "bandwidth-manager.h"
#include "ns3/node.h"
#include "bs-net-device.h"
#include "ss-net-device.h"
#include "ns3/simulator.h"
#include "burst-profile-manager.h"
#include "ss-manager.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
#include "connection-manager.h"
NS_LOG_COMPONENT_DEFINE ("BandwidthManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BandwidthManager);
TypeId BandwidthManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BandwidthManager")
.SetParent<Object> ();
return tid;
}
BandwidthManager::BandwidthManager (Ptr<WimaxNetDevice> device)
: m_device (device),
m_nrBwReqsSent (0)
{
}
BandwidthManager::~BandwidthManager (void)
{
}
void
BandwidthManager::DoDispose (void)
{
m_device = 0;
}
uint32_t
BandwidthManager::CalculateAllocationSize (const SSRecord *ssRecord, const ServiceFlow *serviceFlow)
{
Time currentTime = Simulator::Now ();
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
uint32_t allocationSize = 0;
// if SS has a UGS flow then it must set poll-me bit in order to be polled for non-UGS flows
if (serviceFlow->GetSchedulingType () != ServiceFlow::SF_TYPE_UGS
&& ssRecord->GetHasServiceFlowUgs ()
&& !ssRecord->GetPollMeBit ())
{
return 0;
}
switch (serviceFlow->GetSchedulingType ())
{
case ServiceFlow::SF_TYPE_UGS:
{
if ((currentTime - serviceFlow->GetRecord ()->GetGrantTimeStamp ()).GetMilliSeconds ()
>= serviceFlow->GetUnsolicitedGrantInterval ())
{
allocationSize = serviceFlow->GetRecord ()->GetGrantSize ();
serviceFlow->GetRecord ()->SetGrantTimeStamp (currentTime);
}
}
break;
case ServiceFlow::SF_TYPE_RTPS:
{
if ((currentTime - serviceFlow->GetRecord ()->GetGrantTimeStamp ()).GetMilliSeconds ()
>= serviceFlow->GetUnsolicitedPollingInterval ())
{
allocationSize = bs->GetBwReqOppSize ();
serviceFlow->GetRecord ()->SetGrantTimeStamp (currentTime);
}
}
break;
case ServiceFlow::SF_TYPE_NRTPS:
{
/* nrtPS shall be serviced only if sufficient bandwidth is available after servicing
UGS and rtPS scheduling types, hence no specific service interval is used */
allocationSize = bs->GetBwReqOppSize ();
}
break;
case ServiceFlow::SF_TYPE_BE:
{
/* BE shall be serviced only if sufficient bandwidth is available after servicing
the rest of three scheduling types, hence no specific service interval is used */
allocationSize = bs->GetBwReqOppSize ();
}
break;
default:
NS_FATAL_ERROR ("Invalid scheduling type");
}
return allocationSize;
}
ServiceFlow*
BandwidthManager::SelectFlowForRequest (uint32_t &bytesToRequest)
{
Ptr<Packet> packet;
ServiceFlow *serviceFlow = 0;
Ptr<SubscriberStationNetDevice> ss = m_device->GetObject<SubscriberStationNetDevice> ();
std::vector<ServiceFlow*> serviceFlows = ss->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_ALL);
for (std::vector<ServiceFlow*>::iterator iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
serviceFlow = *iter;
if (serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_RTPS
|| serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_NRTPS
|| serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_BE)
{
if (serviceFlow->HasPackets (MacHeaderType::HEADER_TYPE_GENERIC))
{
// bandwidth is requested for all packets
bytesToRequest = serviceFlow->GetQueue ()->GetQueueLengthWithMACOverhead ();
break;
}
}
}
return serviceFlow;
}
void
BandwidthManager::SendBandwidthRequest (uint8_t uiuc, uint16_t allocationSize)
{
Ptr<SubscriberStationNetDevice> ss = m_device->GetObject<SubscriberStationNetDevice> ();
uint32_t bytesToRequest = 0;
ServiceFlow *serviceFlow = SelectFlowForRequest (bytesToRequest);
if (!serviceFlow || !bytesToRequest)
{
return;
}
BandwidthRequestHeader bwRequestHdr;
// bytesToRequest is the queue length of Service Flow and so,
// the header type must be HEADER_TYPE_AGGREGATE!
bwRequestHdr.SetType ((uint8_t) BandwidthRequestHeader::HEADER_TYPE_AGGREGATE);
bwRequestHdr.SetCid (serviceFlow->GetConnection ()->GetCid ());
bwRequestHdr.SetBr (bytesToRequest);
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (bwRequestHdr);
ss->Enqueue (packet, MacHeaderType (MacHeaderType::HEADER_TYPE_BANDWIDTH), serviceFlow->GetConnection ());
m_nrBwReqsSent++;
NS_ASSERT_MSG (uiuc == OfdmUlBurstProfile::UIUC_REQ_REGION_FULL, "Send Bandwidth Request: !UIUC_REQ_REGION_FULL");
ss->SendBurst (uiuc, allocationSize, serviceFlow->GetConnection (), MacHeaderType::HEADER_TYPE_BANDWIDTH);
}
void
BandwidthManager::ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr)
{
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
ServiceFlow *serviceFlow = bs->GetConnectionManager ()->GetConnection (bwRequestHdr.GetCid ())->GetServiceFlow ();
if (bwRequestHdr.GetType () == (uint8_t) BandwidthRequestHeader::HEADER_TYPE_INCREMENTAL)
{
serviceFlow->GetRecord ()->UpdateRequestedBandwidth (bwRequestHdr.GetBr ());
}
else
{
serviceFlow->GetRecord ()->SetRequestedBandwidth (bwRequestHdr.GetBr ());
bs->GetUplinkScheduler ()->OnSetRequestedBandwidth (serviceFlow->GetRecord ());
}
bs->GetUplinkScheduler ()->ProcessBandwidthRequest (bwRequestHdr);
// update backlogged
serviceFlow->GetRecord ()->IncreaseBacklogged (bwRequestHdr.GetBr ());
}
void
BandwidthManager::SetSubframeRatio (void)
{
// sets ratio of the DL and UL subframes
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
uint32_t symbolsPerFrame = bs->GetPhy ()->GetSymbolsPerFrame ();
/* temporarily divided in half (360 symbols each), shall actually be determined based on UL and DL traffic*/
bs->SetNrDlSymbols (symbolsPerFrame / 2);
bs->SetNrUlSymbols (symbolsPerFrame / 2);
}
uint32_t
BandwidthManager::GetSymbolsPerFrameAllocated (void)
{
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
uint32_t allocationPerFrame = 0;
std::vector<SSRecord*> *ssRecords = bs->GetSSManager ()->GetSSRecords ();
for (std::vector<SSRecord*>::iterator iter1 = ssRecords->begin (); iter1 != ssRecords->end (); ++iter1)
{
for (std::vector<ServiceFlow*>::iterator iter2 = (*iter1)->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).begin ();
iter2 != (*iter1)->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).end (); ++iter2)
{
allocationPerFrame += (*iter2)->GetRecord ()->GetGrantSize ();
}
}
return allocationPerFrame;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bandwidth-manager.cc | C++ | gpl2 | 7,974 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include "wimax-connection.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "ns3/uinteger.h"
#include "service-flow.h"
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxConnection);
TypeId WimaxConnection::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxConnection")
.SetParent<Object> ()
.AddAttribute ("Type",
"Connection type",
EnumValue (Cid::INITIAL_RANGING),
MakeEnumAccessor (&WimaxConnection::GetType),
MakeEnumChecker (Cid::BROADCAST,
"Broadcast",
Cid::INITIAL_RANGING,
"InitialRanging",
Cid::BASIC,
"Basic",
Cid::PRIMARY,
"Primary",
Cid::TRANSPORT,
"Transport",
Cid::MULTICAST,
"Multicast",
Cid::PADDING,
"Padding"))
.AddAttribute ("TxQueue",
"Transmit queue",
PointerValue (),
MakePointerAccessor (&WimaxConnection::GetQueue),
MakePointerChecker<WimaxMacQueue> ());
return tid;
}
WimaxConnection::WimaxConnection (Cid cid, enum Cid::Type type)
: m_cid (cid),
m_cidType (type),
m_queue (CreateObject<WimaxMacQueue> (1024)),
m_serviceFlow (0)
{
}
WimaxConnection::~WimaxConnection (void)
{
}
void
WimaxConnection::DoDispose (void)
{
m_queue = 0;
// m_serviceFlow = 0;
}
Cid
WimaxConnection::GetCid (void) const
{
return m_cid;
}
enum Cid::Type
WimaxConnection::GetType (void) const
{
return m_cidType;
}
Ptr<WimaxMacQueue>
WimaxConnection::GetQueue (void) const
{
return m_queue;
}
void
WimaxConnection::SetServiceFlow (ServiceFlow *serviceFlow)
{
m_serviceFlow = serviceFlow;
}
ServiceFlow*
WimaxConnection::GetServiceFlow (void) const
{
return m_serviceFlow;
}
uint8_t
WimaxConnection::GetSchedulingType (void) const
{
return m_serviceFlow->GetSchedulingType ();
}
bool
WimaxConnection::Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType, const GenericMacHeader &hdr)
{
return m_queue->Enqueue (packet, hdrType, hdr);
}
Ptr<Packet>
WimaxConnection::Dequeue (MacHeaderType::HeaderType packetType)
{
return m_queue->Dequeue (packetType);
}
Ptr<Packet>
WimaxConnection::Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte)
{
return m_queue->Dequeue (packetType, availableByte);
}
bool
WimaxConnection::HasPackets (void) const
{
return !m_queue->IsEmpty ();
}
bool
WimaxConnection::HasPackets (MacHeaderType::HeaderType packetType) const
{
return !m_queue->IsEmpty (packetType);
}
std::string
WimaxConnection::GetTypeStr (void) const
{
switch (m_cidType)
{
case Cid::BROADCAST:
return "Broadcast";
break;
case Cid::INITIAL_RANGING:
return "Initial Ranging";
break;
case Cid::BASIC:
return "Basic";
break;
case Cid::PRIMARY:
return "Primary";
break;
case Cid::TRANSPORT:
return "Transport";
break;
case Cid::MULTICAST:
return "Multicast";
break;
default:
NS_FATAL_ERROR ("Invalid connection type");
}
return "";
}
// Defragmentation Function
const
WimaxConnection::FragmentsQueue WimaxConnection::GetFragmentsQueue (void) const
{
return m_fragmentsQueue;
}
void
WimaxConnection::FragmentEnqueue (Ptr<const Packet> fragment)
{
m_fragmentsQueue.push_back (fragment);
}
void
WimaxConnection::ClearFragmentsQueue (void)
{
m_fragmentsQueue.clear ();
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-connection.cc | C++ | gpl2 | 4,745 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include <stdint.h>
#include <stdint.h>
#include "ofdm-downlink-frame-prefix.h"
#include "ns3/address-utils.h"
namespace ns3 {
DlFramePrefixIe::DlFramePrefixIe ()
: m_rateId (0),
m_diuc (0),
m_preamblePresent (0),
m_length (0),
m_startTime (0)
{
}
DlFramePrefixIe::~DlFramePrefixIe ()
{
}
void
DlFramePrefixIe::SetRateId (uint8_t rateId)
{
m_rateId = rateId;
}
void
DlFramePrefixIe::SetDiuc (uint8_t diuc)
{
m_diuc = diuc;
}
void
DlFramePrefixIe::SetPreamblePresent (uint8_t preamblePresent)
{
m_preamblePresent = preamblePresent;
}
void
DlFramePrefixIe::SetLength (uint16_t length)
{
m_length = length;
}
void
DlFramePrefixIe::SetStartTime (uint16_t startTime)
{
m_startTime = startTime;
}
uint8_t
DlFramePrefixIe::GetRateId (void) const
{
return m_rateId;
}
uint8_t
DlFramePrefixIe::GetDiuc (void) const
{
return m_diuc;
}
uint8_t
DlFramePrefixIe::GetPreamblePresent (void) const
{
return m_preamblePresent;
}
uint16_t
DlFramePrefixIe::GetLength (void) const
{
return m_length;
}
uint16_t
DlFramePrefixIe::GetStartTime (void) const
{
return m_startTime;
}
uint16_t
DlFramePrefixIe::GetSize (void) const
{
return 1 + 1 + 1 + 2 + 2;
}
Buffer::Iterator
DlFramePrefixIe::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_rateId);
i.WriteU8 (m_diuc);
i.WriteU8 (m_preamblePresent);
i.WriteU16 (m_length);
i.WriteU16 (m_startTime);
return i;
}
Buffer::Iterator
DlFramePrefixIe::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_rateId = i.ReadU8 ();
m_diuc = i.ReadU8 ();
m_preamblePresent = i.ReadU8 ();
m_length = i.ReadU16 ();
m_startTime = i.ReadU16 ();
return i;
}
OfdmDownlinkFramePrefix::OfdmDownlinkFramePrefix ()
: m_baseStationId (Mac48Address ("00:00:00:00:00:00")),
m_frameNumber (0),
m_configurationChangeCount (0),
m_hcs (0)
{
}
OfdmDownlinkFramePrefix::~OfdmDownlinkFramePrefix ()
{
}
void
OfdmDownlinkFramePrefix::SetBaseStationId (Mac48Address baseStationId)
{
m_baseStationId = baseStationId;
}
void
OfdmDownlinkFramePrefix::SetFrameNumber (uint32_t frameNumber)
{
m_frameNumber = frameNumber;
}
void
OfdmDownlinkFramePrefix::SetConfigurationChangeCount (
uint8_t configurationChangeCount)
{
m_configurationChangeCount = configurationChangeCount;
}
void
OfdmDownlinkFramePrefix::AddDlFramePrefixElement (
DlFramePrefixIe dlFramePrefixElement)
{
m_dlFramePrefixElements.push_back (dlFramePrefixElement);
}
void
OfdmDownlinkFramePrefix::SetHcs (uint8_t hcs)
{
m_hcs = hcs;
}
Mac48Address
OfdmDownlinkFramePrefix::GetBaseStationId (void) const
{
return m_baseStationId;
}
uint32_t
OfdmDownlinkFramePrefix::GetFrameNumber (void) const
{
return m_frameNumber;
}
uint8_t
OfdmDownlinkFramePrefix::GetConfigurationChangeCount (void) const
{
return m_configurationChangeCount;
}
std::vector<DlFramePrefixIe>
OfdmDownlinkFramePrefix::GetDlFramePrefixElements (void) const
{
return m_dlFramePrefixElements;
}
uint8_t
OfdmDownlinkFramePrefix::GetHcs (void) const
{
return m_hcs;
}
std::string
OfdmDownlinkFramePrefix::GetName (void) const
{
return "OFDM Downlink Frame Prefix";
}
void
OfdmDownlinkFramePrefix::Print (std::ostream &os) const
{
os << " base station id = " << m_baseStationId << ", frame number = "
<< m_frameNumber << ", configuration change count = "
<< (uint32_t) m_configurationChangeCount
<< ", number of dl frame prefix elements = "
<< m_dlFramePrefixElements.size () << ", hcs = " << (uint32_t) m_hcs;
}
uint32_t
OfdmDownlinkFramePrefix::GetSerializedSize (void) const
{
int dlFramePrefixElementsSize = 0;
for (std::vector<DlFramePrefixIe>::const_iterator iter =
m_dlFramePrefixElements.begin (); iter != m_dlFramePrefixElements.end (); iter++)
{
DlFramePrefixIe dlFramePrefixElement = *iter;
dlFramePrefixElementsSize += dlFramePrefixElement.GetSize ();
}
return 6 + 4 + 1 + dlFramePrefixElementsSize + 1;
}
void
OfdmDownlinkFramePrefix::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
WriteTo (i, m_baseStationId);
i.WriteU32 (m_frameNumber);
i.WriteU8 (m_configurationChangeCount);
for (std::vector<DlFramePrefixIe>::const_iterator iter =
m_dlFramePrefixElements.begin (); iter != m_dlFramePrefixElements.end (); iter++)
{
DlFramePrefixIe dlFramePrefixElement = *iter;
i = dlFramePrefixElement.Write (i);
}
i.WriteU8 (m_hcs);
}
uint32_t
OfdmDownlinkFramePrefix::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
ReadFrom (i, m_baseStationId);
m_frameNumber = i.ReadU32 ();
m_configurationChangeCount = i.ReadU8 ();
bool end = false;
while (!end)
{
DlFramePrefixIe dlFramePrefixElement;
i = dlFramePrefixElement.Read (i);
AddDlFramePrefixElement (dlFramePrefixElement);
if (dlFramePrefixElement.GetDiuc () == 14)
{
end = true;
}
}
m_hcs = i.ReadU8 ();
return GetSerializedSize ();
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ofdm-downlink-frame-prefix.cc | C++ | gpl2 | 5,856 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#ifndef IPCS_CLASSIFIER_RECORD_H
#define IPCS_CLASSIFIER_RECORD_H
#include <stdint.h>
#include "ns3/ipv4-address.h"
#include "wimax-tlv.h"
namespace ns3 {
/**
* \ingroup wimax
*/
class IpcsClassifierRecord
{
public:
IpcsClassifierRecord ();
~IpcsClassifierRecord ();
/**
* \brief creates a classifier records and sets all its parameters
* \param srcAddress the source ip address
* \param srcMask the mask to apply on the source ip address
* \param dstAddress the destination ip address
* \param dstMask the mask to apply on the destination ip address
* \param srcPortLow the lower boundary of the source port range
* \param srcPortHigh the higher boundary of the source port range
* \param dstPortLow the lower boundary of the destination port range
* \param dstPortHigh the higher boundary of the destination port range
* \param protocol the L4 protocol
* \param priority the priority of this classifier
*
*/
IpcsClassifierRecord (Ipv4Address srcAddress, Ipv4Mask srcMask,
Ipv4Address dstAddress, Ipv4Mask dstMask,
uint16_t srcPortLow, uint16_t srcPortHigh,
uint16_t dstPortLow, uint16_t dstPortHigh,
uint8_t protocol,
uint8_t priority);
/**
* \brief Decodes a TLV and creates a classifier
* \param tlv the TLV to decode and from which the classifier parameters will be extracted
*/
IpcsClassifierRecord (Tlv tlv);
/**
* \brief Creates a TLV from this classifier
* \return the created TLV
*/
Tlv ToTlv (void) const;
/**
* \brief add a new source ip address to the classifier
* \param srcAddress the source ip address
* \param srcMask the mask to apply on the source ip address
*/
void AddSrcAddr (Ipv4Address srcAddress, Ipv4Mask srcMask);
/**
* \brief add a new destination ip address to the classifier
* \param dstAddress the destination ip address
* \param dstMask the mask to apply on the destination ip address
*/
void AddDstAddr (Ipv4Address dstAddress, Ipv4Mask dstMask);
/**
* \brief add a range of source port to the classifier
* \param srcPortLow the lower boundary of the source port range
* \param srcPortHigh the higher boundary of the source port range
*/
void AddSrcPortRange ( uint16_t srcPortLow, uint16_t srcPortHigh);
/**
* \brief add a range of destination port to the classifier
* \param dstPortLow the lower boundary of the destination port range
* \param dstPortHigh the higher boundary of the destination port range
*/
void AddDstPortRange ( uint16_t dstPortLow, uint16_t dstPortHigh);
/**
* \brief add a protocol to the classifier
* \param proto the L4 protocol to add
*/
void AddProtocol (uint8_t proto);
/**
* \brief Set the priority of this classifier
* \param prio the priority of the classifier
*/
void SetPriority (uint8_t prio);
/**
* \brief Set the index of the classifier
* \param index the index of the classifier
*/
void SetIndex (uint16_t index);
/**
* \brief check if a packets can be used with this classifier
* \param srcAddress the source ip address of the packet
* \param dstAddress the destination ip address of the packet
* \param srcPort the source port of the packet
* \param dstPort the destination port of the packet
* \param proto The L4 protocol of the packet
*/
bool CheckMatch (Ipv4Address srcAddress, Ipv4Address dstAddress,
uint16_t srcPort, uint16_t dstPort,
uint8_t proto) const;
/**
* \return the cid associated with this classifier
*/
uint16_t GetCid (void) const;
/**
* \return the priority of this classifier
*/
uint8_t GetPriority (void) const;
/**
* \return the index of this classifier
*/
uint16_t GetIndex (void) const;
/**
* \brief Set the cid associated to this classifier
* \param cid the connection identifier
*/
void SetCid (uint16_t cid);
private:
bool CheckMatchSrcAddr (Ipv4Address srcAddress) const;
bool CheckMatchDstAddr (Ipv4Address dstAddress) const;
bool CheckMatchSrcPort (uint16_t srcPort) const;
bool CheckMatchDstPort (uint16_t dstPort) const;
bool CheckMatchProtocol (uint8_t proto) const;
struct PortRange
{
uint16_t PortLow;
uint16_t PortHigh;
};
struct ipv4Addr
{
Ipv4Address Address;
Ipv4Mask Mask;
};
uint8_t m_priority;
uint16_t m_index;
uint8_t m_tosLow;
uint8_t m_tosHigh;
uint8_t m_tosMask;
std::vector<uint8_t> m_protocol;
std::vector<struct ipv4Addr> m_srcAddr;
std::vector<struct ipv4Addr> m_dstAddr;
std::vector<struct PortRange> m_srcPortRange;
std::vector<struct PortRange> m_dstPortRange;
uint16_t m_cid;
};
} // namespace ns3
#endif /* IPCS_CLASSIFIER_RECORD_H */
| zy901002-gpsr | src/wimax/model/ipcs-classifier-record.h | C++ | gpl2 | 5,683 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef WIMAX_SS_NET_DEVICE_H
#define WIMAX_SS_NET_DEVICE_H
#include "ns3/event-id.h"
#include "wimax-net-device.h"
#include "ns3/nstime.h"
#include "wimax-mac-header.h"
#include "ns3/uinteger.h"
#include "ns3/ss-service-flow-manager.h"
#include "ipcs-classifier.h"
namespace ns3 {
class Node;
class OfdmDlBurstProfile;
class OfdmUlBurstProfile;
class SSScheduler;
class SSLinkManager;
class SsServiceFlowManager;
class IpcsClassifier;
/**
* \ingroup wimax
*/
class SubscriberStationNetDevice : public WimaxNetDevice
{
public:
enum State
{
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_STOPPED
};
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
};
static TypeId GetTypeId (void);
SubscriberStationNetDevice (void);
SubscriberStationNetDevice (Ptr<Node>, Ptr<WimaxPhy> );
~SubscriberStationNetDevice (void);
/**
* \brief initializes the net device and sets the parameters to the default values
*/
void InitSubscriberStationNetDevice (void);
/**
* \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;
/**
* \param lostUlMapInterval Time since last received UL-MAP before uplink synchronization is considered lost
*/
void SetLostUlMapInterval (Time lostUlMapInterval);
/**
* returns the time since last received UL-MAP before uplink synchronization is considered lost
*/
Time GetLostUlMapInterval (void) const;
/**
* \param maxDcdInterval Maximum time between transmission of DCD messages
*/
void SetMaxDcdInterval (Time maxDcdInterval);
/**
* returns the maximum time between transmission of DCD messages
*/
Time GetMaxDcdInterval (void) const;
/**
* \param maxUcdInterval Maximum time between transmission of UCD messages
*/
void SetMaxUcdInterval (Time maxUcdInterval);
/**
* returns the maximum time between transmission of UCD messages
*/
Time GetMaxUcdInterval (void) const;
/**
* \param interval1 Wait for DCD timeout
*/
void SetIntervalT1 (Time interval1);
/**
* returns the wait for DCD timeout
*/
Time GetIntervalT1 (void) const;
/**
* \param interval2 the wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity
*/
void SetIntervalT2 (Time interval2);
/**
* returns the wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity
*/
Time GetIntervalT2 (void) const;
/**
* \param interval3 the ranging Response reception timeout following the transmission of a ranging request
*/
void SetIntervalT3 (Time interval3);
/**
* returns the ranging Response reception timeout following the transmission of a ranging request
*/
Time GetIntervalT3 (void) const;
/**
* \param interval7 the wait for DSA/DSC/DSD Response timeout
*/
void SetIntervalT7 (Time interval7);
/**
* returns the wait for DSA/DSC/DSD Response timeout
*/
Time GetIntervalT7 (void) const;
/**
* \param interval12 the Wait for UCD descriptor timeout
*/
void SetIntervalT12 (Time interval12);
/**
* returns the wait for UCD descriptor timeout
*/
Time GetIntervalT12 (void) const;
/**
* \param interval20 the Time the SS searches for preambles on a given channel
*/
void SetIntervalT20 (Time interval20);
/**
* returns the Time the SS searches for preambles on a given channel
*/
Time GetIntervalT20 (void) const;
/**
* \param interval21 the time the SS searches for (decodable) DL-MAP on a given channel
*/
void SetIntervalT21 (Time interval21);
/**
* returns the time the SS searches for (decodable) DL-MAP on a given channel
*/
Time GetIntervalT21 (void) const;
/**
* \param maxContentionRangingRetries the Number of retries on contention Ranging Requests
*/
void SetMaxContentionRangingRetries (uint8_t maxContentionRangingRetries);
/**
* \returns the Number of retries on contention Ranging Requests
*/
uint8_t GetMaxContentionRangingRetries (void) const;
/**
* \param basicConnection the basic connection to be used
*/
void SetBasicConnection (Ptr<WimaxConnection> basicConnection);
/**
* \return the basic connection currently in use
*/
Ptr<WimaxConnection> GetBasicConnection (void) const;
/**
* \param primaryConnection the primary connection to be used
*/
void SetPrimaryConnection (Ptr<WimaxConnection> primaryConnection);
/**
* returns the primary connection currently usde
*/
Ptr<WimaxConnection> GetPrimaryConnection (void) const;
/**
* \returns the basic CID
*/
Cid GetBasicCid (void) const;
/**
* \returns the primary CID
*/
Cid GetPrimaryCid (void) const;
/**
* \brief Set the most efficient modulation and coding scheme (MCS) supported by the device
* \param modulationType the most robust MCS supported
*/
void SetModulationType (WimaxPhy::ModulationType modulationType);
/**
* returns the most efficient modulation and coding scheme (MCS) supported by the device
*/
WimaxPhy::ModulationType GetModulationType (void) const;
/**
* \param areManagementConnectionsAllocated true if the management connections are allocated, false otherwise
*/
void SetAreManagementConnectionsAllocated (bool areManagementConnectionsAllocated);
/**
* \returns true if the management connections are allocated, false otherwise
*/
bool GetAreManagementConnectionsAllocated (void) const;
/**
* \param areServiceFlowsAllocated true if the service flows are allocated, false otherwise
*/
void SetAreServiceFlowsAllocated (bool areServiceFlowsAllocated);
/**
* \returns true if the service flows are allocated, false otherwise
*/
bool GetAreServiceFlowsAllocated (void) const;
/**
* \return the scheduler installed on the device
*/
Ptr<SSScheduler> GetScheduler (void) const;
/**
* \param ssScheduler the scheduler to be installed on the device
*/
void SetScheduler (Ptr<SSScheduler> ssScheduler);
/**
* \returns true if the device has at least one active service flow, false otherwise
*/
bool HasServiceFlows (void) const;
/**
* \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
*/
bool Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType, Ptr<WimaxConnection> connection);
/**
* \brief Sends a burst on the uplink frame
*/
void SendBurst (uint8_t uiuc,
uint16_t nrSymbols,
Ptr<WimaxConnection> connection,
MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC);
void Start (void);
void Stop (void);
/**
* \brief adds a new service flow
*/
void AddServiceFlow (ServiceFlow *sf);
/**
* \brief adds a new service flow
*/
void AddServiceFlow (ServiceFlow sf);
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);
Ptr<SSLinkManager> m_linkManager;
/**
* \returns a pointer to the CS packet classifier
*/
Ptr<IpcsClassifier> GetIpcsClassifier () const;
/**
* \brief Sets the packet classifier to be used
*/
void SetIpcsPacketClassifier (Ptr<IpcsClassifier> );
/**
* \returns a pointer to the link manger currently used
*/
Ptr<SSLinkManager> GetLinkManager (void) const;
/**
* \brief sets the link manager to be used
*/
void SetLinkManager (Ptr<SSLinkManager> );
/**
* \returns a pointer to the service flow manager installed on the device
*/
Ptr<SsServiceFlowManager> GetServiceFlowManager (void) const;
/**
* \brief Sets the service flow manager to be installed on the device
*/
void SetServiceFlowManager (Ptr<SsServiceFlowManager> );
private:
static Time GetDefaultLostDlMapInterval ();
void DoDispose (void);
bool DoSend (Ptr<Packet> packet, const Mac48Address &source, const Mac48Address &dest, uint16_t protocolNumber);
void DoReceive (Ptr<Packet> packet);
void ProcessDlMap (const DlMap &dlmap);
void ProcessUlMap (const UlMap &ulmap);
void ProcessDcd (const Dcd &dcd);
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;
// parameters obtained from DL-MAP
uint8_t m_dcdCount;
Mac48Address m_baseStationId;
// parameters obtained from UL-MAP
uint8_t m_ucdCount;
double m_allocationStartTime;
// 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;
Ptr<WimaxConnection> m_basicConnection;
Ptr<WimaxConnection> m_primaryConnection;
EventId m_lostDlMapEvent, m_lostUlMapEvent, m_dcdWaitTimeoutEvent, m_ucdWaitTimeoutEvent, m_rangOppWaitTimeoutEvent;
uint32_t m_nrDlMapRecvd;
uint32_t m_nrUlMapRecvd;
uint32_t m_nrDcdRecvd;
uint32_t m_nrUcdRecvd;
OfdmDlBurstProfile *m_dlBurstProfile;
OfdmUlBurstProfile *m_ulBurstProfile;
/*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;
bool m_areManagementConnectionsAllocated;
bool m_areServiceFlowsAllocated;
Ptr<SSScheduler> m_scheduler;
Ptr<SsServiceFlowManager> m_serviceFlowManager;
Ptr<IpcsClassifier> m_classifier;
TracedCallback<Ptr<const Packet>, Mac48Address, Cid*> m_traceSSRx;
TracedCallback<Ptr<const PacketBurst>, Mac48Address, Cid*, WimaxPhy::ModulationType> m_traceSSTx;
/**
* The trace source fired when packets come into the "top" of the device
* at the L3/L2 transition, before being queued for transmission.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_ssTxTrace;
/**
* The trace source fired when packets coming into the "top" of the device
* are dropped at the MAC layer during transmission.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_ssTxDropTrace;
/**
* The trace source fired for packets successfully received by the device
* immediately before being forwarded up to higher layers (at the L2/L3
* transition). This is a promiscuous trace.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_ssPromiscRxTrace;
/**
* The trace source fired for packets successfully received by the device
* immediately before being forwarded up to higher layers (at the L2/L3
* transition). This is a non- promiscuous trace.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_ssRxTrace;
/**
* The trace source fired when packets coming into the "top" of the device
* are dropped at the MAC layer during reception.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_ssRxDropTrace;
};
} // namespace ns3
#endif /* WIMAX_SS_NET_DEVICE_H */
| zy901002-gpsr | src/wimax/model/ss-net-device.h | C++ | gpl2 | 13,976 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef WIMAX_NET_DEVICE_H
#define WIMAX_NET_DEVICE_H
#include "ns3/net-device.h"
#include "ns3/event-id.h"
#include "ns3/mac48-address.h"
#include "cid.h"
#include "wimax-connection.h"
#include "cid-factory.h"
#include "mac-messages.h"
#include "dl-mac-messages.h"
#include "ul-mac-messages.h"
#include "ns3/traced-callback.h"
#include "ns3/nstime.h"
#include "ns3/log.h"
#include "wimax-phy.h"
#include "wimax-mac-header.h"
namespace ns3 {
class Node;
class Packet;
class TraceContext;
class TraceResolver;
class Channel;
class WimaxChannel;
class PacketBurst;
class BurstProfileManager;
class ConnectionManager;
class ServiceFlowManager;
class BandwidthManager;
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.
* \ingroup wimax
*
* This class holds together ns3::WimaxPhy, ns3::WimaxConnection,
* ns3::ConectionManager, ns3::BurstProfileManager, and
* ns3::BandwidthManager.
*/
class WimaxNetDevice : public NetDevice
{
public:
enum Direction
{
DIRECTION_DOWNLINK, DIRECTION_UPLINK
};
enum RangingStatus
{
RANGING_STATUS_EXPIRED, RANGING_STATUS_CONTINUE, RANGING_STATUS_ABORT, RANGING_STATUS_SUCCESS
};
static TypeId GetTypeId (void);
WimaxNetDevice (void);
virtual ~WimaxNetDevice (void);
/**
* \param ttg transmit/receive transition gap
*/
void SetTtg (uint16_t ttg);
/**
* \returns transmit/receive transition gap
*/
uint16_t GetTtg (void) const;
/**
* \param rtg receive/transmit transition gap
*/
void SetRtg (uint16_t rtg);
/**
* \returns receive/transmit transition gap
*/
uint16_t GetRtg (void) const;
void Attach (Ptr<WimaxChannel> channel);
/**
* \param phy the phy layer to use.
*/
void SetPhy (Ptr<WimaxPhy> phy);
/**
* \returns a pointer to the physical layer.
*/
Ptr<WimaxPhy> GetPhy (void) const;
/**
* \param wimaxChannel the channel to be used
*/
void SetChannel (Ptr<WimaxChannel> wimaxChannel);
uint64_t GetChannel (uint8_t index) const;
void SetNrFrames (uint32_t nrFrames);
uint32_t GetNrFrames (void) const;
/**
* \param address the mac address of the net device
*/
void SetMacAddress (Mac48Address address);
/**
* \returns the mac address of the net device
*/
Mac48Address GetMacAddress (void) const;
void SetState (uint8_t state);
uint8_t GetState (void) const;
/**
* \returns the initial ranging connection
*/
Ptr<WimaxConnection> GetInitialRangingConnection (void) const;
/**
* \returns the broadcast connection
*/
Ptr<WimaxConnection> GetBroadcastConnection (void) const;
void SetCurrentDcd (Dcd dcd);
Dcd GetCurrentDcd (void) const;
void SetCurrentUcd (Ucd ucd);
Ucd GetCurrentUcd (void) const;
/**
* \returns the connection manager of the device
*/
Ptr<ConnectionManager> GetConnectionManager (void) const;
/**
* \param connectionManager the commection manager to be installed in the device
*/
virtual void SetConnectionManager (Ptr<ConnectionManager> connectionManager );
/**
* \returns the burst profile manager currently installed in the device
*/
Ptr<BurstProfileManager> GetBurstProfileManager (void) const;
/**
* \param burstProfileManager the burst profile manager to be installed on the device
*/
void SetBurstProfileManager (Ptr<BurstProfileManager> burstProfileManager);
/**
* \returns the bandwidth manager installed on the device
*/
Ptr<BandwidthManager> GetBandwidthManager (void) const;
/**
* \param bandwidthManager the bandwidth manager to be installed on the device
*/
void SetBandwidthManager (Ptr<BandwidthManager> bandwidthManager);
/*
* \brief Creates the initial ranging and broadcast connections
*/
void CreateDefaultConnections (void);
virtual void Start (void) = 0;
virtual void Stop (void) = 0;
void SetReceiveCallback (void);
void ForwardUp (Ptr<Packet> packet, const Mac48Address &source, const Mac48Address &dest);
virtual bool Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType, Ptr<WimaxConnection> connection) = 0;
void ForwardDown (Ptr<PacketBurst> burst, WimaxPhy::ModulationType modulationType);
// temp, shall be private
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
virtual void SetName (const std::string name);
virtual std::string GetName (void) const;
virtual void SetIfIndex (const uint32_t index);
virtual uint32_t GetIfIndex (void) const;
virtual Ptr<Channel> GetPhyChannel (void) const;
virtual Ptr<Channel> GetChannel (void) const;
virtual void SetAddress (Address address);
virtual Address GetAddress (void) const;
virtual bool SetMtu (const uint16_t mtu);
virtual uint16_t GetMtu (void) const;
virtual bool IsLinkUp (void) const;
virtual void SetLinkChangeCallback (Callback<void> callback);
virtual bool IsBroadcast (void) const;
virtual Address GetBroadcast (void) const;
virtual bool IsMulticast (void) const;
virtual Address GetMulticast (void) const;
virtual Address MakeMulticastAddress (Ipv4Address multicastGroup) const;
virtual bool IsPointToPoint (void) const;
virtual bool Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);
virtual void SetNode (Ptr<Node> node);
virtual Ptr<Node> GetNode (void) const;
virtual bool NeedsArp (void) const;
virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb);
virtual void AddLinkChangeCallback (Callback<void> callback);
virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);
virtual void SetPromiscReceiveCallback (PromiscReceiveCallback cb);
NetDevice::PromiscReceiveCallback GetPromiscReceiveCallback (void);
virtual bool SupportsSendFrom (void) const;
TracedCallback<Ptr<const Packet>, const Mac48Address&> m_traceRx;
TracedCallback<Ptr<const Packet>, const Mac48Address&> m_traceTx;
virtual void DoDispose (void);
virtual Address GetMulticast (Ipv6Address addr) const;
virtual Address GetMulticast (Ipv4Address multicastGroup) const;
virtual bool IsBridge (void) const;
bool IsPromisc (void);
void NotifyPromiscTrace (Ptr<Packet> p);
private:
WimaxNetDevice (const WimaxNetDevice &);
WimaxNetDevice & operator= (const WimaxNetDevice &);
static const uint16_t MAX_MSDU_SIZE = 1500;
// recommended by wimax forum.
static const uint16_t DEFAULT_MSDU_SIZE = 1400;
virtual bool DoSend (Ptr<Packet> packet,
const Mac48Address& source,
const Mac48Address& dest,
uint16_t protocolNumber) = 0;
virtual void DoReceive (Ptr<Packet> packet) = 0;
virtual Ptr<WimaxChannel> DoGetChannel (void) const;
void Receive (Ptr<const PacketBurst> burst);
void InitializeChannels (void);
Ptr<Node> m_node;
Ptr<WimaxPhy> m_phy;
NetDevice::ReceiveCallback m_forwardUp;
NetDevice::PromiscReceiveCallback m_promiscRx;
uint32_t m_ifIndex;
std::string m_name;
bool m_linkUp;
Callback<void> m_linkChange;
mutable uint16_t m_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;
// not sure if it shall be included here
std::vector<uint64_t> m_dlChannels;
Mac48Address m_address;
uint8_t m_state;
uint32_t m_symbolIndex;
// length of TTG and RTG, in units of PSs
uint16_t m_ttg;
uint16_t m_rtg;
Dcd m_currentDcd;
Ucd m_currentUcd;
Ptr<WimaxConnection> m_initialRangingConnection;
Ptr<WimaxConnection> m_broadcastConnection;
Ptr<ConnectionManager> m_connectionManager;
Ptr<BurstProfileManager> m_burstProfileManager;
Ptr<BandwidthManager> m_bandwidthManager;
Ptr<Object> m_mobility;
};
} // namespace ns3
#endif /* WIMAX_NET_DEVICE_H */
| zy901002-gpsr | src/wimax/model/wimax-net-device.h | C++ | gpl2 | 9,033 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef SNR_TO_BLOCK_ERROR_RATE_MANAGER_H
#define SNR_TO_BLOCK_ERROR_RATE_MANAGER_H
#include "ns3/snr-to-block-error-rate-record.h"
#include <vector>
#include "ns3/ptr.h"
namespace ns3 {
/**
* \ingroup wimax
* \brief This class handles the SNR to BlcER traces. A path to a repository containing trace files should be provided.
* If no repository is provided the traces form default-traces.h will be loaded.
* A valid repository should contain 7 files, one for each modulation and coding scheme.
* The names of the files should respect the following format: modulation0.txt for modulation 0, modulation1.txt for
* modulation 1 and so on...
* The files format should be as follows
* SNR_value(1) BER(1) Blc_ER(1) STANDARD_DEVIATION(1) CONFIDENCE_INTERVAL1(1) CONFIDENCE_INTERVAL2(1)
* SNR_value(2) BER(2) Blc_ER(2) STANDARD_DEVIATION(2) CONFIDENCE_INTERVAL1(2) CONFIDENCE_INTERVAL2(2)
* ... ... ... ... ... ...
* ... ... ... ... ... ...
* SNR_value(n) BER(n) Blc_ER(n) STANDARD_DEVIATION(n) CONFIDENCE_INTERVAL1(n) CONFIDENCE_INTERVAL2(n)
*/
class SNRToBlockErrorRateManager
{
public:
SNRToBlockErrorRateManager ();
~SNRToBlockErrorRateManager (void);
/**
* \brief Set the path of the repository containing the traces
* \param traceFilePath the path to the repository.
*/
void SetTraceFilePath (char *traceFilePath);
/**
* \return the path to the repository containing the traces.
*/
std::string GetTraceFilePath (void);
/**
* \brief returns the Block Error Rate for a given modulation and SNR value
* \param SNR the SNR value
* \param modulation one of the seven MCS
* \return the Block Error Rate
*/
double GetBlockErrorRate (double SNR, uint8_t modulation);
SNRToBlockErrorRateRecord *
/**
* \brief returns a record of type SNRToBlockErrorRateRecord corresponding to a given modulation and SNR value
* \param SNR the SNR value
* \param modulation one of the seven MCS
* \return the Block Error Rate
*/
GetSNRToBlockErrorRateRecord (double SNR, uint8_t modulation);
/**
* \brief Loads the traces form the repository specified in the constructor or setted by SetTraceFilePath function. If
* no repository is provided, default traces will be loaded from default-traces.h file
*/
void LoadTraces (void);
/**
* \brief Loads the default traces from default-traces.h file
*/
void LoadDefaultTraces (void);
/**
* \brief Reloads the trace
*/
void ReLoadTraces (void);
/**
* \brief If activate loss is called with false, all the returned BlcER will be 0 (no losses)
*/
void ActivateLoss (bool loss);
private:
void ClearRecords (void);
double m_speed; // in m/s
uint8_t m_activateLoss;
char m_traceFilePath[1024];
std::vector<SNRToBlockErrorRateRecord *> * m_recordModulation[7];
};
}
#endif /* SNR_TO_BLOCK_ERROR_RATE_MANAGER_H */
| zy901002-gpsr | src/wimax/model/snr-to-block-error-rate-manager.h | C++ | gpl2 | 3,944 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef SIMPLE_OFDM_SEND_PARAM_H
#define SIMPLE_OFDM_SEND_PARAM_H
#include <list>
#include "wimax-channel.h"
#include "bvec.h"
#include "wimax-phy.h"
#include "ns3/propagation-loss-model.h"
namespace ns3 {
/**
* \ingroup wimax
*/
class simpleOfdmSendParam
{
public:
simpleOfdmSendParam (void);
simpleOfdmSendParam (const bvec &fecBlock, uint32_t burstSize,
bool isFirstBlock, uint64_t Frequency,
WimaxPhy::ModulationType modulationType, uint8_t direction,
double rxPowerDbm);
simpleOfdmSendParam (uint32_t burstSize,
bool isFirstBlock, uint64_t Frequency,
WimaxPhy::ModulationType modulationType, uint8_t direction,
double rxPowerDbm, Ptr<PacketBurst> burst);
~simpleOfdmSendParam (void);
/**
* \brief sent the fec block to send
* \param fecBlock the fec block to send
*/
void SetFecBlock (const bvec &fecBlock);
/**
* \brief set the burst size
* \param burstSize the burst size in bytes
*/
void SetBurstSize (uint32_t burstSize);
/**
* \param isFirstBlock Set to true if this fec block is the first one in the burst, set to false otherwise
*/
void SetIsFirstBlock (bool isFirstBlock);
/**
* \param Frequency set the frequency of the channel in wich this fec block will be sent
*/
void SetFrequency (uint64_t Frequency);
/**
* \param modulationType the modulation type used to send this fec block
*/
void SetModulationType (WimaxPhy::ModulationType modulationType);
/**
* \param direction the direction on which this fec block will be sent
*/
void SetDirection (uint8_t direction);
/**
* \param rxPowerDbm the received power
*/
void SetRxPowerDbm (double rxPowerDbm);
/**
* \return the fec block
*/
bvec GetFecBlock (void);
/**
* \return the burst size
*/
uint32_t GetBurstSize (void);
/**
* \return true if this fec block is the first one in the burst, false otherwise
*/
bool GetIsFirstBlock (void);
/**
* \return the frequency on which the fec block is sent/received
*/
uint64_t GetFrequency (void);
/**
* \return the modulation type used to send this fec block
*/
WimaxPhy::ModulationType GetModulationType (void);
/**
* \return the direction on which this fec block was sent. UP or DOWN
*/
uint8_t GetDirection (void);
/**
* \return the Received power
*/
double GetRxPowerDbm (void);
/**
* \return the received burst
*/
Ptr<PacketBurst> 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<PacketBurst> m_burst;
};
} // namespace ns3
#endif /* SIMPLE_OFDM_SEND_PARAM_H */
| zy901002-gpsr | src/wimax/model/simple-ofdm-send-param.h | C++ | gpl2 | 3,744 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "wimax-mac-header.h"
#include "crc8.h"
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (MacHeaderType);
MacHeaderType::MacHeaderType (void)
: m_type (0)
{
}
MacHeaderType::MacHeaderType (uint8_t type)
: m_type (type)
{
}
MacHeaderType::~MacHeaderType (void)
{
}
void
MacHeaderType::SetType (uint8_t type)
{
m_type = type;
}
uint8_t
MacHeaderType::GetType (void) const
{
return m_type;
}
std::string
MacHeaderType::GetName (void) const
{
return "MAC Header Type";
}
TypeId
MacHeaderType::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::MacHeaderType").SetParent<Header> ().AddConstructor<MacHeaderType> ();
return tid;
}
TypeId MacHeaderType::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void MacHeaderType::Print (std::ostream &os) const
{
os << " header type = " << (uint32_t) m_type;
}
uint32_t MacHeaderType::GetSerializedSize (void) const
{
return 0;
}
void MacHeaderType::Serialize (Buffer::Iterator start) const
{
}
uint32_t MacHeaderType::Deserialize (Buffer::Iterator start)
{
return 0;
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (GenericMacHeader);
GenericMacHeader::GenericMacHeader (void)
: m_ht (0),
m_ec (0),
m_type (0),
m_ci (0),
m_eks (0),
m_len (0),
m_cid (Cid ())
{
m_esf = 0;
m_hcs = 0;
m_rsv1 = 0;
c_hcs = 0;
}
GenericMacHeader::~GenericMacHeader (void)
{
}
void GenericMacHeader::SetHt (uint8_t ht)
{
m_ht = ht;
}
void GenericMacHeader::SetEc (uint8_t ec)
{
m_ec = ec;
}
void GenericMacHeader::SetType (uint8_t type)
{
m_type = type;
}
void GenericMacHeader::SetCi (uint8_t ci)
{
m_ci = ci;
}
void GenericMacHeader::SetEks (uint8_t eks)
{
m_eks = eks;
}
void GenericMacHeader::SetLen (uint16_t len)
{
m_len = len;
}
void GenericMacHeader::SetCid (Cid cid)
{
m_cid = cid;
}
void GenericMacHeader::SetHcs (uint8_t hcs)
{
m_hcs = hcs;
}
uint8_t GenericMacHeader::GetHt (void) const
{
return m_ht;
}
uint8_t GenericMacHeader::GetEc (void) const
{
return m_ec;
}
uint8_t GenericMacHeader::GetType (void) const
{
return m_type;
}
uint8_t GenericMacHeader::GetCi (void) const
{
return m_ci;
}
uint8_t GenericMacHeader::GetEks (void) const
{
return m_eks;
}
uint16_t GenericMacHeader::GetLen (void) const
{
return m_len;
}
Cid GenericMacHeader::GetCid (void) const
{
return m_cid;
}
uint8_t GenericMacHeader::GetHcs (void) const
{
return m_hcs;
}
std::string GenericMacHeader::GetName (void) const
{
return "Generic Mac Header";
}
TypeId GenericMacHeader::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::GenericMacHeader").SetParent<Header> ().AddConstructor<GenericMacHeader> ();
return tid;
}
TypeId GenericMacHeader::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void GenericMacHeader::Print (std::ostream &os) const
{
os << " ec (encryption control) = " << (uint32_t) m_ec << ", type = " << (uint32_t) m_type
<< ", ci (crc indicator) = " << (uint32_t) m_ci << ", eks (encryption key sequence) = " << (uint32_t) m_eks
<< ", len (length) = " << m_len << ", cid = " << m_cid << ", hcs (header check sequence) = " << (uint32_t) m_hcs;
}
uint32_t GenericMacHeader::GetSerializedSize (void) const
{
return 6;
}
void GenericMacHeader::Serialize (Buffer::Iterator start) const
{
/*
* AI:Serialize function according to the
* IEEE 8002.16e.
* Please send bug and comments to
* amine.ismail@udcast.com
* amine.ismail@sophia.inria.fr
*/
Buffer::Iterator i = start;
uint8_t headerBuffer[6];
memset (headerBuffer, 0, 6);
headerBuffer[0] = ((m_ht << 7) & 0x80) | ((m_ec << 6) & 0x40) | (m_type & 0x3F);
headerBuffer[1] = ((m_esf << 7) & 0x80) | ((m_ci << 6) & 0x40) | ((m_eks << 4) & 0x30) | ((m_rsv1 << 3) & 0x08)
| (((uint8_t)(m_len >> 8)) & 0x07);
headerBuffer[2] = (uint8_t)(m_len);
headerBuffer[3] = (uint8_t)(m_cid.GetIdentifier () >> 8);
headerBuffer[4] = (uint8_t)(m_cid.GetIdentifier ());
uint8_t crc = CRC8Calculate (headerBuffer, 5);
headerBuffer[5] = crc;
for (int j = 0; j < 6; j++)
{
i.WriteU8 (headerBuffer[j]);
}
}
uint32_t GenericMacHeader::Deserialize (Buffer::Iterator start)
{
/*
* AI:Deserialize function according to the
* IEEE 8002.16e.
* Please send bug and comments to
* amine.ismail@udcast.com
* amine.ismail@sophia.inria.fr
*/
Buffer::Iterator i = start;
uint8_t headerBuffer[6];
for (int j = 0; j < 6; j++)
{
headerBuffer[j] = i.ReadU8 ();
}
m_ht = (headerBuffer[0] >> 7) & 0x01;
m_ec = (headerBuffer[0] >> 6) & 0x01;
m_type = (headerBuffer[0]) & 0x3F;
m_esf = (headerBuffer[1] >> 7) & 0x01;
m_ci = (headerBuffer[1] >> 6) & 0x01;
m_eks = (headerBuffer[1] >> 4) & 0x03;
m_rsv1 = (headerBuffer[1] >> 3) & 0x01;
uint16_t lenmsb = (headerBuffer[1] & 0x07);
uint16_t lenlsb = headerBuffer[2];
m_len = ((lenmsb << 8) & 0x0700) | (lenlsb & 0x00FF);
uint16_t cidmsb = headerBuffer[3];
uint16_t cidlsb = headerBuffer[4];
uint16_t cid = ((cidmsb << 8) & 0xFF00) | (cidlsb & 0x00FF);
m_cid = Cid (cid);
m_hcs = headerBuffer[5];
c_hcs = CRC8Calculate (headerBuffer, 5);
return i.GetDistanceFrom (start);
}
bool GenericMacHeader::check_hcs (void) const
{
return (m_hcs == c_hcs);
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (BandwidthRequestHeader);
BandwidthRequestHeader::BandwidthRequestHeader (void)
: m_ht (1),
m_ec (0),
m_type (0),
m_br (0),
m_cid (Cid ()),
m_hcs (0)
{
}
BandwidthRequestHeader::~BandwidthRequestHeader (void)
{
}
void BandwidthRequestHeader::SetHt (uint8_t ht)
{
m_ht = ht;
}
void BandwidthRequestHeader::SetEc (uint8_t ec)
{
m_ec = ec;
}
void BandwidthRequestHeader::SetType (uint8_t type)
{
m_type = type;
}
void BandwidthRequestHeader::SetBr (uint32_t br)
{
m_br = br;
}
void BandwidthRequestHeader::SetCid (Cid cid)
{
m_cid = cid;
}
void BandwidthRequestHeader::SetHcs (uint8_t hcs)
{
m_hcs = hcs;
}
uint8_t BandwidthRequestHeader::GetHt (void) const
{
return m_ht;
}
uint8_t BandwidthRequestHeader::GetEc (void) const
{
return m_ec;
}
uint8_t BandwidthRequestHeader::GetType (void) const
{
return m_type;
}
uint32_t BandwidthRequestHeader::GetBr (void) const
{
return m_br;
}
Cid BandwidthRequestHeader::GetCid (void) const
{
return m_cid;
}
uint8_t BandwidthRequestHeader::GetHcs (void) const
{
return m_hcs;
}
std::string BandwidthRequestHeader::GetName (void) const
{
return "Bandwidth Request Header";
}
TypeId BandwidthRequestHeader::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BandwidthRequestHeader").SetParent<Header> ().AddConstructor<
BandwidthRequestHeader> ();
return tid;
}
TypeId BandwidthRequestHeader::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void BandwidthRequestHeader::Print (std::ostream &os) const
{
os << " ec (encryption control) = " << (uint32_t) m_ec << ", type = " << (uint32_t) m_type
<< ", br (bandwidth request) = " << m_br << ", cid = ";
m_cid.GetIdentifier ();
os << ", hcs (header check sequence) = " << (uint32_t) m_hcs;
}
uint32_t BandwidthRequestHeader::GetSerializedSize (void) const
{
/*
* The size of the BandwidthRequest mac header is always 6 bytes
*/
return 6;
}
void BandwidthRequestHeader::Serialize (Buffer::Iterator start) const
{
/*
* AI:Serialize function according to the
* IEEE 8002.16e.
* please send bug and comments to
* amine.ismail@udcast.com
* amine.ismail@sophia.inria.fr
*/
Buffer::Iterator i = start;
uint8_t headerBuffer[6];
uint8_t br_msb1 = (((uint32_t) m_br) >> 16) & 0x00000007;
uint8_t br_msb2 = (((uint32_t) m_br) >> 8) & 0x000000FF;
uint8_t br_lsb = m_br & 0x000000FF;
headerBuffer[0] = ((m_ht << 7) & 0x80) | ((m_ec << 6) & 0x40) | ((m_type << 3) & 0x38) | br_msb1;
headerBuffer[1] = br_msb2;
headerBuffer[2] = br_lsb;
headerBuffer[3] = (uint8_t)((m_cid.GetIdentifier () >> 8) & 0x00FF);
headerBuffer[4] = (uint8_t)(m_cid.GetIdentifier () & 0x00FF);
headerBuffer[5] = CRC8Calculate (headerBuffer, 5);
for (int j = 0; j < 6; j++)
{
i.WriteU8 (headerBuffer[j]);
}
}
uint32_t BandwidthRequestHeader::Deserialize (Buffer::Iterator start)
{
/*
* AI:Deserialize function according to the
* IEEE 8002.16e.
* Please send bug and comments to
* amine.ismail@udcast.com
* amine.ismail@sophia.inria.fr
*/
Buffer::Iterator i = start;
uint8_t headerBuffer[6];
for (int j = 0; j < 6; j++)
{
headerBuffer[j] = i.ReadU8 ();
}
m_ht = (headerBuffer[0] >> 7) & 0x01;
m_ec = (headerBuffer[0] >> 6) & 0x01;
m_type = (headerBuffer[0] >> 3) & 0x07;
uint32_t br_msb1 = headerBuffer[0] & 0x00000007;
uint32_t br_msb2 = headerBuffer[1] & 0x000000FF;
uint32_t br_lsb = headerBuffer[2] & 0x000000FF;
m_br = ((uint32_t) br_msb1 << 14) | ((uint32_t) br_msb2 << 8) | br_lsb;
uint16_t cidmsb = headerBuffer[3];
uint16_t cidlsb = headerBuffer[4];
uint16_t cid = ((cidmsb << 8) & 0xFF00) | (cidlsb & 0x00FF);
m_cid = Cid (cid);
m_hcs = headerBuffer[5];
c_hcs = CRC8Calculate (headerBuffer, 5);
return i.GetDistanceFrom (start);
}
bool BandwidthRequestHeader::check_hcs (void) const
{
return (m_hcs == c_hcs);
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (GrantManagementSubheader);
GrantManagementSubheader::GrantManagementSubheader (void)
: m_si (0),
m_pm (0),
m_pbr (0)
{
}
GrantManagementSubheader::~GrantManagementSubheader (void)
{
}
void GrantManagementSubheader::SetSi (uint8_t si)
{
m_si = si;
}
void GrantManagementSubheader::SetPm (uint8_t pm)
{
m_pm = pm;
}
void GrantManagementSubheader::SetPbr (uint16_t pbr)
{
m_pbr = pbr;
}
uint8_t GrantManagementSubheader::GetSi (void) const
{
return m_si;
}
uint8_t GrantManagementSubheader::GetPm (void) const
{
return m_pm;
}
uint16_t GrantManagementSubheader::GetPbr (void) const
{
return m_pbr;
}
std::string GrantManagementSubheader::GetName (void) const
{
return "Grant Management Subheader";
}
TypeId GrantManagementSubheader::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::GrantManagementSubheader").SetParent<Header> ().AddConstructor<
GrantManagementSubheader> ();
return tid;
}
TypeId GrantManagementSubheader::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void GrantManagementSubheader::Print (std::ostream &os) const
{
os << " si (slip indicator) = " << (uint32_t) m_si << ", pm (poll me) = " << (uint32_t) m_pm
<< ", pbr (piggyback request) = " << m_pbr;
}
uint32_t GrantManagementSubheader::GetSerializedSize (void) const
{
return 1 + 1 + 2;
}
void GrantManagementSubheader::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_si);
i.WriteU8 (m_pm);
i.WriteU16 (m_pbr);
}
uint32_t GrantManagementSubheader::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_si = i.ReadU8 ();
m_pm = i.ReadU8 ();
m_pbr = i.ReadU16 ();
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (FragmentationSubheader);
FragmentationSubheader::FragmentationSubheader (void)
: m_fc (0),
m_fsn (0)
{
}
FragmentationSubheader::~FragmentationSubheader (void)
{
}
void
FragmentationSubheader::SetFc (uint8_t fc)
{
m_fc = fc;
}
void
FragmentationSubheader::SetFsn (uint8_t fsn)
{
m_fsn = fsn;
}
uint8_t
FragmentationSubheader::GetFc (void) const
{
return m_fc;
}
uint8_t
FragmentationSubheader::GetFsn (void) const
{
return m_fsn;
}
std::string
FragmentationSubheader::GetName (void) const
{
return "Fragmentation Subheader";
}
TypeId
FragmentationSubheader::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::FragmentationSubheader").SetParent<
Header> ().AddConstructor<FragmentationSubheader> ();
return tid;
}
TypeId
FragmentationSubheader::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
FragmentationSubheader::Print (std::ostream &os) const
{
os << " fc (fragment control) = " << (uint32_t) m_fc << ", fsn (fragmentation sequence number) = "
<< (uint32_t) m_fsn << "\n";
}
uint32_t
FragmentationSubheader::GetSerializedSize (void) const
{
return 2;
}
void
FragmentationSubheader::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_fc);
i.WriteU8 (m_fsn);
}
uint32_t
FragmentationSubheader::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_fc = i.ReadU8 ();
m_fsn = i.ReadU8 ();
return i.GetDistanceFrom (start);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-mac-header.cc | C++ | gpl2 | 13,803 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef LINK_MANAGER_H
#define LINK_MANAGER_H
#include <stdint.h>
#include "wimax-net-device.h"
#include "bs-net-device.h"
#include "ns3/event-id.h"
#include "cid.h"
#include "mac-messages.h"
namespace ns3 {
/**
* \ingroup wimax
*/
class BSLinkManager : public Object
{
public:
static TypeId GetTypeId (void);
BSLinkManager (Ptr<BaseStationNetDevice> bs);
~BSLinkManager (void);
/**
* \return the ranging opportunities to allocate
*/
uint8_t CalculateRangingOppsToAllocate (void);
/**
* \return an available downlink channel
*/
uint64_t SelectDlChannel (void);
/**
* \brief process a ranging request message
* \param cid the connection identifier in which the ranging message was received
* \param rngreq the ranging request message
*/
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
*/
void VerifyInvitedRanging (Cid cid, uint8_t uiuc);
private:
BSLinkManager (const BSLinkManager &);
BSLinkManager & operator= (const BSLinkManager &);
void PerformRanging (Cid cid, RngReq rngreq);
void PerformInitialRanging (Cid cid, RngReq *rngreq, RngRsp *rngrsp);
void PerformInvitedRanging (Cid cid, RngRsp *rngrsp);
void SetParametersToAdjust (RngRsp *rngrsp);
void AbortRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord, bool isNewSS);
void AcceptRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord);
void ContinueRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord);
void ScheduleRngRspMessage (Cid cid, RngRsp *rngrsp);
void DeallocateCids (Cid cid);
bool ChangeDlChannel (void);
uint32_t GetNewDlChannel (void);
uint8_t GetSignalQuality (void);
bool IsRangingAcceptable (void);
Ptr<BaseStationNetDevice> m_bs;
// 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
};
} // namespace ns3
#endif /* LINK_MANAGER_H */
| zy901002-gpsr | src/wimax/model/bs-link-manager.h | C++ | gpl2 | 3,019 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef UCD_CHANNEL_ENCODINGS_H
#define UCD_CHANNEL_ENCODINGS_H
#include <stdint.h>
#include "ns3/buffer.h"
#include <list>
namespace ns3 {
/**
* \ingroup wimax
* \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
*
*/
class UcdChannelEncodings
{
public:
UcdChannelEncodings (void);
virtual ~UcdChannelEncodings (void);
void SetBwReqOppSize (uint16_t bwReqOppSize);
void SetRangReqOppSize (uint16_t rangReqOppSize);
void SetFrequency (uint32_t frequency);
uint16_t GetBwReqOppSize (void) const;
uint16_t GetRangReqOppSize (void) const;
uint32_t GetFrequency (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
Buffer::Iterator Read (Buffer::Iterator start);
private:
virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const = 0;
virtual Buffer::Iterator DoRead (Buffer::Iterator start) = 0;
uint16_t m_bwReqOppSize;
uint16_t m_rangReqOppSize;
uint32_t m_frequency;
};
} // namespace ns3
#endif /* UCD_CHANNEL_ENCODINGS_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_UCD_CHANNEL_ENCODINGS_H
#define OFDM_UCD_CHANNEL_ENCODINGS_H
#include <stdint.h>
namespace ns3 {
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);
void SetSbchnlReqRegionFullParams (uint8_t sbchnlReqRegionFullParams);
void SetSbchnlFocContCodes (uint8_t sbchnlFocContCodes);
uint8_t GetSbchnlReqRegionFullParams (void) const;
uint8_t GetSbchnlFocContCodes (void) const;
uint16_t GetSize (void) const;
private:
virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const;
virtual Buffer::Iterator DoRead (Buffer::Iterator start);
uint8_t m_sbchnlReqRegionFullParams;
uint8_t m_sbchnlFocContCodes;
};
} // namespace ns3
#endif /* OFDM_UCD_CHANNEL_ENCODINGS_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_UL_BURST_PROFILE_H
#define OFDM_UL_BURST_PROFILE_H
#include <stdint.h>
#include "ns3/buffer.h"
namespace ns3 {
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:
enum Uiuc
{
UIUC_INITIAL_RANGING = 1,
UIUC_REQ_REGION_FULL,
UIUC_REQ_REGION_FOCUSED,
UIUC_FOCUSED_CONTENTION_IE,
UIUC_BURST_PROFILE_5,
UIUC_BURST_PROFILE_6,
UIUC_BURST_PROFILE_7,
UIUC_BURST_PROFILE_8,
UIUC_BURST_PROFILE_9,
UIUC_BURST_PROFILE_10,
UIUC_BURST_PROFILE_11,
UIUC_BURST_PROFILE_12,
UIUC_SUBCH_NETWORK_ENTRY,
UIUC_END_OF_MAP
};
OfdmUlBurstProfile (void);
~OfdmUlBurstProfile (void);
void SetType (uint8_t type);
void SetLength (uint8_t length);
void SetUiuc (uint8_t uiuc);
void SetFecCodeType (uint8_t fecCodeType);
uint8_t GetType (void) const;
uint8_t GetLength (void) const;
uint8_t GetUiuc (void) const;
uint8_t GetFecCodeType (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
Buffer::Iterator Read (Buffer::Iterator start);
private:
uint8_t m_type;
uint8_t m_length;
uint8_t m_uiuc;
// TLV Encoded information
uint8_t m_fecCodeType;
};
} // namespace ns3
#endif /* OFDM_UL_BURST_PROFILE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef UCD_H
#define UCD_H
#include <stdint.h>
#include "ns3/header.h"
#include <vector>
namespace ns3 {
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);
void SetConfigurationChangeCount (uint8_t ucdCount);
void SetRangingBackoffStart (uint8_t rangingBackoffStart);
void SetRangingBackoffEnd (uint8_t rangingBackoffEnd);
void SetRequestBackoffStart (uint8_t requestBackoffStart);
void SetRequestBackoffEnd (uint8_t requestBackoffEnd);
void SetChannelEncodings (OfdmUcdChannelEncodings channelEncodings);
void AddUlBurstProfile (OfdmUlBurstProfile ulBurstProfile);
void SetNrUlBurstProfiles (uint8_t nrUlBurstProfiles);
uint8_t GetConfigurationChangeCount (void) const;
uint8_t GetRangingBackoffStart (void) const;
uint8_t GetRangingBackoffEnd (void) const;
uint8_t GetRequestBackoffStart (void) const;
uint8_t GetRequestBackoffEnd (void) const;
OfdmUcdChannelEncodings GetChannelEncodings (void) const;
std::vector<OfdmUlBurstProfile> GetUlBurstProfiles (void) const;
uint8_t GetNrUlBurstProfiles (void) const;
std::string GetName (void) const;
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);
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<OfdmUlBurstProfile> m_ulBurstProfiles;
uint8_t m_nrUlBurstProfiles;
};
} // namespace ns3
#endif /* UCD_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_UL_MAP_IE_H
#define OFDM_UL_MAP_IE_H
#include <stdint.h>
#include "ns3/header.h"
#include "cid.h"
namespace ns3 {
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);
void SetCid (Cid cid);
void SetStartTime (uint16_t startTime);
void SetSubchannelIndex (uint8_t subchannelIndex);
void SetUiuc (uint8_t uiuc);
void SetDuration (uint16_t duration);
void SetMidambleRepetitionInterval (uint8_t midambleRepetitionInterval);
Cid GetCid (void) const;
uint16_t GetStartTime (void) const;
uint8_t GetSubchannelIndex (void) const;
uint8_t GetUiuc (void) const;
uint16_t GetDuration (void) const;
uint8_t GetMidambleRepetitionInterval (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
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;
// fields to be implemented later on:
// m_focusedContentionIe()
// m_subchannelizedNetworkEntryIe()
// m_ulExtendedIe()
// m_paddingNibble;
};
} // namespace ns3
#endif /* OFDM_UL_MAP_IE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef UL_MAP_H
#define UL_MAP_H
#include <stdint.h>
#include "ns3/header.h"
#include <vector>
namespace ns3 {
class UlMap : public Header
{
/**
* \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"
* 8.2.1.8.2 Compressed UL-MAP, page 404
*
*/
public:
UlMap (void);
virtual ~UlMap (void);
void SetUcdCount (uint8_t ucdCount);
void SetAllocationStartTime (uint32_t allocationStartTime);
void AddUlMapElement (OfdmUlMapIe ulMapElement);
uint8_t GetUcdCount (void) const;
uint32_t GetAllocationStartTime (void) const;
std::list<OfdmUlMapIe> GetUlMapElements (void) const;
std::string GetName (void) const;
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);
private:
uint8_t m_reserved; // changed as per the amendment 802.16e-2005
uint8_t m_ucdCount;
uint32_t m_allocationStartTime;
std::list<OfdmUlMapIe> m_ulMapElements;
};
} // namespace ns3
#endif /* UL_MAP_H */
| zy901002-gpsr | src/wimax/model/ul-mac-messages.h | C++ | gpl2 | 10,073 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef SERVICE_FLOW_H
#define SERVICE_FLOW_H
#include <stdint.h>
#include "wimax-phy.h"
#include "wimax-connection.h"
#include "cs-parameters.h"
namespace ns3 {
class ServiceFlowRecord;
class WimaxConnection;
/**
* \ingroup wimax
* This class implements service flows as described by the IEEE-802.16 standard
*/
class ServiceFlow
{
public:
enum Direction
{
SF_DIRECTION_DOWN, SF_DIRECTION_UP
};
enum Type
{
SF_TYPE_PROVISIONED, SF_TYPE_ADMITTED, SF_TYPE_ACTIVE
};
// 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
};
// 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,
IPV6_OVER_VLAN = 107
};
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
};
/**
* \brief creates a TLV from this service flow
* \return the created tlv
*
*/
Tlv ToTlv (void) const;
/**
* \brief creates a service flow from a TLV
* \param tlv the tlv from which the service flow will be created
*/
ServiceFlow (Tlv tlv);
/**
* \return true if the passed parameters match the classifier of the service flow, false otherwise
* \param srcAddress the source ip address
* \param dstAddress the destination ip address
* \param srcPort the source port
* \param dstPort the destination port
* \param proto the layer 4 protocol
*/
bool CheckClassifierMatch (Ipv4Address srcAddress,
Ipv4Address dstAddress,
uint16_t srcPort,
uint16_t dstPort,
uint8_t proto) const;
ServiceFlow (enum Direction direction);
ServiceFlow ();
ServiceFlow (const ServiceFlow & sf);
ServiceFlow (uint32_t sfid,
enum Direction direction,
Ptr<WimaxConnection> connection);
~ServiceFlow (void);
ServiceFlow & operator = (ServiceFlow const& o);
void InitValues (void);
void SetDirection (enum Direction direction);
enum Direction GetDirection (void) const;
void CopyParametersFrom (ServiceFlow sf);
void SetType (enum Type type);
enum Type GetType (void) const;
void SetConnection (Ptr<WimaxConnection> connection);
// Can return a null connection is this service flow has not
// been associated yet to a connection.
Ptr<WimaxConnection> GetConnection (void) const;
void SetIsEnabled (bool isEnabled);
bool GetIsEnabled (void) const;
void SetRecord (ServiceFlowRecord *record);
ServiceFlowRecord* GetRecord (void) const;
// wrapper functions
Ptr<WimaxMacQueue> GetQueue (void) const;
enum ServiceFlow::SchedulingType GetSchedulingType (void) const;
bool HasPackets (void) const;
bool HasPackets (MacHeaderType::HeaderType packetType) const;
// shall be called only by BS
void CleanUpQueue (void);
void PrintQoSParameters (void) const;
char* GetSchedulingTypeStr (void) const;
uint32_t GetSfid (void) const;
uint16_t GetCid (void) const;
std::string GetServiceClassName () const;
uint8_t GetQosParamSetType (void) const;
uint8_t GetTrafficPriority (void) const;
uint32_t GetMaxSustainedTrafficRate (void) const;
uint32_t GetMaxTrafficBurst (void) const;
uint32_t GetMinReservedTrafficRate (void) const;
uint32_t GetMinTolerableTrafficRate (void) const;
enum ServiceFlow::SchedulingType GetServiceSchedulingType (void) const;
uint32_t GetRequestTransmissionPolicy (void) const;
uint32_t GetToleratedJitter (void) const;
uint32_t GetMaximumLatency (void) const;
uint8_t GetFixedversusVariableSduIndicator (void) const;
uint8_t GetSduSize (void) const;
uint16_t GetTargetSAID (void) const;
uint8_t GetArqEnable (void) const;
uint16_t GetArqWindowSize (void) const;
uint16_t GetArqRetryTimeoutTx (void) const;
uint16_t GetArqRetryTimeoutRx (void) const;
uint16_t GetArqBlockLifeTime (void) const;
uint16_t GetArqSyncLoss (void) const;
uint8_t GetArqDeliverInOrder (void) const;
uint16_t GetArqPurgeTimeout (void) const;
uint16_t GetArqBlockSize (void) const;
enum CsSpecification GetCsSpecification (void) const;
CsParameters GetConvergenceSublayerParam (void) const;
uint16_t GetUnsolicitedGrantInterval (void) const;
uint16_t GetUnsolicitedPollingInterval (void) const;
bool GetIsMulticast (void) const;
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);
void SetIsMulticast (bool isMulticast);
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<WimaxConnection> m_connection;
bool m_isEnabled;
bool m_isMulticast;
enum WimaxPhy::ModulationType m_modulationType;
// will be used by the BS
ServiceFlowRecord *m_record;
};
} // namespace ns3
#endif /* SERVICE_FLOW_H */
| zy901002-gpsr | src/wimax/model/service-flow.h | C++ | gpl2 | 8,172 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef SS_RECORD_H
#define SS_RECORD_H
#include <stdint.h>
#include <ostream>
#include "ns3/mac48-address.h"
#include "wimax-connection.h"
#include "wimax-phy.h"
#include "wimax-net-device.h"
#include "ns3/ipv4-address.h"
#include <stdint.h>
#include "service-flow.h"
namespace ns3 {
class ServiceFlow;
/**
* \ingroup wimax
* \brief This class is used by the base station to store some information related to subscriber station in the cell.
*/
class SSRecord
{
public:
SSRecord (void);
SSRecord (Mac48Address macAddress);
SSRecord (Mac48Address macAddress, Ipv4Address IPaddress);
~SSRecord (void);
void SetBasicCid (Cid basicCid);
Cid GetBasicCid (void) const;
void SetPrimaryCid (Cid primaryCid);
Cid GetPrimaryCid (void) const;
void SetMacAddress (Mac48Address macAddress);
Mac48Address GetMacAddress (void) const;
uint8_t GetRangingCorrectionRetries (void) const;
void ResetRangingCorrectionRetries (void);
void IncrementRangingCorrectionRetries (void);
uint8_t GetInvitedRangRetries (void) const;
void ResetInvitedRangingRetries (void);
void IncrementInvitedRangingRetries (void);
void SetModulationType (WimaxPhy::ModulationType modulationType);
WimaxPhy::ModulationType GetModulationType (void) const;
void SetRangingStatus (WimaxNetDevice::RangingStatus rangingStatus);
WimaxNetDevice::RangingStatus GetRangingStatus (void) const;
void EnablePollForRanging (void);
void DisablePollForRanging (void);
bool GetPollForRanging (void) const;
bool GetAreServiceFlowsAllocated (void) const;
void SetPollMeBit (bool pollMeBit);
bool GetPollMeBit (void) const;
void AddServiceFlow (ServiceFlow *serviceFlow);
std::vector<ServiceFlow*> GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const;
bool GetHasServiceFlowUgs (void) const;
bool GetHasServiceFlowRtps (void) const;
bool GetHasServiceFlowNrtps (void) const;
bool GetHasServiceFlowBe (void) const;
void SetSfTransactionId (uint16_t sfTransactionId);
uint16_t GetSfTransactionId (void) const;
void SetDsaRspRetries (uint8_t dsaRspRetries);
void IncrementDsaRspRetries (void);
uint8_t GetDsaRspRetries (void) const;
void SetDsaRsp (DsaRsp dsaRsp);
DsaRsp GetDsaRsp (void) const;
void SetIsBroadcastSS (bool);
bool GetIsBroadcastSS (void);
Ipv4Address GetIPAddress (void);
void SetIPAddress (Ipv4Address IPaddress);
void SetAreServiceFlowsAllocated (bool val);
private:
void Initialize (void);
Mac48Address m_macAddress;
Ipv4Address m_IPAddress;
Cid m_basicCid;
Cid m_primaryCid;
uint8_t m_rangingCorrectionRetries;
uint8_t m_invitedRangingRetries;
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;
std::vector<ServiceFlow*> *m_serviceFlows;
// fields for service flow creation
uint16_t m_sfTransactionId;
uint8_t m_dsaRspRetries;
DsaRsp m_dsaRsp;
};
} // namespace ns3
#endif /* SS_RECORD_H */
| zy901002-gpsr | src/wimax/model/ss-record.h | C++ | gpl2 | 4,046 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef BS_SERVICE_FLOW_MANAGER_H
#define BS_SERVICE_FLOW_MANAGER_H
#include <stdint.h>
#include "ns3/event-id.h"
#include "mac-messages.h"
#include "ns3/buffer.h"
#include "service-flow-manager.h"
#include "bs-net-device.h"
namespace ns3 {
class Packet;
class ServiceFlow;
class WimaxNetDevice;
class SSRecord;
class WimaxConnection;
class BaseStationNetDevice;
/**
* \ingroup wimax
*/
class BsServiceFlowManager : public ServiceFlowManager
{
public:
enum ConfirmationCode // as per Table 384 (not all codes implemented)
{
CONFIRMATION_CODE_SUCCESS, CONFIRMATION_CODE_REJECT
};
BsServiceFlowManager (Ptr<BaseStationNetDevice> device);
~BsServiceFlowManager (void);
void DoDispose (void);
/**
* \brief Add a new service flow
* \param serviceFlow the service flow to add
*/
void AddServiceFlow (ServiceFlow *serviceFlow);
/**
* \return the service flow which has as identifier sfid
*/
ServiceFlow* GetServiceFlow (uint32_t sfid) const;
/**
* \return the service flow which has as connection identifier cid
*/
ServiceFlow* GetServiceFlow (Cid cid) const;
/**
* \return the list of service flows configured with schedulingType as a QoS class
*/
std::vector<ServiceFlow*> GetServiceFlows (ServiceFlow::SchedulingType schedulingType) const;
/**
* \brief set the maximum Dynamic ServiceFlow Add (DSA) retries
*/
void SetMaxDsaRspRetries (uint8_t maxDsaRspRetries);
EventId GetDsaAckTimeoutEvent (void) const;
void AllocateServiceFlows (const DsaReq &dsaReq, Cid cid);
/**
* \brief add a multicast service flow
*/
void AddMulticastServiceFlow (ServiceFlow sf, enum WimaxPhy::ModulationType modulation);
/**
* \brief process a DSA-ACK message
* \param dsaAck the message to process
* \param cid the identifier of the connection on which the message was received
*/
void ProcessDsaAck (const DsaAck &dsaAck, Cid cid);
/**
* \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
*/
ServiceFlow* ProcessDsaReq (const DsaReq &dsaReq, Cid cid);
private:
DsaRsp CreateDsaRsp (const ServiceFlow *serviceFlow, uint16_t transactionId);
uint8_t GetMaxDsaRspRetries (void) const;
void ScheduleDsaRsp (ServiceFlow *serviceFlow, Cid cid);
Ptr<WimaxNetDevice> m_device;
uint32_t m_sfidIndex;
uint8_t m_maxDsaRspRetries;
EventId m_dsaAckTimeoutEvent;
Cid m_inuseScheduleDsaRspCid;
};
} // namespace ns3
#endif /* BS_SERVICE_FLOW_MANAGER_H */
| zy901002-gpsr | src/wimax/model/bs-service-flow-manager.h | C++ | gpl2 | 3,388 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "simple-ofdm-send-param.h"
#include "simple-ofdm-wimax-phy.h"
#include "simple-ofdm-wimax-channel.h"
namespace ns3 {
simpleOfdmSendParam::simpleOfdmSendParam (void)
{
// m_fecBlock = 0;
m_burstSize = 0;
m_isFirstBlock = 0;
m_frequency = 0;
m_modulationType = WimaxPhy::MODULATION_TYPE_QPSK_12;
m_direction = 0;
m_rxPowerDbm = 0;
}
simpleOfdmSendParam::simpleOfdmSendParam (const bvec &fecBlock,
uint32_t burstSize,
bool isFirstBlock,
uint64_t Frequency,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
double rxPowerDbm)
{
m_fecBlock = fecBlock;
m_burstSize = burstSize;
m_isFirstBlock = isFirstBlock;
m_frequency = Frequency;
m_modulationType = modulationType;
m_direction = direction;
m_rxPowerDbm = rxPowerDbm;
}
simpleOfdmSendParam::simpleOfdmSendParam (uint32_t burstSize,
bool isFirstBlock,
uint64_t Frequency,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
double rxPowerDbm,
Ptr<PacketBurst> burst)
{
m_burstSize = burstSize;
m_isFirstBlock = isFirstBlock;
m_frequency = Frequency;
m_modulationType = modulationType;
m_direction = direction;
m_rxPowerDbm = rxPowerDbm;
m_burst = burst;
}
simpleOfdmSendParam::~simpleOfdmSendParam (void)
{
}
void
simpleOfdmSendParam::SetFecBlock (const bvec &fecBlock)
{
m_fecBlock = fecBlock;
}
void
simpleOfdmSendParam::SetBurstSize (uint32_t burstSize)
{
m_burstSize = burstSize;
}
void
simpleOfdmSendParam::SetIsFirstBlock (bool isFirstBlock)
{
m_isFirstBlock = isFirstBlock;
}
void
simpleOfdmSendParam::SetFrequency (uint64_t Frequency)
{
m_frequency = Frequency;
}
void
simpleOfdmSendParam::SetModulationType (WimaxPhy::ModulationType modulationType)
{
m_modulationType = modulationType;
}
void
simpleOfdmSendParam::SetDirection (uint8_t direction)
{
m_direction = direction;
}
void
simpleOfdmSendParam::SetRxPowerDbm (double rxPowerDbm)
{
m_rxPowerDbm = rxPowerDbm;
}
bvec
simpleOfdmSendParam::GetFecBlock (void)
{
return m_fecBlock;
}
uint32_t
simpleOfdmSendParam::GetBurstSize (void)
{
return m_burstSize;
}
bool
simpleOfdmSendParam::GetIsFirstBlock (void)
{
return m_isFirstBlock;
}
uint64_t
simpleOfdmSendParam::GetFrequency (void)
{
return m_frequency;
}
WimaxPhy::ModulationType
simpleOfdmSendParam::GetModulationType (void)
{
return m_modulationType;
}
uint8_t
simpleOfdmSendParam::GetDirection (void)
{
return m_direction;
}
double
simpleOfdmSendParam::GetRxPowerDbm (void)
{
return m_rxPowerDbm;
}
Ptr<PacketBurst>
simpleOfdmSendParam::GetBurst (void)
{
return m_burst;
}
}
| zy901002-gpsr | src/wimax/model/simple-ofdm-send-param.cc | C++ | gpl2 | 3,948 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#include "wimax-tlv.h"
#include "cs-parameters.h"
namespace ns3 {
CsParameters::CsParameters ()
{
m_classifierDscAction = CsParameters::ADD;
}
CsParameters::~CsParameters ()
{
}
CsParameters::CsParameters (Tlv tlv)
{
NS_ASSERT_MSG (tlv.GetType () == SfVectorTlvValue::IPV4_CS_Parameters,
"Invalid TLV");
CsParamVectorTlvValue* param = ((CsParamVectorTlvValue*)(tlv.PeekValue ()));
for (std::vector<Tlv*>::const_iterator iter = param->Begin (); iter
!= param->End (); ++iter)
{
switch ((*iter)->GetType ())
{
case CsParamVectorTlvValue::Classifier_DSC_Action:
{
m_classifierDscAction
= (enum CsParameters::Action)((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case CsParamVectorTlvValue::Packet_Classification_Rule:
{
m_packetClassifierRule
= IpcsClassifierRecord (*(*iter));
break;
}
}
}
}
CsParameters::CsParameters (enum CsParameters::Action classifierDscAction,
IpcsClassifierRecord classifier)
{
m_classifierDscAction = classifierDscAction;
m_packetClassifierRule = classifier;
}
void
CsParameters::SetClassifierDscAction (enum CsParameters::Action action)
{
m_classifierDscAction = action;
}
void
CsParameters::SetPacketClassifierRule (IpcsClassifierRecord packetClassifierRule)
{
m_packetClassifierRule = packetClassifierRule;
}
enum CsParameters::Action
CsParameters::GetClassifierDscAction (void) const
{
return m_classifierDscAction;
}
IpcsClassifierRecord
CsParameters::GetPacketClassifierRule (void) const
{
return m_packetClassifierRule;
}
Tlv
CsParameters::ToTlv (void) const
{
CsParamVectorTlvValue tmp;
tmp.Add (Tlv (CsParamVectorTlvValue::Classifier_DSC_Action,1, U8TlvValue (m_classifierDscAction)));
tmp.Add (m_packetClassifierRule.ToTlv ());
return Tlv (SfVectorTlvValue::IPV4_CS_Parameters, tmp.GetSerializedSize (), tmp);
}
}
| zy901002-gpsr | src/wimax/model/cs-parameters.cc | C++ | gpl2 | 2,839 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "bs-uplink-scheduler.h"
#include "bs-net-device.h"
#include "ns3/simulator.h"
#include "cid.h"
#include "burst-profile-manager.h"
#include "ss-manager.h"
#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "bs-link-manager.h"
#include "bandwidth-manager.h"
NS_LOG_COMPONENT_DEFINE ("UplinkScheduler");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (UplinkScheduler);
UplinkScheduler::UplinkScheduler (void)
: m_bs (0),
m_timeStampIrInterval (Seconds (0)),
m_nrIrOppsAllocated (0),
m_isIrIntrvlAllocated (false),
m_isInvIrIntrvlAllocated (false),
m_dcdTimeStamp (Simulator::Now ()),
m_ucdTimeStamp (Simulator::Now ())
{
}
UplinkScheduler::UplinkScheduler (Ptr<BaseStationNetDevice> bs)
: m_bs (bs),
m_timeStampIrInterval (Seconds (0)),
m_nrIrOppsAllocated (0),
m_isIrIntrvlAllocated (false),
m_isInvIrIntrvlAllocated (false),
m_dcdTimeStamp (Simulator::Now ()),
m_ucdTimeStamp (Simulator::Now ())
{
}
UplinkScheduler::~UplinkScheduler (void)
{
m_bs = 0;
m_uplinkAllocations.clear ();
}
void
UplinkScheduler::InitOnce ()
{
}
TypeId
UplinkScheduler::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::UplinkScheduler")
.SetParent<Object> ()
;
return tid;
}
uint8_t
UplinkScheduler::GetNrIrOppsAllocated (void) const
{
return m_nrIrOppsAllocated;
}
void
UplinkScheduler::SetNrIrOppsAllocated (uint8_t nrIrOppsAllocated)
{
m_nrIrOppsAllocated = nrIrOppsAllocated;
}
bool
UplinkScheduler::GetIsIrIntrvlAllocated (void) const
{
return m_isIrIntrvlAllocated;
}
void
UplinkScheduler::SetIsIrIntrvlAllocated (bool isIrIntrvlAllocated)
{
m_isIrIntrvlAllocated = isIrIntrvlAllocated;
}
bool
UplinkScheduler::GetIsInvIrIntrvlAllocated (void) const
{
return m_isInvIrIntrvlAllocated;
}
void
UplinkScheduler::SetIsInvIrIntrvlAllocated (bool isInvIrIntrvlAllocated)
{
m_isInvIrIntrvlAllocated = isInvIrIntrvlAllocated;
}
Time
UplinkScheduler::GetDcdTimeStamp (void) const
{
return m_dcdTimeStamp;
}
void
UplinkScheduler::SetDcdTimeStamp (Time dcdTimeStamp)
{
m_dcdTimeStamp = dcdTimeStamp;
}
Time
UplinkScheduler::GetUcdTimeStamp (void) const
{
return m_ucdTimeStamp;
}
void
UplinkScheduler::SetUcdTimeStamp (Time ucdTimeStamp)
{
m_ucdTimeStamp = ucdTimeStamp;
}
std::list<OfdmUlMapIe>
UplinkScheduler::GetUplinkAllocations (void) const
{
return m_uplinkAllocations;
}
Time
UplinkScheduler::GetTimeStampIrInterval (void)
{
return m_timeStampIrInterval;
}
void
UplinkScheduler::SetTimeStampIrInterval (Time timeStampIrInterval)
{
m_timeStampIrInterval = timeStampIrInterval;
}
Ptr<BaseStationNetDevice>
UplinkScheduler::GetBs (void)
{
return m_bs;
}
void
UplinkScheduler::SetBs (Ptr<BaseStationNetDevice> bs)
{
m_bs = bs;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler.cc | C++ | gpl2 | 3,663 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef CRC8_H
#define CRC8_H
#include <stdint.h>
namespace ns3 {
/**
* \param data buffer to calculate the checksum for
* \param length the length of the buffer (bytes)
* \returns the computed crc.
*
*/
uint8_t CRC8Calculate (const uint8_t *data, int length);
} // namespace ns3
#endif
| zy901002-gpsr | src/wimax/model/crc8.h | C++ | gpl2 | 1,191 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include <stdint.h>
#include "ns3/node.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "service-flow.h"
#include "service-flow-manager.h"
#include "ns3/log.h"
#include "wimax-net-device.h"
#include "bs-net-device.h"
#include "ss-net-device.h"
#include "ss-record.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "wimax-connection.h"
#include "ss-manager.h"
#include "connection-manager.h"
#include "bs-uplink-scheduler.h"
#include "ss-scheduler.h"
#include "ns3/buffer.h"
#include "service-flow-record.h"
NS_LOG_COMPONENT_DEFINE ("SsServiceFlowManager");
namespace ns3 {
SsServiceFlowManager::SsServiceFlowManager (Ptr<SubscriberStationNetDevice> device)
: m_device (device),
m_sfidIndex (100),
m_maxDsaReqRetries (100),
m_dsaReq (DsaReq ()),
m_dsaAck (DsaAck ()),
m_currentTransactionId (0),
m_transactionIdIndex (1),
m_dsaReqRetries (0),
m_pendingServiceFlow (0)
{
}
SsServiceFlowManager::~SsServiceFlowManager (void)
{
}
void
SsServiceFlowManager::DoDispose (void)
{
ServiceFlowManager::DoDispose ();
}
void
SsServiceFlowManager::SetMaxDsaReqRetries (uint8_t maxDsaReqRetries)
{
m_maxDsaReqRetries = maxDsaReqRetries;
}
uint8_t
SsServiceFlowManager::GetMaxDsaReqRetries (void) const
{
return m_maxDsaReqRetries;
}
EventId
SsServiceFlowManager::GetDsaRspTimeoutEvent (void) const
{
return m_dsaRspTimeoutEvent;
}
EventId
SsServiceFlowManager::GetDsaAckTimeoutEvent (void) const
{
return m_dsaAckTimeoutEvent;
}
void
SsServiceFlowManager::AddServiceFlow (ServiceFlow serviceFlow)
{
ServiceFlow * sf = new ServiceFlow ();
sf->CopyParametersFrom (serviceFlow);
ServiceFlowManager::AddServiceFlow (sf);
}
void
SsServiceFlowManager::AddServiceFlow (ServiceFlow *serviceFlow)
{
ServiceFlowManager::AddServiceFlow (serviceFlow);
}
void
SsServiceFlowManager::InitiateServiceFlows (void)
{
ServiceFlow *serviceFlow = GetNextServiceFlowToAllocate ();
NS_ASSERT_MSG (serviceFlow != 0,"Error while initiating a new service flow: All service flows have been initiated");
m_pendingServiceFlow = serviceFlow;
ScheduleDsaReq (m_pendingServiceFlow);
}
DsaReq
SsServiceFlowManager::CreateDsaReq (const ServiceFlow *serviceFlow)
{
DsaReq dsaReq;
dsaReq.SetTransactionId (m_transactionIdIndex);
m_currentTransactionId = m_transactionIdIndex++;
/*as it is SS-initiated DSA therefore SFID and CID will
not be included, see 6.3.2.3.10.1 and 6.3.2.3.11.1*/
dsaReq.SetServiceFlow (*serviceFlow);
// dsaReq.SetParameterSet (*serviceFlow->GetParameterSet ());
return dsaReq;
}
Ptr<Packet>
SsServiceFlowManager::CreateDsaAck (void)
{
DsaAck dsaAck;
dsaAck.SetTransactionId (m_dsaReq.GetTransactionId ());
dsaAck.SetConfirmationCode (CONFIRMATION_CODE_SUCCESS);
m_dsaAck = dsaAck;
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (dsaAck);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_DSA_ACK));
return p;
}
void
SsServiceFlowManager::ScheduleDsaReq (const ServiceFlow *serviceFlow)
{
Ptr<Packet> p = Create<Packet> ();
DsaReq dsaReq;
Ptr<SubscriberStationNetDevice> ss = m_device->GetObject<SubscriberStationNetDevice> ();
if (m_dsaReqRetries == 0)
{
dsaReq = CreateDsaReq (serviceFlow);
p->AddHeader (dsaReq);
m_dsaReq = dsaReq;
}
else
{
if (m_dsaReqRetries <= m_maxDsaReqRetries)
{
p->AddHeader (m_dsaReq);
}
else
{
NS_LOG_DEBUG ("Service flows could not be initialized!");
}
}
m_dsaReqRetries++;
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_DSA_REQ));
if (m_dsaRspTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_dsaRspTimeoutEvent);
}
m_dsaRspTimeoutEvent = Simulator::Schedule (ss->GetIntervalT7 (),
&SsServiceFlowManager::ScheduleDsaReq,
this,
serviceFlow);
m_device->Enqueue (p, MacHeaderType (), ss->GetPrimaryConnection ());
}
void
SsServiceFlowManager::ProcessDsaRsp (const DsaRsp &dsaRsp)
{
Ptr<SubscriberStationNetDevice> ss = m_device->GetObject<SubscriberStationNetDevice> ();
// already received DSA-RSP for that particular DSA-REQ
if (dsaRsp.GetTransactionId () != m_currentTransactionId)
{
return;
}
Ptr<Packet> dsaAck = CreateDsaAck ();
m_device->Enqueue (dsaAck, MacHeaderType (), ss->GetPrimaryConnection ());
m_dsaReqRetries = 0;
if (m_pendingServiceFlow == NULL)
{
// May be the DSA-ACK was not received by the SS
return;
}
ServiceFlow sf = dsaRsp.GetServiceFlow ();
(*m_pendingServiceFlow) = sf;
m_pendingServiceFlow->SetUnsolicitedGrantInterval (1);
m_pendingServiceFlow->SetUnsolicitedPollingInterval (1);
Ptr<WimaxConnection> transportConnection = CreateObject<WimaxConnection> (sf.GetCid (),
Cid::TRANSPORT);
m_pendingServiceFlow->SetConnection (transportConnection);
transportConnection->SetServiceFlow (m_pendingServiceFlow);
ss->GetConnectionManager ()->AddConnection (transportConnection,
Cid::TRANSPORT);
m_pendingServiceFlow->SetIsEnabled (true);
m_pendingServiceFlow = 0;
// check if all service flow have been initiated
ServiceFlow * serviceFlow = GetNextServiceFlowToAllocate ();
if (serviceFlow == 0)
{
ss->SetAreServiceFlowsAllocated (true);
}
else
{
m_pendingServiceFlow = serviceFlow;
ScheduleDsaReq (m_pendingServiceFlow);
}
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ss-service-flow-manager.cc | C++ | gpl2 | 6,494 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef UPLINK_SCHEDULER_H
#define UPLINK_SCHEDULER_H
#include <stdint.h>
#include "ul-mac-messages.h"
#include "ns3/nstime.h"
#include "wimax-phy.h"
#include "service-flow-record.h"
#include "service-flow.h"
namespace ns3 {
class BaseStationNetDevice;
class SSRecord;
class ServiceFlow;
class ServiceFlowRecord;
/**
* \ingroup wimax
* \brief Virtual class for uplink scheduler.
*/
class UplinkScheduler : public Object
{
public:
UplinkScheduler (void);
UplinkScheduler (Ptr<BaseStationNetDevice> bs);
virtual ~UplinkScheduler (void);
static TypeId GetTypeId (void);
virtual uint8_t GetNrIrOppsAllocated (void) const;
virtual void SetNrIrOppsAllocated (uint8_t nrIrOppsAllocated);
virtual bool GetIsIrIntrvlAllocated (void) const;
virtual void SetIsIrIntrvlAllocated (bool isIrIntrvlAllocated);
virtual bool GetIsInvIrIntrvlAllocated (void) const;
virtual void SetIsInvIrIntrvlAllocated (bool isInvIrIntrvlAllocated);
virtual std::list<OfdmUlMapIe> GetUplinkAllocations (void) const;
virtual Time GetTimeStampIrInterval (void);
virtual void SetTimeStampIrInterval (Time timeStampIrInterval);
virtual Time GetDcdTimeStamp (void) const;
virtual void SetDcdTimeStamp (Time dcdTimeStamp);
virtual Time GetUcdTimeStamp (void) const;
virtual void SetUcdTimeStamp (Time ucdTimeStamp);
virtual Ptr<BaseStationNetDevice> GetBs (void);
virtual void SetBs (Ptr<BaseStationNetDevice> bs);
/**
* Determines if channel descriptors sent in the current frame are
* required to be updated
*/
virtual void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&) = 0;
virtual uint32_t CalculateAllocationStartTime (void) = 0;
virtual void AddUplinkAllocation (OfdmUlMapIe &ulMapIe,
const uint32_t &allocationSize,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols) = 0;
virtual void Schedule (void) = 0;
virtual void ServiceUnsolicitedGrants (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols) = 0;
virtual void ServiceBandwidthRequests (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols) = 0;
virtual bool ServiceBandwidthRequests (ServiceFlow *serviceFlow,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols) = 0;
virtual void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols) = 0;
virtual void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow) = 0;
virtual void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr) = 0;
virtual void InitOnce (void) = 0;
virtual void OnSetRequestedBandwidth (ServiceFlowRecord *sfr) = 0;
private:
Ptr<BaseStationNetDevice> m_bs;
std::list<OfdmUlMapIe> m_uplinkAllocations;
Time m_timeStampIrInterval;
uint8_t m_nrIrOppsAllocated;
bool m_isIrIntrvlAllocated;
bool m_isInvIrIntrvlAllocated;
Time m_dcdTimeStamp;
Time m_ucdTimeStamp;
};
} // namespace ns3
#endif /* UPLINK_SCHEDULER_H */
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler.h | C++ | gpl2 | 4,868 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef WIMAX_BS_NET_DEVICE_H
#define WIMAX_BS_NET_DEVICE_H
#include "wimax-net-device.h"
#include "ns3/event-id.h"
#include "wimax-connection.h"
#include "ns3/nstime.h"
#include "ns3/mac48-address.h"
#include "ns3/ipv4-address.h"
#include "ns3/bs-service-flow-manager.h"
#include "dl-mac-messages.h"
#include "ipcs-classifier.h"
namespace ns3 {
class Node;
class Packet;
class SSRecord;
class SSManager;
class BSScheduler;
class BurstProfileManager;
class BSLinkManager;
class UplinkScheduler;
class BsServiceFlowManager;
/**
* \ingroup wimax
*/
class BaseStationNetDevice : public WimaxNetDevice
{
public:
enum State
{
BS_STATE_DL_SUB_FRAME, BS_STATE_UL_SUB_FRAME, BS_STATE_TTG, BS_STATE_RTG
};
enum MacPreamble
{
SHORT_PREAMBLE = 1, LONG_PREAMBLE
};
static TypeId GetTypeId (void);
BaseStationNetDevice (void);
BaseStationNetDevice (Ptr<Node> node, Ptr<WimaxPhy> phy);
BaseStationNetDevice (Ptr<Node> node,
Ptr<WimaxPhy> phy,
Ptr<UplinkScheduler> uplinkScheduler,
Ptr<BSScheduler> bsScheduler);
~BaseStationNetDevice (void);
/**
* \param initialRangInterval Time between Initial Ranging regions assigned by the BS
*/
void SetInitialRangingInterval (Time initialRangInterval);
/**
* \brief initializes the BS net device and sets its parameters to the default values
*/
void InitBaseStationNetDevice (void);
/**
* \returns Time between Initial Ranging regions assigned by the BS
*/
Time GetInitialRangingInterval (void) const;
/**
* \param dcdInterval Time between transmission of DCD messages
*/
void SetDcdInterval (Time dcdInterval);
/**
* \returns the Time between transmission of DCD messages
*/
Time GetDcdInterval (void) const;
/**
* \param ucdInterval the Time between transmission of UCD messages
*/
void SetUcdInterval (Time ucdInterval);
/**
* \returns Time between transmission of UCD messages
*/
Time GetUcdInterval (void) const;
/**
* \param interval the Wait for DSA/DSC Acknowledge timeout
*/
void SetIntervalT8 (Time interval);
/**
* \returns the Wait for DSA/DSC Acknowledge timeout
*/
Time GetIntervalT8 (void) const;
/**
* \param maxRangCorrectionRetries the number of retries on contention Ranging Requests
*/
void SetMaxRangingCorrectionRetries (uint8_t maxRangCorrectionRetries);
/**
* \returns the number of retries on contention Ranging Requests
*/
uint8_t GetMaxRangingCorrectionRetries (void) const;
/**
* \param maxInvitedRangRetries the number of retries on contention Ranging
*/
void SetMaxInvitedRangRetries (uint8_t maxInvitedRangRetries);
/**
* \returns the number of retries on contention Ranging
*/
uint8_t GetMaxInvitedRangRetries (void) const;
/**
* \param rangReqOppSize The ranging opportunity size in symbols
*/
void SetRangReqOppSize (uint8_t rangReqOppSize);
/**
* \returns The ranging opportunity size in symbols
*/
uint8_t GetRangReqOppSize (void) const;
/**
* \param bwReqOppSize The bandwidth request opportunity size in symbols
*/
void SetBwReqOppSize (uint8_t bwReqOppSize);
/**
* \returns The bandwidth request opportunity size in symbols
*/
uint8_t GetBwReqOppSize (void) const;
/**
* \param dlSymbols the number of symbols in the downlink sub-frame
*/
void SetNrDlSymbols (uint32_t dlSymbols);
/**
* \returns the number of symbols in the downlink sub-frame
*/
uint32_t GetNrDlSymbols (void) const;
/**
* \param ulSymbols the number of symbols in the uplink sub-frame
*/
void SetNrUlSymbols (uint32_t ulSymbols);
/**
* \returns the number of symbols in the uplink sub-frame
*/
uint32_t GetNrUlSymbols (void) const;
/**
* \returns the number dcd messages already sent
*/
uint32_t GetNrDcdSent (void) const;
/**
* \returns the number ucd messages already sent
*/
uint32_t GetNrUcdSent (void) const;
Time GetDlSubframeStartTime (void) const;
Time GetUlSubframeStartTime (void) const;
uint8_t GetRangingOppNumber (void) const;
/**
* \returns a pointer to the SS manager
*/
Ptr<SSManager> GetSSManager (void) const;
/**
* \param ssManager the SS manager to be installed on the BS
*/
void SetSSManager (Ptr<SSManager> ssManager);
/**
* \returns a pointer to the uplink scheduler installed on the device
*/
Ptr<UplinkScheduler> GetUplinkScheduler (void) const;
/**
* \param ulScheduler the ulScheduler to be isnstalled on the BS
*/
void SetUplinkScheduler (Ptr<UplinkScheduler> ulScheduler);
/**
* \returns a pointer to the link manager installed on the BS
*/
Ptr<BSLinkManager> GetLinkManager (void) const;
/**
* \param bsSchedule the downlink scheduler to be installed on the BS
*/
void SetBSScheduler (Ptr<BSScheduler> bsSchedule);
/**
* \returns The BS scheduler installed on the BS
*/
Ptr<BSScheduler> GetBSScheduler (void) const;
/**
* \param linkManager The link manager installed on the BS
*/
void SetLinkManager (Ptr<BSLinkManager> linkManager);
/**
* \returns a pointer to the classifier installed on the BS
*/
Ptr<IpcsClassifier> GetBsClassifier (void) const;
/**
* \param classifier a classifier to be installed on the BS
*/
void SetBsClassifier (Ptr<IpcsClassifier> classifier);
Time GetPsDuration (void) const;
Time GetSymbolDuration (void) const;
void Start (void);
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
*/
bool Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType, Ptr<WimaxConnection> connection);
Ptr<WimaxConnection> GetConnection (Cid cid);
void MarkUplinkAllocations (void);
void MarkRangingOppStart (Time rangingOppStartTime);
Ptr<BsServiceFlowManager> GetServiceFlowManager (void) const;
void SetServiceFlowManager (Ptr<BsServiceFlowManager> );
private:
void DoDispose (void);
void StartFrame (void);
void StartDlSubFrame (void);
void EndDlSubFrame (void);
void StartUlSubFrame (void);
void EndUlSubFrame (void);
void EndFrame (void);
bool DoSend (Ptr<Packet> packet, const Mac48Address& source, const Mac48Address& dest, uint16_t protocolNumber);
void DoReceive (Ptr<Packet> packet);
/**
* \brief creates the MAC management messages DL-MAP and UL-MAP
*/
void CreateMapMessages (void);
/**
* \brief creates the channel descriptor MAC management messages DCD and UCD
*/
void CreateDescriptorMessages (bool sendDcd, bool senUcd);
void SendBursts (void);
Ptr<Packet> CreateDlMap (void);
Ptr<Packet> CreateDcd (void);
Ptr<Packet> CreateUlMap (void);
Ptr<Packet> CreateUcd (void);
void SetDlBurstProfiles (Dcd *dcd);
void SetUlBurstProfiles (Ucd *ucd);
void MarkUplinkAllocationStart (Time allocationStartTime);
void MarkUplinkAllocationEnd (Time allocationEndTime, Cid cid, uint8_t uiuc);
void UplinkAllocationStart (void);
void UplinkAllocationEnd (Cid cid, uint8_t uiuc);
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
uint8_t m_maxRangCorrectionRetries;
uint8_t m_maxInvitedRangRetries;
uint8_t m_rangReqOppSize; // in symbols
uint8_t m_bwReqOppSize; // in symbols
uint32_t m_nrDlSymbols;
uint32_t m_nrUlSymbols;
// to keep track total number of a certain management messages sent by the BS
uint32_t m_nrDlMapSent;
uint32_t m_nrUlMapSent;
// number of DCDs and UCDs sent even if same
uint32_t m_nrDcdSent;
uint32_t m_nrUcdSent;
uint32_t m_dcdConfigChangeCount;
uint32_t m_ucdConfigChangeCount;
uint32_t m_framesSinceLastDcd;
uint32_t m_framesSinceLastUcd;
// uint32_t m_nrFrames; //temporarily defined in wimax-net-device, as static
uint32_t m_nrDlFrames;
uint32_t m_nrUlFrames;
// to keep track if number of SSs have changed since the last frame
uint16_t m_nrSsRegistered;
uint16_t m_nrDlAllocations;
uint16_t m_nrUlAllocations;
Time m_dlSubframeStartTime;
Time m_ulSubframeStartTime;
uint8_t m_ulAllocationNumber; // to see UL burst number
uint8_t m_rangingOppNumber; // current ranging TO number
CidFactory *m_cidFactory;
uint32_t m_allocationStartTime;
Ptr<SSManager> m_ssManager;
Ptr<UplinkScheduler> m_uplinkScheduler;
Ptr<BSScheduler> m_scheduler;
Ptr<BSLinkManager> m_linkManager;
Ptr<IpcsClassifier> m_bsClassifier;
Ptr<BsServiceFlowManager> m_serviceFlowManager;
// same fields as in PHY, for quick access
Time m_psDuration;
Time m_symbolDuration;
TracedCallback<Ptr<const Packet>, Mac48Address, Cid> m_traceBSRx;
/**
* The trace source fired when packets come into the "top" of the device
* at the L3/L2 transition, before being queued for transmission.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_bsTxTrace;
/**
* The trace source fired when packets coming into the "top" of the device
* are dropped at the MAC layer during transmission.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_bsTxDropTrace;
/**
* The trace source fired for packets successfully received by the device
* immediately before being forwarded up to higher layers (at the L2/L3
* transition). This is a promiscuous trace.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_bsPromiscRxTrace;
/**
* The trace source fired for packets successfully received by the device
* immediately before being forwarded up to higher layers (at the L2/L3
* transition). This is a non- promiscuous trace.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_bsRxTrace;
/**
* The trace source fired when packets coming into the "top" of the device
* are dropped at the MAC layer during reception.
*
* \see class CallBackTraceSource
*/
TracedCallback<Ptr<const Packet> > m_bsRxDropTrace;
};
} // namespace ns3
#endif /* WIMAX_BS_NET_DEVICE_H */
| zy901002-gpsr | src/wimax/model/bs-net-device.h | C++ | gpl2 | 11,243 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef WIMAX_MAC_QUEUE_H
#define WIMAX_MAC_QUEUE_H
#include <queue>
#include <stdint.h>
#include "wimax-mac-header.h"
#include "ns3/packet.h"
#include "ns3/object.h"
#include "ns3/traced-callback.h"
#include "ns3/nstime.h"
namespace ns3 {
/**
* \ingroup wimax
*/
class WimaxMacQueue : public Object
{
public:
static TypeId GetTypeId (void);
WimaxMacQueue (void);
WimaxMacQueue (uint32_t maxSize);
~WimaxMacQueue (void);
/**
* \brief set the maximum queue size
* \param maxSize the max queue size
*/
void SetMaxSize (uint32_t maxSize);
/**
* \return the maximum queue size
*/
uint32_t GetMaxSize (void) const;
/**
* \brief Enqueue a packet
* \param packet the packet to enqueue
* \param hdrType the mac header type of the packet
* \param hdr the header of the packet
*/
bool Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType,
const GenericMacHeader &hdr);
/**
* \brief Dequeue a packet of type packetType from the queue
* \param packetType the type of the packet
* \return the first packet in the queue
*/
Ptr<Packet> Dequeue (MacHeaderType::HeaderType packetType);
/**
* \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
*/
Ptr<Packet> Dequeue (MacHeaderType::HeaderType packetType,
uint32_t availableByte);
/**
* \brief Same as Dequeue but does not pop from queue
*/
/**
* \brief Exclusive 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.
*/
Ptr<Packet> Peek (GenericMacHeader &hdr) const;
Ptr<Packet> 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.
*/
Ptr<Packet> Peek (MacHeaderType::HeaderType packetType) const;
Ptr<Packet> Peek (MacHeaderType::HeaderType packetType, Time &timeStamp) const;
bool IsEmpty (void) const;
/*
Exclusive for SS.
*/
bool IsEmpty (MacHeaderType::HeaderType packetType) const;
uint32_t GetSize (void) const;
uint32_t GetNBytes (void) const;
/**
* \brief Fragmentation utilities
*/
bool CheckForFragmentation (MacHeaderType::HeaderType packetType);
uint32_t GetFirstPacketHdrSize (MacHeaderType::HeaderType packetType);
uint32_t GetFirstPacketPayloadSize (MacHeaderType::HeaderType packetType);
uint32_t GetFirstPacketRequiredByte (MacHeaderType::HeaderType packetType);
uint32_t GetQueueLengthWithMACOverhead (void);
void SetFragmentation (MacHeaderType::HeaderType packetType);
void SetFragmentNumber (MacHeaderType::HeaderType packetType);
void SetFragmentOffset (MacHeaderType::HeaderType packetType, uint32_t offset);
private:
struct QueueElement
{
QueueElement (void);
QueueElement (Ptr<Packet> packet,
const MacHeaderType &hdrType,
const GenericMacHeader &hdr,
Time timeStamp);
uint32_t GetSize (void) const;
Ptr<Packet> m_packet;
MacHeaderType m_hdrType;
GenericMacHeader m_hdr;
Time m_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
*/
bool m_fragmentation;
uint32_t m_fragmentNumber;
uint32_t m_fragmentOffset;
void SetFragmentation (void);
void SetFragmentNumber (void);
void SetFragmentOffset (uint32_t offset);
};
/*
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.
*/
WimaxMacQueue::QueueElement Front (MacHeaderType::HeaderType packetType) const;
void Pop (MacHeaderType::HeaderType packetType);
typedef std::deque<QueueElement> PacketQueue;
PacketQueue m_queue;
uint32_t m_maxSize;
uint32_t m_bytes;
uint32_t m_nrDataPackets;
uint32_t m_nrRequestPackets;
TracedCallback<Ptr<const Packet> > m_traceEnqueue;
TracedCallback<Ptr<const Packet> > m_traceDequeue;
TracedCallback<Ptr<const Packet> > m_traceDrop;
public:
const WimaxMacQueue::PacketQueue & GetPacketQueue (void) const;
};
} // namespace ns3
#endif /* WIMAX_MAC_QUEUE_H */
| zy901002-gpsr | src/wimax/model/wimax-mac-queue.h | C++ | gpl2 | 5,829 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c)
*
* 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: Juliana Freitag Borin, Flavio Kubota and Nelson L.
* S. da Fonseca - wimaxgroup@lrc.ic.unicamp.br
*/
#ifndef UL_JOB_H
#define UL_JOB_H
#include <stdint.h>
#include "ns3/header.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"
namespace ns3 {
class SSRecord;
class ServiceFlow;
enum ReqType
{
DATA, UNICAST_POLLING
};
/**
* \ingroup wimax
* \brief this class implements a structure to compute the priority of service flows
*/
class UlJob : public Object
{
public:
enum JobPriority
{
LOW, INTERMEDIATE, HIGH
};
UlJob (void);
virtual ~UlJob (void);
SSRecord *
GetSsRecord (void);
void SetSsRecord (SSRecord* ssRecord);
enum ServiceFlow::SchedulingType GetSchedulingType (void);
void SetSchedulingType (ServiceFlow::SchedulingType schedulingType);
ServiceFlow *
GetServiceFlow (void);
void SetServiceFlow (ServiceFlow *serviceFlow);
ReqType GetType (void);
void SetType (ReqType type);
Time GetReleaseTime (void);
void SetReleaseTime (Time releaseTime);
Time GetPeriod (void);
void SetPeriod (Time period);
Time GetDeadline (void);
void SetDeadline (Time deadline);
uint32_t GetSize (void);
void SetSize (uint32_t size);
private:
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 */
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 */
SSRecord *m_ssRecord; /* Pointer to SSRecord */
ReqType m_type; /* Type of request, DATA or Unicast req slots */
ServiceFlow *m_serviceFlow;
};
class PriorityUlJob : public Object
{
/**
* \brief this class implements an auxiliar struct to compute the priority of the rtPS and nrtPS in
* the intermediate queue
*/
public:
PriorityUlJob ();
int GetPriority (void);
void SetPriority (int priority);
Ptr<UlJob>
GetUlJob (void);
void SetUlJob (Ptr<UlJob> job);
private:
int m_priority;
Ptr<UlJob> m_job;
};
struct SortProcess : public std::binary_function<PriorityUlJob*, PriorityUlJob*, bool>
{
bool operator () (PriorityUlJob& left, PriorityUlJob& right) const
{ // return true if left is logically less then right for given comparison
if (left.GetPriority () < right.GetPriority ())
{
return true;
}
else if (left.GetPriority () == right.GetPriority ())
{
int32_t leftBacklogged = left.GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
int32_t rightBacklogged = left.GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
if (leftBacklogged <= rightBacklogged)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
};
struct SortProcessPtr: public std::binary_function< Ptr<PriorityUlJob>, Ptr<PriorityUlJob>, bool>
{
bool operator () (Ptr<PriorityUlJob>& left, Ptr<PriorityUlJob>& right) const
{ //return true if left is logically less then right for given comparison
if (left->GetPriority () < right->GetPriority ())
{
return true;
}
else if (left->GetPriority () == right->GetPriority ())
{
int32_t leftBacklogged = left->GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
int32_t rightBacklogged = left->GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
if (leftBacklogged <= rightBacklogged)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
};
} // namespace ns3
#endif /* UL_JOB_H */
| zy901002-gpsr | src/wimax/model/ul-job.h | C++ | gpl2 | 4,848 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "ns3/simulator.h"
#include "ns3/callback.h"
#include "ns3/nstime.h"
#include "ns3/event-id.h"
#include "ns3/assert.h"
#include "ns3/net-device.h"
#include "ns3/node.h"
#include "wimax-phy.h"
#include "simple-ofdm-wimax-phy.h"
#include "simple-ofdm-wimax-channel.h"
#include "ns3/mobility-model.h"
#include "ns3/cost231-propagation-loss-model.h"
#include "simple-ofdm-send-param.h"
NS_LOG_COMPONENT_DEFINE ("simpleOfdmWimaxChannel");
namespace ns3 {
// NS_OBJECT_ENSURE_REGISTERED (simpleOfdmWimaxChannel);
SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel (void)
{
m_loss = 0;
}
SimpleOfdmWimaxChannel::~SimpleOfdmWimaxChannel (void)
{
m_phyList.clear ();
}
SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel (PropModel propModel)
{
switch (propModel)
{
case RANDOM_PROPAGATION:
m_loss = CreateObject<RandomPropagationLossModel> ();
break;
case FRIIS_PROPAGATION:
m_loss = CreateObject<FriisPropagationLossModel> ();
break;
case LOG_DISTANCE_PROPAGATION:
m_loss = CreateObject<LogDistancePropagationLossModel> ();
break;
case COST231_PROPAGATION:
m_loss = CreateObject<Cost231PropagationLossModel> ();
break;
default:
m_loss = 0;
}
}
void
SimpleOfdmWimaxChannel::SetPropagationModel (PropModel propModel)
{
switch (propModel)
{
case RANDOM_PROPAGATION:
m_loss = CreateObject<RandomPropagationLossModel> ();
break;
case FRIIS_PROPAGATION:
m_loss = CreateObject<FriisPropagationLossModel> ();
break;
case LOG_DISTANCE_PROPAGATION:
m_loss = CreateObject<LogDistancePropagationLossModel> ();
break;
case COST231_PROPAGATION:
m_loss = CreateObject<Cost231PropagationLossModel> ();
break;
default:
m_loss = 0;
}
}
void
SimpleOfdmWimaxChannel::DoAttach (Ptr<WimaxPhy> phy)
{
Ptr<SimpleOfdmWimaxPhy> o_phy = phy->GetObject<SimpleOfdmWimaxPhy> ();
m_phyList.push_back (o_phy);
}
uint32_t
SimpleOfdmWimaxChannel::DoGetNDevices (void) const
{
return m_phyList.size ();
}
Ptr<NetDevice>
SimpleOfdmWimaxChannel::DoGetDevice (uint32_t index) const
{
uint32_t j = 0;
for (std::list<Ptr<SimpleOfdmWimaxPhy> >::const_iterator iter = m_phyList.begin (); iter != m_phyList.end (); ++iter)
{
if (j == index)
{
return (*iter)->GetDevice ();
}
j++;
}
NS_FATAL_ERROR ("Unable to get device");
return 0;
}
void
SimpleOfdmWimaxChannel::Send (Time BlockTime,
uint32_t burstSize,
Ptr<WimaxPhy> phy,
bool isFirstBlock,
bool isLastBlock,
uint64_t frequency,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
double txPowerDbm,
Ptr<PacketBurst> burst)
{
double rxPowerDbm = 0;
Ptr<MobilityModel> senderMobility = 0;
Ptr<MobilityModel> receiverMobility = 0;
senderMobility = phy->GetDevice ()->GetNode ()->GetObject<MobilityModel> ();
simpleOfdmSendParam * param;
for (std::list<Ptr<SimpleOfdmWimaxPhy> >::iterator iter = m_phyList.begin (); iter != m_phyList.end (); ++iter)
{
Time delay = Seconds (0);
if (phy != *iter)
{
double distance = 0;
receiverMobility = (*iter)->GetDevice ()->GetNode ()->GetObject<MobilityModel> ();
if (receiverMobility != 0 && senderMobility != 0 && m_loss != 0)
{
distance = senderMobility->GetDistanceFrom (receiverMobility);
delay = Seconds (distance/300000000.0);
rxPowerDbm = m_loss->CalcRxPower (txPowerDbm, senderMobility, receiverMobility);
}
param = new simpleOfdmSendParam (burstSize,
isFirstBlock,
frequency,
modulationType,
direction,
rxPowerDbm,
burst);
Ptr<Object> dstNetDevice = (*iter)->GetDevice ();
uint32_t dstNode;
if (dstNetDevice == 0)
{
dstNode = 0xffffffff;
}
else
{
dstNode = dstNetDevice->GetObject<NetDevice> ()->GetNode ()->GetId ();
}
Simulator::ScheduleWithContext (dstNode,
delay,
&SimpleOfdmWimaxChannel::EndSendDummyBlock,
this,
*iter,
param);
}
}
}
void
SimpleOfdmWimaxChannel::EndSendDummyBlock (Ptr<SimpleOfdmWimaxPhy> rxphy, simpleOfdmSendParam * param)
{
rxphy->StartReceive (param->GetBurstSize (),
param->GetIsFirstBlock (),
param->GetFrequency (),
param->GetModulationType (),
param->GetDirection (),
param->GetRxPowerDbm (),
param->GetBurst ());
delete param;
}
}
// namespace ns3
| zy901002-gpsr | src/wimax/model/simple-ofdm-wimax-channel.cc | C++ | gpl2 | 6,248 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef SS_MANAGER_H
#define SS_MANAGER_H
#include <stdint.h>
#include "cid.h"
#include "ss-record.h"
namespace ns3 {
/**
* \ingroup wimax
* \brief this class manages a list of SSrecord
* \see SSrecord
*/
class SSManager : public Object
{
public:
static TypeId GetTypeId (void);
SSManager (void);
~SSManager (void);
SSRecord* CreateSSRecord (const Mac48Address &macAddress);
SSRecord* GetSSRecord (const Mac48Address &macAddress) const;
/**
* \brief returns the ssrecord which has been assigned this cid. Since
* different types of cids (basic, primary, transport) are assigned
* 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
*/
SSRecord* GetSSRecord (Cid cid) const;
std::vector<SSRecord*>* GetSSRecords (void) const;
bool IsInRecord (const Mac48Address &macAddress) const;
bool IsRegistered (const Mac48Address &macAddress) const;
void DeleteSSRecord (Cid cid);
Mac48Address GetMacAddress (Cid cid) const;
uint32_t GetNSSs (void) const;
uint32_t GetNRegisteredSSs (void) const;
private:
std::vector<SSRecord*> *m_ssRecords;
};
} // namespace ns3
#endif /* SS_MANAGER_H */
| zy901002-gpsr | src/wimax/model/ss-manager.h | C++ | gpl2 | 2,233 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "bs-uplink-scheduler-simple.h"
#include "bs-net-device.h"
#include "ns3/simulator.h"
#include "cid.h"
#include "burst-profile-manager.h"
#include "ss-manager.h"
#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "bs-link-manager.h"
#include "bandwidth-manager.h"
NS_LOG_COMPONENT_DEFINE ("UplinkSchedulerSimple");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (UplinkSchedulerSimple);
UplinkSchedulerSimple::UplinkSchedulerSimple (void)
{
SetBs (0);
SetTimeStampIrInterval (Seconds (0));
SetNrIrOppsAllocated (0);
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
SetDcdTimeStamp (Simulator::Now ());
SetUcdTimeStamp (Simulator::Now ());
}
UplinkSchedulerSimple::UplinkSchedulerSimple (Ptr<BaseStationNetDevice> bs)
{
SetBs (bs);
SetTimeStampIrInterval (Seconds (0));
SetNrIrOppsAllocated (0);
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
SetDcdTimeStamp (Simulator::Now ());
SetUcdTimeStamp (Simulator::Now ());
}
UplinkSchedulerSimple::~UplinkSchedulerSimple (void)
{
SetBs (0);
m_uplinkAllocations.clear ();
}
void
UplinkSchedulerSimple::InitOnce ()
{
}
TypeId
UplinkSchedulerSimple::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::UplinkSchedulerSimple").SetParent<Object> ();
return tid;
}
std::list<OfdmUlMapIe>
UplinkSchedulerSimple::GetUplinkAllocations (void) const
{
return m_uplinkAllocations;
}
void
UplinkSchedulerSimple::GetChannelDescriptorsToUpdate (bool &updateDcd,
bool &updateUcd,
bool &sendDcd,
bool &sendUcd)
{
/*DCD and UCD shall actually be updated when channel or burst profile definitions
change. burst profiles are updated based on number of SSs, network conditions and etc.
for now temporarily assuming DCD/UCD shall be updated everytime */
uint32_t randNr = rand ();
if (randNr % 5 == 0 || GetBs ()->GetNrDcdSent () == 0)
{
sendDcd = true;
}
randNr = rand ();
if (randNr % 5 == 0 || GetBs ()->GetNrUcdSent () == 0)
{
sendUcd = true;
}
// -------------------------------------
// additional, just to send more frequently
if (!sendDcd)
{
randNr = rand ();
if (randNr % 4 == 0)
{
sendDcd = true;
}
}
if (!sendUcd)
{
randNr = rand ();
if (randNr % 4 == 0)
{
sendUcd = true;
}
}
// -------------------------------------
Time timeSinceLastDcd = Simulator::Now () - GetDcdTimeStamp ();
Time timeSinceLastUcd = Simulator::Now () - GetUcdTimeStamp ();
if (timeSinceLastDcd > GetBs ()->GetDcdInterval ())
{
sendDcd = true;
SetDcdTimeStamp (Simulator::Now ());
}
if (timeSinceLastUcd > GetBs ()->GetUcdInterval ())
{
sendUcd = true;
SetUcdTimeStamp (Simulator::Now ());
}
}
uint32_t
UplinkSchedulerSimple::CalculateAllocationStartTime (void)
{
return GetBs ()->GetNrDlSymbols () * GetBs ()->GetPhy ()->GetPsPerSymbol () + GetBs ()->GetTtg ();
}
void
UplinkSchedulerSimple::AddUplinkAllocation (OfdmUlMapIe &ulMapIe,
const uint32_t &allocationSize,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
ulMapIe.SetDuration (allocationSize);
ulMapIe.SetStartTime (symbolsToAllocation);
m_uplinkAllocations.push_back (ulMapIe);
symbolsToAllocation += allocationSize;
availableSymbols -= allocationSize;
}
void
UplinkSchedulerSimple::Schedule (void)
{
m_uplinkAllocations.clear ();
SetIsIrIntrvlAllocated (false);
SetIsInvIrIntrvlAllocated (false);
bool allocationForDsa = false;
uint32_t symbolsToAllocation = 0;
uint32_t allocationSize = 0; // size in symbols
uint32_t availableSymbols = GetBs ()->GetNrUlSymbols ();
AllocateInitialRangingInterval (symbolsToAllocation, availableSymbols);
std::vector<SSRecord*> *ssRecords = GetBs ()->GetSSManager ()->GetSSRecords ();
for (std::vector<SSRecord*>::iterator iter = ssRecords->begin (); iter != ssRecords->end (); ++iter)
{
SSRecord *ssRecord = *iter;
if (ssRecord->GetIsBroadcastSS ())
{
continue;
}
Cid cid = ssRecord->GetBasicCid ();
OfdmUlMapIe ulMapIe;
ulMapIe.SetCid (cid);
if (ssRecord->GetPollForRanging () && ssRecord->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_CONTINUE)
{
// SS's ranging is not yet complete
// allocating invited initial ranging interval
ulMapIe.SetUiuc (OfdmUlBurstProfile::UIUC_INITIAL_RANGING);
allocationSize = GetBs ()->GetRangReqOppSize ();
SetIsInvIrIntrvlAllocated (true);
if (availableSymbols >= allocationSize)
{
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
}
else
{
break;
}
}
else
{
WimaxPhy::ModulationType modulationType = ssRecord->GetModulationType ();
// need to update because modulation/FEC to UIUC mapping may vary over time
ulMapIe.SetUiuc (GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_UPLINK));
// establish service flows for SS
if (ssRecord->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_SUCCESS
&& !ssRecord->GetAreServiceFlowsAllocated ())
{
// allocating grant (with arbitrary size) to allow SS to send DSA messages DSA-REQ and DSA-ACK
// only one DSA allocation per frame
if (!allocationForDsa)
{
allocationSize = GetBs ()->GetPhy ()->GetNrSymbols (sizeof(DsaReq), modulationType);
if (availableSymbols >= allocationSize)
{
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
allocationForDsa = true;
}
else
{
break;
}
}
}
else
{
// all service flows associated to SS are established now
/*allocating grants for data transmission for UGS flows (Data Grant Burst Type IEs, 6.3.7.4.3.3)
(grant has been referred by different names e.g. transmission opportunity, slot, uplink allocation, etc)*/
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_UGS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
// allocate unicast polls for rtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_RTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// allocate unicast polls for nrtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_NRTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// finally allocate unicast polls for BE flows if bandwidth is available
if (availableSymbols)
{
ServiceUnsolicitedGrants (ssRecord,
ServiceFlow::SF_TYPE_BE,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// now allocating grants for non-UGS flows (i.e., in response of bandwidth requests)
if (availableSymbols)
{
ServiceBandwidthRequests (ssRecord,
ServiceFlow::SF_TYPE_RTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// allocate unicast polls for nrtPS flows if bandwidth is available
if (availableSymbols)
{
ServiceBandwidthRequests (ssRecord,
ServiceFlow::SF_TYPE_NRTPS,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
// finally allocate unicast polls for BE flows if bandwidth is available
if (availableSymbols)
{
ServiceBandwidthRequests (ssRecord,
ServiceFlow::SF_TYPE_BE,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
}
}
}
}
OfdmUlMapIe ulMapIeEnd;
ulMapIeEnd.SetCid (Cid::InitialRanging ());
ulMapIeEnd.SetStartTime (symbolsToAllocation);
ulMapIeEnd.SetUiuc (OfdmUlBurstProfile::UIUC_END_OF_MAP);
ulMapIeEnd.SetDuration (0);
m_uplinkAllocations.push_back (ulMapIeEnd);
// setting DL/UL subframe allocation for the next frame
GetBs ()->GetBandwidthManager ()->SetSubframeRatio ();
}
void
UplinkSchedulerSimple::ServiceUnsolicitedGrants (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
uint32_t allocationSize = 0; // size in symbols
uint8_t uiuc = ulMapIe.GetUiuc (); // SS's burst profile
std::vector<ServiceFlow*> serviceFlows = ssRecord->GetServiceFlows (schedulingType);
for (std::vector<ServiceFlow*>::iterator iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
ServiceFlow *serviceFlow = *iter;
/* in case of rtPS, nrtPS and BE, allocating unicast polls for bandwidth requests (Request IEs, 6.3.7.4.3.1).
in case of UGS, allocating grants for data transmission (Data Grant Burst Type IEs, 6.3.7.4.3.3) (grant has
been referred in this code by different names e.g. transmission opportunity, slot, allocation, etc) */
allocationSize = GetBs ()->GetBandwidthManager ()->CalculateAllocationSize (ssRecord, serviceFlow);
// verifying that minimum reserved traffic rate of nrtPS flow is maintained
if (serviceFlow->GetSchedulingType () == ServiceFlow::SF_TYPE_NRTPS)
{
Time currentTime = Simulator::Now ();
ServiceFlowRecord *record = serviceFlow->GetRecord ();
if (currentTime - record->GetGrantTimeStamp () > Seconds (1))
{
uint32_t bps = (record->GetBwSinceLastExpiry () * 8);
if (bps < serviceFlow->GetMinReservedTrafficRate ())
{
ServiceBandwidthRequests (serviceFlow,
schedulingType,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols);
record->SetBwSinceLastExpiry (0);
record->SetGrantTimeStamp (currentTime);
}
}
}
if (availableSymbols < allocationSize)
{
break;
}
if (allocationSize > 0)
{
ulMapIe.SetStartTime (symbolsToAllocation);
if (serviceFlow->GetSchedulingType () != ServiceFlow::SF_TYPE_UGS)
{
// special burst profile with most robust modulation type is used for unicast polls (Request IEs)
ulMapIe.SetUiuc (OfdmUlBurstProfile::UIUC_REQ_REGION_FULL);
}
}
else
{
continue;
}
NS_LOG_DEBUG (", CID: " << serviceFlow->GetConnection ()->GetCid () << ", SFID: " << serviceFlow->GetSfid ());
AddUplinkAllocation (ulMapIe, allocationSize, symbolsToAllocation, availableSymbols);
ulMapIe.SetUiuc (uiuc);
}
}
void
UplinkSchedulerSimple::ServiceBandwidthRequests (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
std::vector<ServiceFlow*> serviceFlows = ssRecord->GetServiceFlows (schedulingType);
for (std::vector<ServiceFlow*>::iterator iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
if (!ServiceBandwidthRequests (*iter,
schedulingType,
ulMapIe,
modulationType,
symbolsToAllocation,
availableSymbols))
{
break;
}
}
}
bool
UplinkSchedulerSimple::ServiceBandwidthRequests (ServiceFlow *serviceFlow,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols)
{
uint32_t allocSizeBytes = 0;
uint32_t allocSizeSymbols = 0;
uint16_t sduSize = 0;
ServiceFlowRecord *record = serviceFlow->GetRecord ();
sduSize = serviceFlow->GetSduSize ();
uint32_t requiredBandwidth = record->GetRequestedBandwidth () - record->GetGrantedBandwidth ();
if (requiredBandwidth > 0)
{
if (sduSize > 0)
{
// if SDU size is mentioned, allocate grant of that size
allocSizeBytes = sduSize;
allocSizeSymbols = GetBs ()->GetPhy ()->GetNrSymbols (sduSize, modulationType);
}
else
{
allocSizeBytes = requiredBandwidth;
allocSizeSymbols = GetBs ()->GetPhy ()->GetNrSymbols (requiredBandwidth, modulationType);
}
if (availableSymbols >= allocSizeSymbols)
{
record->UpdateGrantedBandwidth (allocSizeBytes);
if (schedulingType == ServiceFlow::SF_TYPE_NRTPS)
{
record->SetBwSinceLastExpiry (allocSizeBytes);
}
AddUplinkAllocation (ulMapIe, allocSizeSymbols, symbolsToAllocation, availableSymbols);
}
else
{
return false;
}
}
return true;
}
void
UplinkSchedulerSimple::AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols)
{
Time ssUlStartTime = Seconds (CalculateAllocationStartTime () * GetBs ()->GetPsDuration ().GetSeconds ());
SetNrIrOppsAllocated (GetBs ()->GetLinkManager ()->CalculateRangingOppsToAllocate ());
uint32_t allocationSize = GetNrIrOppsAllocated () * GetBs ()->GetRangReqOppSize ();
Time timeSinceLastIrInterval = Simulator::Now () - GetTimeStampIrInterval ();
// adding one frame because may be the time has not elapsed now but will elapse before the next frame is sent
if (timeSinceLastIrInterval + GetBs ()->GetPhy ()->GetFrameDuration () > GetBs ()->GetInitialRangingInterval ()
&& availableSymbols >= allocationSize)
{
SetIsIrIntrvlAllocated (true);
OfdmUlMapIe ulMapIeIr;
ulMapIeIr.SetCid ((GetBs ()->GetBroadcastConnection ())->GetCid ());
ulMapIeIr.SetStartTime (symbolsToAllocation);
ulMapIeIr.SetUiuc (OfdmUlBurstProfile::UIUC_INITIAL_RANGING);
NS_LOG_DEBUG ("BS uplink scheduler, initial ranging allocation, size: " << allocationSize << " symbols"
<< ", modulation: BPSK 1/2");
// marking start and end of each TO, only for debugging
for (uint8_t i = 0; i < GetNrIrOppsAllocated (); i++)
{
GetBs ()->MarkRangingOppStart (ssUlStartTime + Seconds (symbolsToAllocation
* GetBs ()->GetSymbolDuration ().GetSeconds ()) + Seconds (i * GetBs ()->GetRangReqOppSize ()
* GetBs ()->GetSymbolDuration ().GetSeconds ()));
}
AddUplinkAllocation (ulMapIeIr, allocationSize, symbolsToAllocation, availableSymbols);
SetTimeStampIrInterval (Simulator::Now ());
}
}
void
UplinkSchedulerSimple::SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow)
{
uint8_t delayNrFrames = 1;
uint32_t bitsPerSecond = serviceFlow->GetMinReservedTrafficRate ();
WimaxPhy::ModulationType modulation;
uint32_t bytesPerFrame =
(uint32_t ((double)(bitsPerSecond) * GetBs ()->GetPhy ()->GetFrameDuration ().GetSeconds ())) / 8;
uint32_t frameDurationMSec = GetBs ()->GetPhy ()->GetFrameDuration ().GetMilliSeconds ();
switch (serviceFlow->GetSchedulingType ())
{
case ServiceFlow::SF_TYPE_UGS:
{
if (serviceFlow->GetIsMulticast () == true)
{
modulation = serviceFlow->GetModulation ();
}
else
{
modulation = ssRecord->GetModulationType ();
}
uint32_t grantSize = GetBs ()->GetPhy ()->GetNrSymbols (bytesPerFrame, modulation);
serviceFlow->GetRecord ()->SetGrantSize (grantSize);
uint32_t toleratedJitter = serviceFlow->GetToleratedJitter ();
if (toleratedJitter > frameDurationMSec)
{
delayNrFrames = (uint8_t)(toleratedJitter / frameDurationMSec);
}
uint16_t interval = delayNrFrames * frameDurationMSec;
serviceFlow->SetUnsolicitedGrantInterval (interval);
}
break;
case ServiceFlow::SF_TYPE_RTPS:
{
if (serviceFlow->GetSduSize () > bytesPerFrame)
{
delayNrFrames = (uint8_t)(serviceFlow->GetSduSize () / bytesPerFrame);
}
uint16_t interval = delayNrFrames * frameDurationMSec;
serviceFlow->SetUnsolicitedPollingInterval (interval);
}
break;
case ServiceFlow::SF_TYPE_NRTPS:
{
// no real-time guarantees are given to NRTPS, serviced based on available bandwidth
}
break;
case ServiceFlow::SF_TYPE_BE:
{
// no real-time guarantees are given to BE, serviced based on available bandwidth
}
break;
default:
NS_FATAL_ERROR ("Invalid scheduling type");
}
}
void
UplinkSchedulerSimple::ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr)
{
// virtual function on UplinkScheduler
// this is not necessary on this implementation
}
void
UplinkSchedulerSimple::OnSetRequestedBandwidth (ServiceFlowRecord *sfr)
{
// m_grantedBandwidth must be reset to zero
uint32_t grantedBandwidth = 0;
sfr->SetGrantedBandwidth (grantedBandwidth);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler-simple.cc | C++ | gpl2 | 21,847 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include <stdint.h>
#include "ns3/node.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "service-flow.h"
#include "service-flow-manager.h"
#include "ns3/log.h"
#include "wimax-net-device.h"
#include "bs-net-device.h"
#include "ss-net-device.h"
#include "ss-record.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "wimax-connection.h"
#include "ss-manager.h"
#include "connection-manager.h"
#include "bs-uplink-scheduler.h"
#include "ss-scheduler.h"
#include "ns3/buffer.h"
#include "service-flow-record.h"
NS_LOG_COMPONENT_DEFINE ("ServiceFlowManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (ServiceFlowManager);
TypeId ServiceFlowManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::ServiceFlowManager")
.SetParent<Object> ();
return tid;
}
ServiceFlowManager::ServiceFlowManager ()
{
m_serviceFlows = new std::vector<ServiceFlow*>;
}
ServiceFlowManager::~ServiceFlowManager (void)
{
}
void
ServiceFlowManager::DoDispose (void)
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
delete (*iter);
}
m_serviceFlows->clear ();
delete m_serviceFlows;
}
void
ServiceFlowManager::AddServiceFlow (ServiceFlow *serviceFlow)
{
m_serviceFlows->push_back (serviceFlow);
}
ServiceFlow* ServiceFlowManager::DoClassify (Ipv4Address srcAddress,
Ipv4Address dstAddress,
uint16_t srcPort,
uint16_t dstPort,
uint8_t proto,
ServiceFlow::Direction dir) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetDirection () == dir)
{
if ((*iter)->CheckClassifierMatch (srcAddress, dstAddress, srcPort, dstPort, proto))
{
return (*iter);
}
}
}
return 0;
}
ServiceFlow*
ServiceFlowManager::GetServiceFlow (uint32_t sfid) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetSfid () == sfid)
{
return (*iter);
}
}
NS_LOG_DEBUG ("GetServiceFlow: service flow not found!");
return 0;
}
ServiceFlow*
ServiceFlowManager::GetServiceFlow (Cid cid) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetCid () == cid.GetIdentifier ())
{
return (*iter);
}
}
NS_LOG_DEBUG ("GetServiceFlow: service flow not found!");
return 0;
}
std::vector<ServiceFlow*>
ServiceFlowManager::GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const
{
std::vector<ServiceFlow*> tmpServiceFlows;
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if (((*iter)->GetSchedulingType () == schedulingType) || (schedulingType == ServiceFlow::SF_TYPE_ALL))
{
tmpServiceFlows.push_back ((*iter));
}
}
return tmpServiceFlows;
}
bool
ServiceFlowManager::AreServiceFlowsAllocated ()
{
return AreServiceFlowsAllocated (m_serviceFlows);
}
bool
ServiceFlowManager::AreServiceFlowsAllocated (std::vector<ServiceFlow*>* serviceFlowVector)
{
return AreServiceFlowsAllocated (*serviceFlowVector);
}
bool
ServiceFlowManager::AreServiceFlowsAllocated (std::vector<ServiceFlow*> serviceFlowVector)
{
for (std::vector<ServiceFlow*>::const_iterator iter = serviceFlowVector.begin (); iter != serviceFlowVector.end (); ++iter)
{
if (!(*iter)->GetIsEnabled ())
{
return false;
}
}
return true;
}
ServiceFlow*
ServiceFlowManager::GetNextServiceFlowToAllocate ()
{
std::vector<ServiceFlow*>::iterator iter;
for (iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if (!(*iter)->GetIsEnabled ())
{
return (*iter);
}
}
return 0;
}
uint32_t
ServiceFlowManager::GetNrServiceFlows (void) const
{
return m_serviceFlows->size ();
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/service-flow-manager.cc | C++ | gpl2 | 5,224 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "connection-manager.h"
#include "ns3/log.h"
#include "cid-factory.h"
#include "ss-record.h"
#include "mac-messages.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "service-flow.h"
#include "ss-net-device.h"
#include "bs-net-device.h"
NS_LOG_COMPONENT_DEFINE ("ConnectionManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (ConnectionManager);
TypeId ConnectionManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::ConnectionManager")
.SetParent<Object> ();
return tid;
}
ConnectionManager::ConnectionManager (void)
: m_cidFactory (0)
{
}
void
ConnectionManager::DoDispose (void)
{
}
ConnectionManager::~ConnectionManager (void)
{
}
void
ConnectionManager::SetCidFactory (CidFactory *cidFactory)
{
m_cidFactory = cidFactory;
}
void
ConnectionManager::AllocateManagementConnections (SSRecord *ssRecord, RngRsp *rngrsp)
{
Ptr<WimaxConnection> basicConnection = CreateConnection (Cid::BASIC);
ssRecord->SetBasicCid (basicConnection->GetCid ());
Ptr<WimaxConnection> primaryConnection = CreateConnection (Cid::PRIMARY);
ssRecord->SetPrimaryCid (primaryConnection->GetCid ());
rngrsp->SetBasicCid (basicConnection->GetCid ());
rngrsp->SetPrimaryCid (primaryConnection->GetCid ());
}
Ptr<WimaxConnection>
ConnectionManager::CreateConnection (Cid::Type type)
{
Cid cid;
switch (type)
{
case Cid::BASIC:
case Cid::MULTICAST:
case Cid::PRIMARY:
cid = m_cidFactory->Allocate (type);
break;
case Cid::TRANSPORT:
cid = m_cidFactory->AllocateTransportOrSecondary ();
break;
default:
NS_FATAL_ERROR ("Invalid connection type");
break;
}
Ptr<WimaxConnection> connection = CreateObject<WimaxConnection> (cid, type);
AddConnection (connection, type);
return connection;
}
void
ConnectionManager::AddConnection (Ptr<WimaxConnection> connection, Cid::Type type)
{
switch (type)
{
case Cid::BASIC:
m_basicConnections.push_back (connection);
break;
case Cid::PRIMARY:
m_primaryConnections.push_back (connection);
break;
case Cid::TRANSPORT:
m_transportConnections.push_back (connection);
break;
case Cid::MULTICAST:
m_multicastConnections.push_back (connection);
break;
default:
NS_FATAL_ERROR ("Invalid connection type");
break;
}
}
Ptr<WimaxConnection>
ConnectionManager::GetConnection (Cid cid)
{
std::vector<Ptr<WimaxConnection> >::const_iterator iter;
for (iter = m_basicConnections.begin (); iter != m_basicConnections.end (); ++iter)
{
if ((*iter)->GetCid () == cid)
{
return *iter;
}
}
for (iter = m_primaryConnections.begin (); iter != m_primaryConnections.end (); ++iter)
{
if ((*iter)->GetCid () == cid)
{
return *iter;
}
}
for (iter = m_transportConnections.begin (); iter != m_transportConnections.end (); ++iter)
{
if ((*iter)->GetCid () == cid)
{
return *iter;
}
}
return 0;
}
std::vector<Ptr<WimaxConnection> >
ConnectionManager::GetConnections (Cid::Type type) const
{
std::vector<Ptr<WimaxConnection> > connections;
switch (type)
{
case Cid::BASIC:
connections = m_basicConnections;
break;
case Cid::PRIMARY:
connections = m_primaryConnections;
break;
case Cid::TRANSPORT:
connections = m_transportConnections;
break;
default:
NS_FATAL_ERROR ("Invalid connection type");
break;
}
return connections;
}
uint32_t
ConnectionManager::GetNPackets (Cid::Type type, ServiceFlow::SchedulingType schedulingType) const
{
uint32_t nrPackets = 0;
switch (type)
{
case Cid::BASIC:
{
for (std::vector<Ptr<WimaxConnection> >::const_iterator iter = m_basicConnections.begin (); iter
!= m_basicConnections.end (); ++iter)
{
nrPackets += (*iter)->GetQueue ()->GetSize ();
}
break;
}
case Cid::PRIMARY:
{
for (std::vector<Ptr<WimaxConnection> >::const_iterator iter = m_primaryConnections.begin (); iter
!= m_primaryConnections.end (); ++iter)
{
nrPackets += (*iter)->GetQueue ()->GetSize ();
}
break;
}
case Cid::TRANSPORT:
{
for (std::vector<Ptr<WimaxConnection> >::const_iterator iter = m_transportConnections.begin (); iter
!= m_transportConnections.end (); ++iter)
{
if (schedulingType == ServiceFlow::SF_TYPE_ALL || (*iter)->GetSchedulingType () == schedulingType)
{
nrPackets += (*iter)->GetQueue ()->GetSize ();
}
}
break;
}
default:
NS_FATAL_ERROR ("Invalid connection type");
break;
}
return nrPackets;
}
bool
ConnectionManager::HasPackets (void) const
{
std::vector<Ptr<WimaxConnection> >::const_iterator iter;
for (iter = m_basicConnections.begin (); iter != m_basicConnections.end (); ++iter)
{
if ((*iter)->HasPackets ())
{
return true;
}
}
for (iter = m_primaryConnections.begin (); iter != m_primaryConnections.end (); ++iter)
{
if ((*iter)->HasPackets ())
{
return true;
}
}
for (iter = m_transportConnections.begin (); iter != m_transportConnections.end (); ++iter)
{
if ((*iter)->HasPackets ())
{
return true;
}
}
return false;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/connection-manager.cc | C++ | gpl2 | 6,496 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "ns3/llc-snap-header.h"
#include "ns3/simulator.h"
#include "ns3/callback.h"
#include "ns3/node.h"
#include "ns3/packet.h"
#include "wimax-net-device.h"
#include "wimax-channel.h"
#include "ns3/packet-burst.h"
#include "burst-profile-manager.h"
#include <list>
#include "send-params.h"
#include "ns3/uinteger.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "service-flow-manager.h"
#include "connection-manager.h"
#include "bandwidth-manager.h"
NS_LOG_COMPONENT_DEFINE ("WimaxNetDevice");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxNetDevice);
uint32_t WimaxNetDevice::m_nrFrames = 0;
uint8_t WimaxNetDevice::m_direction = ~0;
Time WimaxNetDevice::m_frameStartTime = Seconds (0);
TypeId WimaxNetDevice::GetTypeId (void)
{
static TypeId
tid =
TypeId ("ns3::WimaxNetDevice")
.SetParent<NetDevice> ()
.AddAttribute ("Mtu", "The MAC-level Maximum Transmission Unit",
UintegerValue (DEFAULT_MSDU_SIZE),
MakeUintegerAccessor (&WimaxNetDevice::SetMtu,
&WimaxNetDevice::GetMtu),
MakeUintegerChecker<uint16_t> (0,MAX_MSDU_SIZE))
.AddAttribute ("Phy",
"The PHY layer attached to this device.",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::GetPhy, &WimaxNetDevice::SetPhy),
MakePointerChecker<WimaxPhy> ())
.AddAttribute ("Channel",
"The channel attached to this device.",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::GetPhyChannel, &WimaxNetDevice::SetChannel),
MakePointerChecker<WimaxChannel> ())
.AddAttribute ("RTG",
"receive/transmit transition gap.",
UintegerValue (0),
MakeUintegerAccessor (&WimaxNetDevice::GetRtg, &WimaxNetDevice::SetRtg),
MakeUintegerChecker<uint16_t> (0, 120))
.AddAttribute ("TTG",
"transmit/receive transition gap.",
UintegerValue (0),
MakeUintegerAccessor (&WimaxNetDevice::GetTtg, &WimaxNetDevice::SetTtg),
MakeUintegerChecker<uint16_t> (0, 120))
.AddAttribute ("ConnectionManager",
"The connection manager attached to this device.",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::GetConnectionManager,
&WimaxNetDevice::SetConnectionManager),
MakePointerChecker<ConnectionManager> ())
.AddAttribute ("BurstProfileManager",
"The burst profile manager attached to this device.",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::GetBurstProfileManager,
&WimaxNetDevice::SetBurstProfileManager),
MakePointerChecker<BurstProfileManager> ())
.AddAttribute ("BandwidthManager",
"The bandwidth manager attached to this device.",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::GetBandwidthManager,
&WimaxNetDevice::SetBandwidthManager),
MakePointerChecker<BandwidthManager> ())
.AddAttribute ("InitialRangingConnection",
"Initial ranging connection",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::m_initialRangingConnection),
MakePointerChecker<WimaxConnection> ())
.AddAttribute ("BroadcastConnection",
"Broadcast connection",
PointerValue (),
MakePointerAccessor (&WimaxNetDevice::m_broadcastConnection),
MakePointerChecker<WimaxConnection> ())
.AddTraceSource ("Rx", "Receive trace", MakeTraceSourceAccessor (&WimaxNetDevice::m_traceRx))
.AddTraceSource ("Tx", "Transmit trace", MakeTraceSourceAccessor (&WimaxNetDevice::m_traceTx));
return tid;
}
WimaxNetDevice::WimaxNetDevice (void)
: m_state (0),
m_symbolIndex (0),
m_ttg (0),
m_rtg (0)
{
InitializeChannels ();
m_connectionManager = CreateObject<ConnectionManager> ();
m_burstProfileManager = CreateObject<BurstProfileManager> (this);
m_bandwidthManager = CreateObject<BandwidthManager> (this);
m_nrFrames = 0;
m_direction = ~0;
m_frameStartTime = Seconds (0);
}
WimaxNetDevice::~WimaxNetDevice (void)
{
}
void
WimaxNetDevice::DoDispose (void)
{
m_phy->Dispose ();
m_phy = 0;
m_node = 0;
m_initialRangingConnection = 0;
m_broadcastConnection = 0;
m_connectionManager = 0;
m_burstProfileManager = 0;
m_bandwidthManager = 0;
m_connectionManager = 0;
m_bandwidthManager = 0;
NetDevice::DoDispose ();
}
void
WimaxNetDevice::SetTtg (uint16_t ttg)
{
m_ttg = ttg;
}
uint16_t
WimaxNetDevice::GetTtg (void) const
{
return m_ttg;
}
void
WimaxNetDevice::SetRtg (uint16_t rtg)
{
m_rtg = rtg;
}
uint16_t
WimaxNetDevice::GetRtg (void) const
{
return m_rtg;
}
void
WimaxNetDevice::SetName (const std::string name)
{
m_name = name;
}
std::string
WimaxNetDevice::GetName (void) const
{
return m_name;
}
void
WimaxNetDevice::SetIfIndex (const uint32_t index)
{
m_ifIndex = index;
}
uint32_t
WimaxNetDevice::GetIfIndex (void) const
{
return m_ifIndex;
}
Ptr<Channel>
WimaxNetDevice::GetChannel (void) const
{
return DoGetChannel ();
}
Ptr<Channel>
WimaxNetDevice::GetPhyChannel (void) const
{
return DoGetChannel ();
}
bool
WimaxNetDevice::SetMtu (const uint16_t mtu)
{
if (mtu > MAX_MSDU_SIZE)
{
return false;
}
m_mtu = mtu;
return true;
}
uint16_t
WimaxNetDevice::GetMtu (void) const
{
return m_mtu;
}
bool
WimaxNetDevice::IsLinkUp (void) const
{
return m_phy != 0 && m_linkUp;
}
void
WimaxNetDevice::SetLinkChangeCallback (Callback<void> callback)
{
m_linkChange = callback;
}
bool
WimaxNetDevice::IsBroadcast (void) const
{
return true;
}
Address
WimaxNetDevice::GetBroadcast (void) const
{
return Mac48Address::GetBroadcast ();
}
bool
WimaxNetDevice::IsMulticast (void) const
{
return false;
}
Address
WimaxNetDevice::GetMulticast (void) const
{
return Mac48Address ("01:00:5e:00:00:00");
}
Address
WimaxNetDevice::MakeMulticastAddress (Ipv4Address multicastGroup) const
{
return GetMulticast ();
}
bool
WimaxNetDevice::IsPointToPoint (void) const
{
return false;
}
bool
WimaxNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
{
Mac48Address to = Mac48Address::ConvertFrom (dest);
LlcSnapHeader llcHdr;
llcHdr.SetType (protocolNumber);
packet->AddHeader (llcHdr);
m_traceTx (packet, to);
return DoSend (packet, Mac48Address::ConvertFrom (GetAddress ()), to, protocolNumber);
}
void
WimaxNetDevice::SetNode (Ptr<Node> node)
{
m_node = node;
}
Ptr<Node>
WimaxNetDevice::GetNode (void) const
{
return m_node;
}
bool
WimaxNetDevice::NeedsArp (void) const
{
return false;
/*
* Modified by Mohamed Amine ISMAIL.
* see "Transmission of IPv4 packets over IEEE 802.16's IP Convergence
* Sublayer draft-ietf-16ng-ipv4-over-802-dot-16-ipcs-04.txt" section
* 5.2
*/
}
void
WimaxNetDevice::SetReceiveCallback (ReceiveCallback cb)
{
m_forwardUp = cb;
}
void
WimaxNetDevice::ForwardUp (Ptr<Packet> packet, const Mac48Address &source, const Mac48Address &dest)
{
m_traceRx (packet, source);
LlcSnapHeader llc;
packet->RemoveHeader (llc);
m_forwardUp (this, packet, llc.GetType (), source);
}
void
WimaxNetDevice::Attach (Ptr<WimaxChannel> channel)
{
m_phy->Attach (channel);
}
void
WimaxNetDevice::SetPhy (Ptr<WimaxPhy> phy)
{
m_phy = phy;
}
Ptr<WimaxPhy>
WimaxNetDevice::GetPhy (void) const
{
return m_phy;
}
void
WimaxNetDevice::SetChannel (Ptr<WimaxChannel> channel)
{
if (m_phy != 0)
{
m_phy->Attach (channel);
}
}
uint64_t
WimaxNetDevice::GetChannel (uint8_t index) const
{
return m_dlChannels.at (index);
}
void
WimaxNetDevice::SetNrFrames (uint32_t nrFrames)
{
m_nrFrames = nrFrames;
}
uint32_t WimaxNetDevice::GetNrFrames (void) const
{
return m_nrFrames;
}
void
WimaxNetDevice::SetAddress (Address address)
{
m_address = Mac48Address::ConvertFrom (address);
}
void
WimaxNetDevice::SetMacAddress (Mac48Address address)
{
m_address = address;
}
Address
WimaxNetDevice::GetAddress (void) const
{
return m_address;
}
Mac48Address
WimaxNetDevice::GetMacAddress (void) const
{
return m_address;
}
void
WimaxNetDevice::SetState (uint8_t state)
{
m_state = state;
}
uint8_t
WimaxNetDevice::GetState (void) const
{
return m_state;
}
Ptr<WimaxConnection>
WimaxNetDevice::GetInitialRangingConnection (void) const
{
return m_initialRangingConnection;
}
Ptr<WimaxConnection>
WimaxNetDevice::GetBroadcastConnection (void) const
{
return m_broadcastConnection;
}
void
WimaxNetDevice::SetCurrentDcd (Dcd dcd)
{
m_currentDcd = dcd;
}
Dcd
WimaxNetDevice::GetCurrentDcd (void) const
{
return m_currentDcd;
}
void
WimaxNetDevice::SetCurrentUcd (Ucd ucd)
{
m_currentUcd = ucd;
}
Ucd
WimaxNetDevice::GetCurrentUcd (void) const
{
return m_currentUcd;
}
Ptr<ConnectionManager>
WimaxNetDevice::GetConnectionManager (void) const
{
return m_connectionManager;
}
void
WimaxNetDevice::SetConnectionManager (Ptr<ConnectionManager> cm)
{
m_connectionManager = cm;
}
Ptr<BurstProfileManager>
WimaxNetDevice::GetBurstProfileManager (void) const
{
return m_burstProfileManager;
}
void
WimaxNetDevice::SetBurstProfileManager (Ptr<BurstProfileManager> bpm)
{
m_burstProfileManager = bpm;
}
Ptr<BandwidthManager>
WimaxNetDevice::GetBandwidthManager (void) const
{
return m_bandwidthManager;
}
void
WimaxNetDevice::SetBandwidthManager (Ptr<BandwidthManager> bwm)
{
m_bandwidthManager = bwm;
}
void
WimaxNetDevice::CreateDefaultConnections (void)
{
m_initialRangingConnection = CreateObject<WimaxConnection> (Cid::InitialRanging (), Cid::INITIAL_RANGING);
m_broadcastConnection = CreateObject<WimaxConnection> (Cid::Broadcast (), Cid::BROADCAST);
}
void
WimaxNetDevice::Receive (Ptr<const PacketBurst> burst)
{
NS_LOG_DEBUG ("WimaxNetDevice::Receive, station = " << GetMacAddress ());
Ptr<PacketBurst> b = burst->Copy ();
for (std::list<Ptr<Packet> >::const_iterator iter = b->Begin (); iter != b->End (); ++iter)
{
Ptr<Packet> packet = *iter;
DoReceive (packet);
}
}
Ptr<WimaxChannel>
WimaxNetDevice::DoGetChannel (void) const
{
return m_phy->GetChannel ();
}
void
WimaxNetDevice::SetReceiveCallback (void)
{
m_phy->SetReceiveCallback (MakeCallback (&WimaxNetDevice::Receive, this));
}
bool
WimaxNetDevice::SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber)
{
Mac48Address from = Mac48Address::ConvertFrom (source);
Mac48Address to = Mac48Address::ConvertFrom (dest);
LlcSnapHeader llcHdr;
llcHdr.SetType (protocolNumber);
packet->AddHeader (llcHdr);
m_traceTx (packet, to);
return DoSend (packet, from, to, protocolNumber);
}
void
WimaxNetDevice::SetPromiscReceiveCallback (PromiscReceiveCallback cb)
{
m_promiscRx = cb;
}
bool
WimaxNetDevice::IsPromisc (void)
{
return !(m_promiscRx.IsNull ());
}
void
WimaxNetDevice::NotifyPromiscTrace (Ptr<Packet> p)
{
// m_promiscRx(p);
}
bool
WimaxNetDevice::SupportsSendFrom (void) const
{
return false;
}
void
WimaxNetDevice::ForwardDown (Ptr<PacketBurst> burst, WimaxPhy::ModulationType modulationType)
{
SendParams * params = new OfdmSendParams (burst, modulationType, m_direction);
m_phy->Send (params);
delete params;
}
void
WimaxNetDevice::InitializeChannels (void)
{
// initializing vector of channels (or frequencies)
// Values according to WirelessMAN-OFDM RF profile for 10 MHz channelization
// Section 12.3.3.1 from IEEE 802.16-2004 standard
// profR10_3 :
// channels: 5000 + n ⋅ 5 MHz, ∀n ∈ { 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167 }
// from a range 5GHz to 6GHz, according to Section 8.5.1.
uint64_t frequency = 5000;
for (uint8_t i = 0; i < 200; i++)
{
m_dlChannels.push_back (frequency);
frequency += 5;
}
}
bool
WimaxNetDevice::IsBridge (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return false;
}
Address
WimaxNetDevice::GetMulticast (Ipv4Address multicastGroup) const
{
NS_LOG_FUNCTION (multicastGroup);
Mac48Address ad = Mac48Address::GetMulticast (multicastGroup);
//
// Implicit conversion (operator Address ()) is defined for Mac48Address, so
// use it by just returning the EUI-48 address which is automagically converted
// to an Address.
//
NS_LOG_LOGIC ("multicast address is " << ad);
return ad;
}
Address
WimaxNetDevice::GetMulticast (Ipv6Address addr) const
{
Mac48Address ad = Mac48Address::GetMulticast (addr);
NS_LOG_LOGIC ("MAC IPv6 multicast address is " << ad);
return ad;
}
void
WimaxNetDevice::AddLinkChangeCallback (Callback<void> callback)
{
/* TODO: Add a callback invoked whenever the link
* status changes to UP. This callback is typically used
* by the IP/ARP layer to flush the ARP cache and by IPv6 stack
* to flush NDISC cache whenever the link goes up.
*/
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-net-device.cc | C++ | gpl2 | 14,369 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#ifndef WIMAX_TLV_H
#define WIMAX_TLV_H
#define WIMAX_TLV_EXTENDED_LENGTH_MASK 0x80
#include "ns3/ipv4-address.h"
#include <stdlib.h>
#include "ns3/log.h"
#include "ns3/assert.h"
#include "ns3/uinteger.h"
#include "ns3/header.h"
#include <vector>
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
*/
class TlvValue
{
public:
virtual ~TlvValue ()
{
}
virtual uint32_t GetSerializedSize (void) const = 0;
virtual void Serialize (Buffer::Iterator start) const = 0;
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLen ) = 0;
virtual TlvValue * Copy (void) const = 0;
private:
};
// =============================================================================
/**
* \ingroup wimax
* \brief This class implements the Type-Len-Value structure channel encodings as described by "IEEE Standard for
* Local and metropolitan area networks Part 16: Air Interface for Fixed Broadband Wireless Access Systems"
* 11. TLV encodings, page 645
*
*/
class Tlv : public Header
{
public:
enum CommonTypes
{
HMAC_TUPLE = 149,
MAC_VERSION_ENCODING = 148,
CURRENT_TRANSMIT_POWER = 147,
DOWNLINK_SERVICE_FLOW = 146,
UPLINK_SERVICE_FLOW = 145,
VENDOR_ID_EMCODING = 144,
VENDOR_SPECIFIC_INFORMATION = 143
};
Tlv (uint8_t type, uint64_t length, const TlvValue & value);
Tlv (void);
~Tlv (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);
uint8_t GetSizeOfLen (void) const;
uint8_t GetType (void) const;
uint64_t GetLength (void) const;
TlvValue* PeekValue (void);
Tlv * Copy (void) const;
TlvValue * CopyValue (void) const;
Tlv &operator = (Tlv const& o);
Tlv (const Tlv & tlv);
private:
uint8_t m_type;
uint64_t m_length;
TlvValue * m_value;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class U8TlvValue : public TlvValue
{
public:
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);
uint32_t Deserialize (Buffer::Iterator start);
uint8_t GetValue (void) const;
U8TlvValue * Copy (void) const;
private:
uint8_t m_value;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class U16TlvValue : public TlvValue
{
public:
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);
uint32_t Deserialize (Buffer::Iterator start);
uint16_t GetValue (void) const;
virtual U16TlvValue * Copy (void) const;
private:
uint16_t m_value;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class U32TlvValue : public TlvValue
{
public:
U32TlvValue (uint32_t value);
U32TlvValue ();
~U32TlvValue (void);
virtual uint32_t GetSerializedSize (void) const;
virtual void Serialize (Buffer::Iterator start) const;
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLen);
uint32_t Deserialize (Buffer::Iterator start);
uint32_t GetValue (void) const;
virtual U32TlvValue * Copy (void) const;
private:
uint32_t m_value;
};
// ==============================================================================
/**
* \ingroup wimax
* \brief this class is used to implement a vector of values in one tlv value field
*/
class VectorTlvValue : public TlvValue
{
public:
typedef std::vector<Tlv*>::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;
Iterator Begin () const;
Iterator End () const;
void Add (const Tlv & val);
virtual VectorTlvValue * Copy (void) const = 0;
private:
std::vector<Tlv*> * m_tlvList;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class SfVectorTlvValue : public VectorTlvValue
{
public:
enum Type
{
SFID = 1,
CID = 2,
Service_Class_Name = 3,
reserved1 = 4,
QoS_Parameter_Set_Type = 5,
Traffic_Priority = 6,
Maximum_Sustained_Traffic_Rate = 7,
Maximum_Traffic_Burst = 8,
Minimum_Reserved_Traffic_Rate = 9,
Minimum_Tolerable_Traffic_Rate = 10,
Service_Flow_Scheduling_Type = 11,
Request_Transmission_Policy = 12,
Tolerated_Jitter = 13,
Maximum_Latency = 14,
Fixed_length_versus_Variable_length_SDU_Indicator = 15,
SDU_Size = 16,
Target_SAID = 17,
ARQ_Enable = 18,
ARQ_WINDOW_SIZE = 19,
ARQ_RETRY_TIMEOUT_Transmitter_Delay = 20,
ARQ_RETRY_TIMEOUT_Receiver_Delay = 21,
ARQ_BLOCK_LIFETIME = 22,
ARQ_SYNC_LOSS = 23,
ARQ_DELIVER_IN_ORDER = 24,
ARQ_PURGE_TIMEOUT = 25,
ARQ_BLOCK_SIZE = 26,
reserved2 = 27,
CS_Specification = 28,
IPV4_CS_Parameters = 100
};
SfVectorTlvValue ();
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength);
virtual SfVectorTlvValue * Copy (void) const;
};
// ==============================================================================
/**
* \ingroup wimax
* \brief this class implements the convergence sub-layer descriptor as a tlv vector
*/
class CsParamVectorTlvValue : public VectorTlvValue
{
public:
enum Type
{
Classifier_DSC_Action = 1,
Packet_Classification_Rule = 3,
};
CsParamVectorTlvValue ();
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength);
virtual CsParamVectorTlvValue * Copy (void) const;
private:
};
// ==============================================================================
/**
* \ingroup wimax
* \brief this class implements the classifier descriptor as a tlv vector
*/
class ClassificationRuleVectorTlvValue : public VectorTlvValue
{
public:
enum ClassificationRuleTlvType
{
Priority = 1,
ToS = 2,
Protocol = 3,
IP_src = 4,
IP_dst = 5,
Port_src = 6,
Port_dst = 7,
Index = 14,
};
ClassificationRuleVectorTlvValue ();
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength);
virtual ClassificationRuleVectorTlvValue * Copy (void) const;
private:
};
// ==============================================================================
/**
* \ingroup wimax
*/
class TosTlvValue : public TlvValue
{
public:
TosTlvValue ();
TosTlvValue (uint8_t, uint8_t, uint8_t);
~TosTlvValue ();
virtual uint32_t GetSerializedSize (void) const;
virtual void Serialize (Buffer::Iterator start) const;
virtual uint32_t Deserialize (Buffer::Iterator start, uint64_t valueLength);
uint8_t GetLow (void) const;
uint8_t GetHigh (void) const;
uint8_t GetMask (void) const;
virtual TosTlvValue * Copy () const;
private:
uint8_t m_low;
uint8_t m_high;
uint8_t m_mask;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class PortRangeTlvValue : public TlvValue
{
public:
struct PortRange
{
uint16_t PortLow;
uint16_t PortHigh;
};
typedef std::vector<struct PortRange>::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);
void Add (uint16_t portLow, uint16_t portHigh);
Iterator Begin () const;
Iterator End () const;
virtual PortRangeTlvValue * Copy (void) const;
private:
std::vector<struct PortRange> * m_portRange;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class ProtocolTlvValue : public TlvValue
{
public:
ProtocolTlvValue ();
~ProtocolTlvValue ();
typedef std::vector<uint8_t>::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);
Iterator Begin () const;
Iterator End () const;
virtual ProtocolTlvValue * Copy (void) const;
private:
std::vector<uint8_t> * m_protocol;
};
// ==============================================================================
/**
* \ingroup wimax
*/
class Ipv4AddressTlvValue : public TlvValue
{
public:
struct ipv4Addr
{
Ipv4Address Address;
Ipv4Mask Mask;
};
typedef std::vector<struct ipv4Addr>::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);
void Add (Ipv4Address address, Ipv4Mask Mask);
Iterator Begin () const;
Iterator End () const;
virtual Ipv4AddressTlvValue * Copy () const;
private:
std::vector<struct ipv4Addr> * m_ipv4Addr;
};
}
#endif /* WIMAX_TLV_H */
| zy901002-gpsr | src/wimax/model/wimax-tlv.h | C++ | gpl2 | 10,474 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef WIMAX_CONNECTION_H
#define WIMAX_CONNECTION_H
#include <stdint.h>
#include <ostream>
#include "cid.h"
#include "wimax-mac-header.h"
#include "wimax-mac-queue.h"
#include "ns3/object.h"
#include "service-flow.h"
namespace ns3 {
class ServiceFlow;
class Cid;
/**
* \ingroup wimax
*/
class WimaxConnection : public Object
{
public:
static TypeId GetTypeId (void);
WimaxConnection (Cid cid, enum Cid::Type type);
~WimaxConnection (void);
Cid GetCid (void) const;
enum Cid::Type GetType (void) const;
/**
* \return the queue of the connection
*/
Ptr<WimaxMacQueue> GetQueue (void) const;
/**
* \brief set the service flow associated to this connection
* \param serviceFlow The service flow to be associated to this connection
*/
void SetServiceFlow (ServiceFlow *serviceFlow);
/**
* \return the service flow associated to this connection
*/
ServiceFlow* GetServiceFlow (void) const;
// wrapper functions
/**
* \return the scheduling type of this connection
*/
uint8_t GetSchedulingType (void) const;
/**
* \brief enqueue a packet in the queue of the connection
* \param packet the packet to be enqueued
* \param hdrType the header type of the packet
* \param hdr the header of the packet
*/
bool Enqueue (Ptr<Packet> 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
*/
Ptr<Packet> Dequeue (MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC);
Ptr<Packet> Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte);
/**
* \return true if the connection has at least one packet in its queue, false otherwise
*/
bool HasPackets (void) const;
/**
* \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
*/
bool HasPackets (MacHeaderType::HeaderType packetType) const;
std::string GetTypeStr (void) const;
// Definition of Fragments Queue data type
typedef std::list<Ptr<const Packet> > FragmentsQueue;
/**
* \brief get a queue of received fragments
*/
const FragmentsQueue GetFragmentsQueue (void) const;
/**
* \brief enqueue a received packet (that is a fragment) into the fragments queue
* \param fragment received fragment
*/
void FragmentEnqueue (Ptr<const Packet> fragment);
/**
* \brief delete all enqueued fragments
*/
void ClearFragmentsQueue (void);
private:
virtual void DoDispose (void);
Cid m_cid;
enum Cid::Type m_cidType;
Ptr<WimaxMacQueue> m_queue;
ServiceFlow *m_serviceFlow;
// FragmentsQueue stores all received fragments
FragmentsQueue m_fragmentsQueue;
};
} // namespace ns3
#endif /* WIMAX_CONNECTION_H */
| zy901002-gpsr | src/wimax/model/wimax-connection.h | C++ | gpl2 | 3,785 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef BANDWIDTH_MANAGER_H
#define BANDWIDTH_MANAGER_H
#include <stdint.h>
#include "wimax-net-device.h"
#include "ul-job.h"
#include "bs-uplink-scheduler.h"
#include "cid.h"
/*
The same bandwidth manager class serves both for BS and SS though some functions are exclusive to only one of them.
*/
namespace ns3 {
class SSRecord;
class ServiceFlow;
class UlJob;
class UplinkScheduler;
/**
* \ingroup wimax
* \brief This class manage the bandwidth request and grant mechanism.
* The bandwidth request and grant mechanism is supported by the Bandwidth
* Manager. Both BS and SS maintain a bandwidth manager. Furthermore BS's
* bandwidth manager works together with the uplink scheduler to determine
* total bandwidth available and allocation size for each service flow.
* Bandwidth request mechanism is a key feature of the WiMAX scheduler
* since all three non-UGS services explicitly request for bandwidth by
* sending a bandwidth request to BS.
*/
class BandwidthManager : public Object
{
public:
static TypeId GetTypeId (void);
BandwidthManager (Ptr<WimaxNetDevice> device);
~BandwidthManager (void);
void DoDispose (void);
uint32_t CalculateAllocationSize (const SSRecord *ssRecord, const ServiceFlow *serviceFlow);
ServiceFlow* SelectFlowForRequest (uint32_t &bytesToRequest);
void SendBandwidthRequest (uint8_t uiuc, uint16_t allocationSize);
void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr);
void SetSubframeRatio (void);
uint32_t GetSymbolsPerFrameAllocated (void);
private:
BandwidthManager (const BandwidthManager &);
BandwidthManager& operator= (const BandwidthManager &);
Ptr<WimaxNetDevice> m_device;
uint16_t m_nrBwReqsSent;
};
} // namespace ns3
#endif /* BANDWIDTH_MANAGER_H */
| zy901002-gpsr | src/wimax/model/bandwidth-manager.h | C++ | gpl2 | 2,726 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef SNR_TO_BLOCK_ERROR_RATE_RECORD_H
#define SNR_TO_BLOCK_ERROR_RATE_RECORD_H
namespace ns3 {
/**
* \ingroup wimax
* \brief This class represents a record (handled by SnrToBlockErrorRate manager) that keeps a mapping between
* an SNR value and its corresponding (1) Bit Error Rate, (2) Block Error Rate, (3) Standard deviation, (4 and 5)
* confidence interval.
*
*/
class SNRToBlockErrorRateRecord
{
public:
/**
* \brief creates a record and sets its values
* \param snrValue The SNR value
* \param bitErrorRate the BER
* \param BlockErrorRate the BlcER
* \param sigma2 the standard deviation
* \param I1 the lower boundary of the confidence interval
* \param I2 the upper boundary of the confidence interval
*/
SNRToBlockErrorRateRecord (double snrValue, double bitErrorRate,
double BlockErrorRate, double sigma2, double I1, double I2);
~SNRToBlockErrorRateRecord (void);
/**
* \return the SNR value
*/
double GetSNRValue (void);
/**
* \return the BER value
*/
double GetBitErrorRate (void);
/**
* \return the BlcER value
*/
double GetBlockErrorRate (void);
/**
* \return the standard deviation
*/
double GetSigma2 (void);
/**
* \return the lower boundary of the confidence interval
*/
double GetI1 (void);
/**
* \return the upper boundary of the confidence interval
*/
double GetI2 (void);
/**
* \brief copy a record
* \return a copy of this record
*/
SNRToBlockErrorRateRecord *
Copy ();
/**
* \brief set the snr value
*/
void SetSNRValue (double);
/**
* \brief set the BER value
*/
void SetBitErrorRate (double);
/**
* \brief set the BlcER value
*/
void SetBlockErrorRate (double);
/**
* \brief set the lower boundary of the confidence interval
*/
void SetI1 (double);
/**
* \brief set the upper boundary of the confidence interval
*/
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
};
}
#endif /* SNR_TO_BLOCK_ERROR_RATE_RECORD_H */
| zy901002-gpsr | src/wimax/model/snr-to-block-error-rate-record.h | C++ | gpl2 | 3,138 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Giuseppe Piro <g.piro@poliba.it>
*/
#ifndef UPLINK_SCHEDULER_RTPS_H
#define UPLINK_SCHEDULER_RTPS_H
#include <stdint.h>
#include "ul-mac-messages.h"
#include "ns3/nstime.h"
#include "wimax-phy.h"
#include "bs-uplink-scheduler.h"
namespace ns3 {
class BaseStationNetDevice;
class SSRecord;
class ServiceFlow;
/**
* \ingroup wimax
* \brief This class implements a simple uplink scheduler for rtPS flows.
*
* The UL-rtPS-Scheduler work in this way:
* At the beginning of the UL sub-frame some symbols are allocated
* to the rangingInterval Messages, DSA Messages, UGS grants and
* UGS/rtPS/nrtPS/BE poll.
* Then, the remaining available symbols are allocated to the all
* rtPS flows according to their requestedBandwidth.
* The bandwidth saturation control has been implemented to
* redistribute the resource if the sum of requestedBandwidth exceed
* the available bandwidth.
* At the end, if there are some free symbols, their are allocated to
* nrtPS and BE Connections.
*/
class UplinkSchedulerRtps : public UplinkScheduler
{
public:
UplinkSchedulerRtps ();
UplinkSchedulerRtps (Ptr<BaseStationNetDevice> bs);
~UplinkSchedulerRtps (void);
static TypeId GetTypeId (void);
std::list<OfdmUlMapIe> GetUplinkAllocations (void) const;
/**
* Determines if channel descriptors sent in the current frame are
* required to be updated
*/
void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&);
uint32_t CalculateAllocationStartTime (void);
void AddUplinkAllocation (OfdmUlMapIe &ulMapIe,
const uint32_t &allocationSize,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
/**
* \brief Schedule function.
*/
void Schedule (void);
void ServiceUnsolicitedGrants (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
void ServiceBandwidthRequests (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
bool ServiceBandwidthRequests (ServiceFlow *serviceFlow,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
/**
* \brief Uplink Scheduler for rtPS connections.
*
* \param symbolsToAllocation symbols to allocation for UpLink Subframe
* \param availableSymbols available symbols for rtPS flows
*
* This method represent the UL Scheduler for rtPS connections.
* The scheduler is designed to serve all rtPS connections that
* have at least one packet to transmit, every UL Subframe.
* The methos selects all rtPS connection that have al least one
* packet to transmit. To each rtPS connections are allocated,
* at the beginning, the bandwidth to transmit a quota of data equal
* to (RequestedBandwidth - GrantedBandwidth).
* If the sum of all pre-allocated bandwidth exceed the available
* symbols for rtPS connections, the Channel Saturation Control function
* is called to redistribute the available bandwidth.
*/
void ULSchedulerRTPSConnection (uint32_t &symbolsToAllocation, uint32_t &availableSymbols);
void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols);
void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow);
void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr);
void InitOnce (void);
void OnSetRequestedBandwidth (ServiceFlowRecord *sfr);
private:
std::list<OfdmUlMapIe> m_uplinkAllocations;
};
} // namespace ns3
#endif /* UPLINK_SCHEDULER_RTPS_H */
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler-rtps.h | C++ | gpl2 | 5,153 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef DCD_CHANNEL_ENCODINGS_H
#define DCD_CHANNEL_ENCODINGS_H
#include <stdint.h>
#include "ns3/buffer.h"
#include <list>
namespace ns3 {
/**
* \ingroup wimax
* \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
*
*/
class DcdChannelEncodings
{
public:
DcdChannelEncodings (void);
virtual ~DcdChannelEncodings (void);
void SetBsEirp (uint16_t bs_eirp);
void SetEirxPIrMax (uint16_t rss_ir_max);
void SetFrequency (uint32_t frequency);
uint16_t GetBsEirp (void) const;
uint16_t GetEirxPIrMax (void) const;
uint32_t GetFrequency (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
Buffer::Iterator Read (Buffer::Iterator start);
private:
virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const = 0;
virtual Buffer::Iterator DoRead (Buffer::Iterator start) = 0;
uint16_t m_bsEirp;
uint16_t m_eirXPIrMax;
uint32_t m_frequency;
};
} // namespace ns3
#endif /* DCD_CHANNEL_ENCODINGS_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_DCD_CHANNEL_ENCODINGS_H
#define OFDM_DCD_CHANNEL_ENCODINGS_H
#include <stdint.h>
#include "ns3/mac48-address.h"
namespace ns3 {
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);
void SetChannelNr (uint8_t channelNr);
void SetTtg (uint8_t ttg);
void SetRtg (uint8_t rtg);
void SetBaseStationId (Mac48Address baseStationId);
void SetFrameDurationCode (uint8_t frameDurationCode);
void SetFrameNumber (uint32_t frameNumber);
uint8_t GetChannelNr (void) const;
uint8_t GetTtg (void) const;
uint8_t GetRtg (void) const;
Mac48Address GetBaseStationId (void) const;
uint8_t GetFrameDurationCode (void) const;
uint32_t GetFrameNumber (void) const;
uint16_t GetSize (void) const;
private:
virtual Buffer::Iterator DoWrite (Buffer::Iterator start) const;
virtual Buffer::Iterator DoRead (Buffer::Iterator start);
uint8_t m_channelNr;
uint8_t m_ttg;
uint8_t m_rtg;
uint32_t m_chnlSwitchFrameNr;
Mac48Address m_baseStationId;
uint8_t m_frameDurationCode;
uint32_t m_frameNumber;
};
} // namespace ns3
#endif /* OFDM_DCD_CHANNEL_ENCODINGS_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_DL_BURST_PROFILE_H
#define OFDM_DL_BURST_PROFILE_H
#include <stdint.h>
#include "ns3/buffer.h"
namespace ns3 {
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:
enum Diuc
{
DIUC_STC_ZONE = 0,
DIUC_BURST_PROFILE_1,
DIUC_BURST_PROFILE_2,
DIUC_BURST_PROFILE_3,
DIUC_BURST_PROFILE_4,
DIUC_BURST_PROFILE_5,
DIUC_BURST_PROFILE_6,
DIUC_BURST_PROFILE_7,
DIUC_BURST_PROFILE_8,
DIUC_BURST_PROFILE_9,
DIUC_BURST_PROFILE_10,
DIUC_BURST_PROFILE_11,
// 12 is reserved
DIUC_GAP = 13,
DIUC_END_OF_MAP
};
OfdmDlBurstProfile (void);
~OfdmDlBurstProfile (void);
void SetType (uint8_t type);
void SetLength (uint8_t length);
void SetDiuc (uint8_t diuc);
void SetFecCodeType (uint8_t fecCodeType);
uint8_t GetType (void) const;
uint8_t GetLength (void) const;
uint8_t GetDiuc (void) const;
uint8_t GetFecCodeType (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
Buffer::Iterator Read (Buffer::Iterator start);
private:
uint8_t m_type;
uint8_t m_length;
uint8_t m_diuc;
// TLV Encoded information
uint8_t m_fecCodeType;
};
} // namespace ns3
#endif /* OFDM_DL_BURST_PROFILE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef DCD_H
#define DCD_H
#include <stdint.h>
#include "ns3/header.h"
#include <vector>
namespace ns3 {
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);
void SetConfigurationChangeCount (uint8_t configurationChangeCount);
void SetChannelEncodings (OfdmDcdChannelEncodings channelEncodings);
void AddDlBurstProfile (OfdmDlBurstProfile dlBurstProfile);
void SetNrDlBurstProfiles (uint8_t nrDlBurstProfiles);
uint8_t GetConfigurationChangeCount (void) const;
OfdmDcdChannelEncodings GetChannelEncodings (void) const;
std::vector<OfdmDlBurstProfile> GetDlBurstProfiles (void) const;
uint8_t GetNrDlBurstProfiles (void) const;
std::string GetName (void) const;
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);
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<OfdmDlBurstProfile> m_dlBurstProfiles; // vector of download burst profiles
uint8_t m_nrDlBurstProfiles;
};
} // namespace ns3
#endif /* DCD_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef OFDM_DL_MAP_IE_H
#define OFDM_DL_MAP_IE_H
#include <stdint.h>
#include "cid.h"
namespace ns3 {
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);
void SetCid (Cid cid);
void SetDiuc (uint8_t diuc);
void SetPreamblePresent (uint8_t preamblePresent);
void SetStartTime (uint16_t startTime);
Cid GetCid (void) const;
uint8_t GetDiuc (void) const;
uint8_t GetPreamblePresent (void) const;
uint16_t GetStartTime (void) const;
uint16_t GetSize (void) const;
Buffer::Iterator Write (Buffer::Iterator start) const;
Buffer::Iterator Read (Buffer::Iterator start);
private:
Cid m_cid;
uint8_t m_diuc;
uint8_t m_preamblePresent;
uint16_t m_startTime;
};
} // namespace ns3
#endif /* OFDM_DL_MAP_IE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef DL_MAP_H
#define DL_MAP_H
#include <stdint.h>
#include <vector>
#include "ns3/header.h"
#include "ns3/mac48-address.h"
namespace ns3 {
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);
void SetDcdCount (uint8_t dcdCount);
void SetBaseStationId (Mac48Address baseStationID);
void AddDlMapElement (OfdmDlMapIe dlMapElement);
uint8_t GetDcdCount (void) const;
Mac48Address GetBaseStationId (void) const;
std::list<OfdmDlMapIe> GetDlMapElements (void) const;
std::string GetName (void) const;
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);
private:
uint8_t m_dcdCount;
Mac48Address m_baseStationId;
std::list<OfdmDlMapIe> m_dlMapElements;
// m_paddingNibble; //fields to be implemented later on:
};
} // namespace ns3
#endif /* DL_MAP_H */
| zy901002-gpsr | src/wimax/model/dl-mac-messages.h | C++ | gpl2 | 9,588 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef CONNECTION_IDENTIFIER_FACTORY_H
#define CONNECTION_IDENTIFIER_FACTORY_H
#include <stdint.h>
#include "cid.h"
namespace ns3 {
/**
* \ingroup wimax
* This class is used exclusively by the BS to allocate CIDs to new connections.
* This class uses the definitions from Table 345 in ieee-802.16-2004 to
* allocate cids in different integer ranges according to their type.
* The relative allocation of the ranges is controlled by the parameter 'm'
* introduced in the above-mentionned table.
*
* Note: The current implementation merely allocates cids sequentially from
* the start of the allowed range. A proper implementation would be able
* to recycle cids from previous dead connections and should instead look
* at a bitmap of free cids. Some other day :)
*/
class CidFactory
{
public:
/**
* Create a cid factory with a default value for m of 0x5500.
*/
CidFactory (void);
/**
* \brief This function returns the next basic CID.
* \returns the next basic CID.
*/
Cid AllocateBasic (void);
/**
* \brief This function returns the next primary basic CID.
* \returns the next primary CID.
*/
Cid AllocatePrimary (void);
/**
* \brief This function returns the next Transport (or Secondary) CID.
* \returns the next Transport (or Secondary) CID.
*/
Cid AllocateTransportOrSecondary (void);
/**
* \brief This function returns the next Multicast CID.
* \returns the next Multicast CID.
*/
Cid AllocateMulticast (void);
Cid Allocate (enum Cid::Type type);
bool IsTransport (Cid cid) const;
bool IsPrimary (Cid cid) const;
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.
*/
void FreeCid (Cid cid);
private:
uint16_t m_m;
uint16_t m_basicIdentifier;
uint16_t m_primaryIdentifier;
uint16_t m_transportOrSecondaryIdentifier;
uint16_t m_multicastPollingIdentifier;
};
} // namespace ns3
#endif /* CONNECTION_IDENTIFIER_FACTORY_H */
| zy901002-gpsr | src/wimax/model/cid-factory.h | C++ | gpl2 | 2,999 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef SERVICE_FLOW_MANAGER_H
#define SERVICE_FLOW_MANAGER_H
#include <stdint.h>
#include "ns3/event-id.h"
#include "mac-messages.h"
#include "ns3/buffer.h"
namespace ns3 {
class Packet;
class ServiceFlow;
class WimaxNetDevice;
class SSRecord;
class WimaxConnection;
/**
* \ingroup wimax
* The same service flow manager class serves both for BS and SS though some functions are exclusive to only one of them.
*/
class ServiceFlowManager : public Object
{
public:
enum ConfirmationCode // as per Table 384 (not all codes implemented)
{
CONFIRMATION_CODE_SUCCESS, CONFIRMATION_CODE_REJECT
};
static TypeId GetTypeId (void);
ServiceFlowManager ();
~ServiceFlowManager (void);
void DoDispose (void);
void AddServiceFlow (ServiceFlow * serviceFlow);
ServiceFlow* GetServiceFlow (uint32_t sfid) const;
ServiceFlow* GetServiceFlow (Cid cid) const;
std::vector<ServiceFlow*> GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const;
/**
* \return true if all service flows are allocated, false otherwise
*/
bool AreServiceFlowsAllocated ();
/**
* \param serviceFlows the list of the service flows to be checked
* \return true if all service flows are allocated, false otherwise
*/
bool AreServiceFlowsAllocated (std::vector<ServiceFlow*>* serviceFlows);
/**
* \param serviceFlows the list of the service flows to be checked
* \return true if all service flows are allocated, false otherwise
*/
bool AreServiceFlowsAllocated (std::vector<ServiceFlow*> serviceFlows);
/**
* \return the next service flow to be allocated
*/
ServiceFlow* GetNextServiceFlowToAllocate ();
/**
* \return the number of all service flows
*/
uint32_t GetNrServiceFlows (void) const;
/**
*\param SrcAddress the source ip address
*\param DstAddress the destination ip address
*\param SrcPort the source port
*\param DstPort the destination port
*\param Proto the protocol
*\param dir the direction of the service flow
*\return the service flow to which this ip flow is associated
*/
ServiceFlow* DoClassify (Ipv4Address SrcAddress,
Ipv4Address DstAddress,
uint16_t SrcPort,
uint16_t DstPort,
uint8_t Proto,
ServiceFlow::Direction dir) const;
private:
std::vector<ServiceFlow*> * m_serviceFlows;
};
} // namespace ns3
#endif /* SERVICE_FLOW_MANAGER_H */
| zy901002-gpsr | src/wimax/model/service-flow-manager.h | C++ | gpl2 | 3,396 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "ns3/node.h"
#include "wimax-net-device.h"
#include "wimax-phy.h"
#include "wimax-channel.h"
#include "ns3/packet-burst.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/pointer.h"
#include "ns3/uinteger.h"
#include "ns3/double.h"
NS_LOG_COMPONENT_DEFINE ("WimaxPhy");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxPhy);
TypeId WimaxPhy::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxPhy").SetParent<Object> ()
.AddAttribute ("Channel",
"Wimax channel",
PointerValue (),
MakePointerAccessor (&WimaxPhy::GetChannel, &WimaxPhy::Attach),
MakePointerChecker<WimaxChannel> ())
.AddAttribute ("FrameDuration",
"The frame duration in seconds.",
TimeValue (Seconds (0.01)),
MakeTimeAccessor (&WimaxPhy::SetFrameDuration, &WimaxPhy::GetFrameDurationSec),
MakeTimeChecker ())
.AddAttribute ("Frequency",
"The central frequency in KHz.",
UintegerValue (5000000),
MakeUintegerAccessor (&WimaxPhy::SetFrequency, &WimaxPhy::GetFrequency),
MakeUintegerChecker<uint32_t> (1000000, 11000000))
.AddAttribute ("Bandwidth",
"The channel bandwidth in Hz.",
UintegerValue (10000000),
MakeUintegerAccessor (&WimaxPhy::SetChannelBandwidth, &WimaxPhy::GetChannelBandwidth),
MakeUintegerChecker<uint32_t> (5000000, 30000000))
;
return tid;
}
WimaxPhy::WimaxPhy (void)
: m_state (PHY_STATE_IDLE),
m_nrCarriers (0),
m_frameDuration (Seconds (0.01)),
m_frequency (5000000),
m_channelBandwidth (10000000),
m_psDuration (Seconds (0)),
m_symbolDuration (Seconds (0)),
m_psPerSymbol (0),
m_psPerFrame (0),
m_symbolsPerFrame (0)
{
m_mobility = 0;
m_duplex = 0;
m_txFrequency = 0;
m_rxFrequency = 0;
}
WimaxPhy::~WimaxPhy (void)
{
}
void
WimaxPhy::DoDispose (void)
{
m_device = 0;
m_channel = 0;
}
void
WimaxPhy::Attach (Ptr<WimaxChannel> channel)
{
m_channel = channel;
DoAttach (channel);
}
Ptr<WimaxChannel>
WimaxPhy::GetChannel (void) const
{
return m_channel;
}
void
WimaxPhy::SetDevice (Ptr<WimaxNetDevice> device)
{
m_device = device;
}
Ptr<NetDevice>
WimaxPhy::GetDevice (void) const
{
return m_device;
}
void
WimaxPhy::StartScanning (uint64_t frequency, Time timeout, Callback<void, bool, uint64_t> callback)
{
NS_ASSERT_MSG (m_state == PHY_STATE_IDLE || m_state == PHY_STATE_SCANNING,
"Error while scanning: The PHY state should be PHY_STATE_SCANNING or PHY_STATE_IDLE");
m_state = PHY_STATE_SCANNING;
m_scanningFrequency = frequency;
m_dlChnlSrchTimeoutEvent = Simulator::Schedule (timeout, &WimaxPhy::EndScanning, this);
m_scanningCallback = callback;
}
void
WimaxPhy::EndScanning (void)
{
m_scanningCallback (false, m_scanningFrequency);
}
void
WimaxPhy::SetReceiveCallback (Callback<void, Ptr<const PacketBurst> > callback)
{
m_rxCallback = callback;
}
Callback<void, Ptr<const PacketBurst> >
WimaxPhy::GetReceiveCallback (void) const
{
return m_rxCallback;
}
void
WimaxPhy::SetDuplex (uint64_t rxFrequency, uint64_t txFrequency)
{
m_txFrequency = txFrequency;
m_rxFrequency = rxFrequency;
}
void
WimaxPhy::SetSimplex (uint64_t frequency)
{
m_txFrequency = frequency;
m_rxFrequency = frequency;
}
uint64_t
WimaxPhy::GetRxFrequency (void) const
{
return m_rxFrequency;
}
uint64_t
WimaxPhy::GetTxFrequency (void) const
{
return m_txFrequency;
}
uint64_t
WimaxPhy::GetScanningFrequency (void) const
{
return m_scanningFrequency;
}
void
WimaxPhy::SetState (PhyState state)
{
m_state = state;
}
WimaxPhy::PhyState WimaxPhy::GetState (void) const
{
return m_state;
}
bool
WimaxPhy::IsDuplex (void) const
{
return m_duplex;
}
EventId
WimaxPhy::GetChnlSrchTimeoutEvent (void) const
{
return m_dlChnlSrchTimeoutEvent;
}
void
WimaxPhy::SetScanningCallback (void) const
{
m_scanningCallback (true, GetScanningFrequency ());
}
void
WimaxPhy::SetDataRates (void)
{
DoSetDataRates ();
}
uint32_t
WimaxPhy::GetDataRate (WimaxPhy::ModulationType modulationType) const
{
return DoGetDataRate (modulationType);
}
Time
WimaxPhy::GetTransmissionTime (uint32_t size, WimaxPhy::ModulationType modulationType) const
{
return DoGetTransmissionTime (size, modulationType);
}
uint64_t
WimaxPhy::GetNrSymbols (uint32_t size, WimaxPhy::ModulationType modulationType) const
{
return DoGetNrSymbols (size, modulationType);
}
uint64_t
WimaxPhy::GetNrBytes (uint32_t symbols, WimaxPhy::ModulationType modulationType) const
{
return DoGetNrBytes (symbols, modulationType);
}
uint16_t
WimaxPhy::GetTtg (void) const
{
return DoGetTtg ();
}
uint16_t
WimaxPhy::GetRtg (void) const
{
return DoGetRtg ();
}
uint8_t
WimaxPhy::GetFrameDurationCode (void) const
{
return DoGetFrameDurationCode ();
}
Time
WimaxPhy::GetFrameDuration (uint8_t frameDurationCode) const
{
return DoGetFrameDuration (frameDurationCode);
}
/*---------------------PHY parameters functions-----------------------*/
void
WimaxPhy::SetPhyParameters (void)
{
DoSetPhyParameters ();
}
void
WimaxPhy::SetNrCarriers (uint8_t nrCarriers)
{
m_nrCarriers = nrCarriers;
}
uint8_t
WimaxPhy::GetNrCarriers (void) const
{
return m_nrCarriers;
}
void
WimaxPhy::SetFrameDuration (Time frameDuration)
{
m_frameDuration = frameDuration;
}
Time
WimaxPhy::GetFrameDuration (void) const
{
return GetFrameDurationSec ();
}
Time
WimaxPhy::GetFrameDurationSec (void) const
{
return m_frameDuration;
}
void
WimaxPhy::SetFrequency (uint32_t frequency)
{
m_frequency = frequency;
}
uint32_t
WimaxPhy::GetFrequency (void) const
{
return m_frequency;
}
void
WimaxPhy::SetChannelBandwidth (uint32_t channelBandwidth)
{
m_channelBandwidth = channelBandwidth;
}
uint32_t
WimaxPhy::GetChannelBandwidth (void) const
{
return m_channelBandwidth;
}
uint16_t
WimaxPhy::GetNfft (void) const
{
return DoGetNfft ();
}
double
WimaxPhy::GetSamplingFactor (void) const
{
return DoGetSamplingFactor ();
}
double
WimaxPhy::GetSamplingFrequency (void) const
{
return DoGetSamplingFrequency ();
}
void
WimaxPhy::SetPsDuration (Time psDuration)
{
m_psDuration = psDuration;
}
Time
WimaxPhy::GetPsDuration (void) const
{
return m_psDuration;
}
void
WimaxPhy::SetSymbolDuration (Time symbolDuration)
{
m_symbolDuration = symbolDuration;
}
Time
WimaxPhy::GetSymbolDuration (void) const
{
return m_symbolDuration;
}
double
WimaxPhy::GetGValue (void) const
{
return DoGetGValue ();
}
void
WimaxPhy::SetPsPerSymbol (uint16_t psPerSymbol)
{
m_psPerSymbol = psPerSymbol;
}
uint16_t
WimaxPhy::GetPsPerSymbol (void) const
{
return m_psPerSymbol;
}
void
WimaxPhy::SetPsPerFrame (uint16_t psPerFrame)
{
m_psPerFrame = psPerFrame;
}
uint16_t
WimaxPhy::GetPsPerFrame (void) const
{
return m_psPerFrame;
}
void
WimaxPhy::SetSymbolsPerFrame (uint32_t symbolsPerFrame)
{
m_symbolsPerFrame = symbolsPerFrame;
}
uint32_t
WimaxPhy::GetSymbolsPerFrame (void) const
{
return m_symbolsPerFrame;
}
Ptr<Object>
WimaxPhy::GetMobility (void)
{
return m_mobility;
}
void
WimaxPhy::SetMobility (Ptr<Object> mobility)
{
m_mobility = mobility;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-phy.cc | C++ | gpl2 | 8,185 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#ifndef MAC_HEADER_TYPE_H
#define MAC_HEADER_TYPE_H
#include <stdint.h>
#include "ns3/header.h"
namespace ns3 {
/**
* \ingroup wimax
* \brief Represents the HT (Header Type) field of generic MAC and bandwidth request headers
*/
class MacHeaderType : public Header
{
/**
* \brief this class implements the mac header type field.
* \see GenericMacHeader
* \see BandwidthRequestHeader
*/
public:
enum HeaderType
{
HEADER_TYPE_GENERIC, HEADER_TYPE_BANDWIDTH
};
MacHeaderType (void);
MacHeaderType (uint8_t type);
virtual ~MacHeaderType (void);
void SetType (uint8_t type);
uint8_t GetType (void) const;
std::string GetName (void) const;
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);
private:
uint8_t m_type;
};
} // namespace ns3
#endif /* MAC_HEADER_TYPE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef GENERIC_MAC_HEADER_H
#define GENERIC_MAC_HEADER_H
#include <stdint.h>
#include "ns3/header.h"
#include "cid.h"
namespace ns3 {
/**
* \brief 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
*/
class GenericMacHeader : public Header
{
public:
GenericMacHeader (void);
~GenericMacHeader (void);
void SetEc (uint8_t ec);
void SetType (uint8_t type);
void SetCi (uint8_t ci);
void SetEks (uint8_t eks);
void SetLen (uint16_t len);
void SetCid (Cid cid);
void SetHcs (uint8_t hcs);
void SetHt (uint8_t HT);
uint8_t GetEc (void) const;
uint8_t GetType (void) const;
uint8_t GetCi (void) const;
uint8_t GetEks (void) const;
uint16_t GetLen (void) const;
Cid GetCid (void) const;
uint8_t GetHcs (void) const;
uint8_t GetHt (void) const;
std::string GetName (void) const;
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);
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
};
} // namespace ns3
#endif /* GENERIC_MAC_HEADER */
// ----------------------------------------------------------------------------------------------------------
#ifndef BANDWIDTH_REQUEST_HEADER_H
#define BANDWIDTH_REQUEST_HEADER_H
#include <stdint.h>
#include "ns3/header.h"
#include "cid.h"
namespace ns3 {
/**
* \brief 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:
enum HeaderType
{
HEADER_TYPE_INCREMENTAL, HEADER_TYPE_AGGREGATE
};
BandwidthRequestHeader (void);
~BandwidthRequestHeader (void);
void SetHt (uint8_t HT);
void SetEc (uint8_t ec);
void SetType (uint8_t type);
void SetBr (uint32_t br);
void SetCid (Cid cid);
void SetHcs (uint8_t hcs);
uint8_t GetHt (void) const;
uint8_t GetEc (void) const;
uint8_t GetType (void) const;
uint32_t GetBr (void) const;
Cid GetCid (void) const;
uint8_t GetHcs (void) const;
std::string GetName (void) const;
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);
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
};
} // namespace ns3
#endif /* BANDWIDTH_REQUEST_HEADER_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef GRANT_MANAGEMENT_SUBHEADER_H
#define GRANT_MANAGEMENT_SUBHEADER_H
#include <stdint.h>
#include "ns3/header.h"
namespace ns3 {
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);
void SetSi (uint8_t si);
void SetPm (uint8_t pm);
void SetPbr (uint16_t pbr);
uint8_t GetSi (void) const;
uint8_t GetPm (void) const;
uint16_t GetPbr (void) const;
std::string GetName (void) const;
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);
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
};
} // namespace ns3
#endif /* GRANT_MANAGEMENT_SUBHEADER_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef FRAGMENTATION_SUBHEADER_H
#define FRAGMENTATION_SUBHEADER_H
#include <stdint.h>
#include "ns3/header.h"
namespace ns3 {
/**
*
* \brief 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
{
public:
FragmentationSubheader (void);
~FragmentationSubheader (void);
void SetFc (uint8_t fc);
void SetFsn (uint8_t fsn);
uint8_t GetFc (void) const;
uint8_t GetFsn (void) const;
std::string GetName (void) const;
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);
private:
uint8_t m_fc; // Fragment Control
uint8_t m_fsn; // Fragment Sequence Number
};
} // namespace ns3
#endif /* FRAGMENTATION_SUBHEADER_H */
| zy901002-gpsr | src/wimax/model/wimax-mac-header.h | C++ | gpl2 | 8,173 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
/**
* \brief this file represents default traces providing for each SNR value (1): the bit error rate BER (2), the block error
* rate BlcER(3), the standard deviation on block error rate (4) and the confidence interval (5 and 6) for a given
* modulation.
* It is made of 7 tables: one for each modulation and coding scheme. Each table is made of 6 columns (see (1) to (6) above).
* These traces are generated by an external OFDM simulator: It is based on an external mathematics and signal processing
* library IT++ and includes : a random block generator, a Reed Solomon (RS) coder, a convolutional coder, an interleaver, a 256
* FFT-based OFDM modulator, a multi-path channel simulator and an equalizer. The multipath channel is simulated using
* the TDL_channel class of the IT++ library.
*/
#ifndef WIMAX_DEFAULT_TRACES_H
#define WIMAX_DEFAULT_TRACES_H
double modulation0[6][29] = {
{ 0.00, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80,
1.90, 2.00, 2.10, 2.20, 2.30, 2.40, 2.50, 2.60, 2.70, 2.80 },
{ 0.50798, 0.50862, 0.50517, 0.49325, 0.45741, 0.39430, 0.30345, 0.20492, 0.12126, 0.06741, 0.03429, 0.01710, 0.00865,
0.00419, 0.00223, 0.00098, 0.00065, 0.00028, 0.00013, 0.00006, 0.00005, 0.00001, 0.00002, 0.00000, 0.00000, 0.00000,
0.00000, 0.00000, 0.00000 },
{ 1.00000, 1.00000, 1.00000, 1.00000, 0.99870, 0.98730, 0.93240, 0.81330, 0.62730, 0.45400, 0.29000, 0.17620, 0.09950,
0.05670, 0.03350, 0.01640, 0.01120, 0.00520, 0.00320, 0.00160, 0.00110, 0.00060, 0.00040, 0.00010, 0.00010, 0.00010,
0.00000, 0.00000, 0.00000 },
{ 0.00000, 0.00000, 0.00000, 0.00000, 0.00130, 0.01254, 0.06303, 0.15184, 0.23380, 0.24788, 0.20590, 0.14515, 0.08960,
0.05348, 0.03238, 0.01613, 0.01107, 0.00517, 0.00319, 0.00160, 0.00110, 0.00020, 0.00060, 0.00000, 0.00010, 0.00010,
0.00000, 0.00000, 0.00000 },
{ 1.00000, 1.00000, 1.00000, 1.00000, 0.99799, 0.98511, 0.92748, 0.80566, 0.61782, 0.44424, 0.28111, 0.16873, 0.09363,
0.05217, 0.02997, 0.01391, 0.00914, 0.00379, 0.00209, 0.00082, 0.00045, 0.00008, 0.00012, 0.00000, 0.00010, 0.00010,
0.00000, 0.00000, 0.00000 },
{ 1.00000, 1.00000, 1.00000, 1.00000, 0.99941, 0.98950, 0.93732, 0.82094, 0.63678, 0.46376, 0.29889, 0.18367, 0.10537,
0.06123, 0.03703, 0.01889, 0.01326, 0.00661, 0.00431, 0.00238, 0.00175, 0.00048, 0.00108, 0.00000, 0.00030, 0.00030,
0.00000, 0.00000, 0.00000 }
};
double modulation1[6][42] = {
{ 2.00, 2.10, 2.20, 2.30, 2.40, 2.50, 2.60, 2.70, 2.80, 2.90, 3.00, 3.10, 3.20, 3.30, 3.40, 3.50, 3.60, 3.70, 3.80,
3.90, 4.00, 4.10, 4.20, 4.30, 4.40, 4.50, 4.60, 4.70, 4.80, 4.90, 5.00, 5.10, 5.20, 5.30, 5.40, 5.50, 5.60, 5.70,
5.80, 5.90, 6.00, 6.10 },
{ 0.45604, 0.43627, 0.41185, 0.38360, 0.34393, 0.30548, 0.26033, 0.22148, 0.18646, 0.14898, 0.11921, 0.09493, 0.07055,
0.05625, 0.04178, 0.03245, 0.02613, 0.01733, 0.01415, 0.01151, 0.00834, 0.00506, 0.00450, 0.00349, 0.00213, 0.00158,
0.00162, 0.00078, 0.00070, 0.00039, 0.00039, 0.00059, 0.00049, 0.00005, 0.00015, 0.00010, 0.00000, 0.00029, 0.00005,
0.00000, 0.00005, 0.00000 },
{ 0.95150, 0.91120, 0.86240, 0.80300, 0.72060, 0.64010, 0.54740, 0.46440, 0.39190, 0.31310, 0.25110, 0.19930, 0.14830,
0.11820, 0.08800, 0.06890, 0.05520, 0.03650, 0.02980, 0.02440, 0.01770, 0.01090, 0.00920, 0.00730, 0.00460, 0.00340,
0.00340, 0.00160, 0.00160, 0.00150, 0.00140, 0.00120, 0.00100, 0.00090, 0.00060, 0.00040, 0.00020, 0.00010, 0.00005,
0.00004, 0.00003, 0.00000 },
{ 0.04615, 0.08092, 0.11867, 0.15819, 0.20134, 0.23037, 0.24775, 0.24873, 0.23831, 0.21507, 0.18805, 0.15958, 0.12631,
0.10423, 0.08026, 0.06415, 0.05215, 0.03517, 0.02891, 0.02380, 0.01739, 0.01078, 0.00911, 0.00725, 0.00458, 0.00339,
0.00339, 0.00160, 0.00160, 0.00080, 0.00080, 0.00120, 0.00100, 0.00010, 0.00030, 0.00020, 0.00000, 0.00060, 0.00010,
0.00000, 0.00010, 0.00000 },
{ 0.94729, 0.90563, 0.85565, 0.79520, 0.71181, 0.63069, 0.53764, 0.45463, 0.38233, 0.30401, 0.24260, 0.19147, 0.14133,
0.11187, 0.08245, 0.06394, 0.05072, 0.03282, 0.02647, 0.02138, 0.01512, 0.00886, 0.00733, 0.00563, 0.00327, 0.00226,
0.00226, 0.00082, 0.00082, 0.00025, 0.00025, 0.00052, 0.00038, 0.00010, 0.00004, 0.00008, 0.00000, 0.00012, 0.00010,
0.00000, 0.00010, 0.00000 },
{ 0.95571, 0.91678, 0.86915, 0.81080, 0.72940, 0.64951, 0.55716, 0.47418, 0.40147, 0.32219, 0.25960, 0.20713, 0.15527,
0.12453, 0.09355, 0.07386, 0.05968, 0.04018, 0.03313, 0.02742, 0.02028, 0.01294, 0.01107, 0.00897, 0.00593, 0.00454,
0.00454, 0.00238, 0.00238, 0.00135, 0.00135, 0.00188, 0.00162, 0.00030, 0.00064, 0.00048, 0.00000, 0.00108, 0.00030,
0.00000, 0.00030, 0.00000 }
};
double modulation2[6][96] = {
{ 3.00, 3.10, 3.20, 3.30, 3.40, 3.50, 3.60, 3.70, 3.80, 3.90, 4.00, 4.10, 4.20, 4.30, 4.40, 4.50, 4.60, 4.70, 4.80,
4.90, 5.00, 5.10, 5.20, 5.30, 5.40, 5.50, 5.60, 5.70, 5.80, 5.90, 6.00, 6.10, 6.20, 6.30, 6.40, 6.50, 6.60, 6.70,
6.80, 6.90, 7.00, 7.10, 7.20, 7.30, 7.40, 7.50, 7.60, 7.70, 7.80, 7.90, 8.00, 8.10, 8.20, 8.30, 8.40, 8.50, 8.60,
8.70, 8.80, 8.90, 9.00, 9.10, 9.20, 9.30, 9.40, 9.50, 9.60, 9.70, 9.80, 9.90, 10.00, 10.10, 10.20, 10.30, 10.40,
10.50, 10.60, 10.70, 10.80, 10.90, 11.00, 11.10, 11.20, 11.30, 11.40, 11.50, 11.60, 11.70, 11.80, 11.90, 12.00,
12.10, 12.20, 12.30, 12.40, 12.50 },
{ 0.36630, 0.35317, 0.34175, 0.33351, 0.31776, 0.30292, 0.28624, 0.27526, 0.26174, 0.24856, 0.23007, 0.21865, 0.19945,
0.18414, 0.16967, 0.15747, 0.14530, 0.13298, 0.11771, 0.11115, 0.09713, 0.09123, 0.08231, 0.07267, 0.06616, 0.05673,
0.05156, 0.04577, 0.04282, 0.03866, 0.03513, 0.02856, 0.02680, 0.02406, 0.01948, 0.01927, 0.01580, 0.01473, 0.01292,
0.01266, 0.01108, 0.00937, 0.00735, 0.00675, 0.00582, 0.00612, 0.00496, 0.00471, 0.00386, 0.00412, 0.00333, 0.00387,
0.00234, 0.00257, 0.00204, 0.00161, 0.00179, 0.00128, 0.00114, 0.00136, 0.00102, 0.00133, 0.00087, 0.00066, 0.00075,
0.00066, 0.00069, 0.00041, 0.00051, 0.00035, 0.00033, 0.00034, 0.00025, 0.00033, 0.00038, 0.00036, 0.00012, 0.00005,
0.00024, 0.00015, 0.00010, 0.00000, 0.00011, 0.00001, 0.00024, 0.00001, 0.00001, 0.00005, 0.00001, 0.00005, 0.00010,
0.00005, 0.00009, 0.00000, 0.00000, 0.00000 },
{ 0.99130, 0.98790, 0.97490, 0.96360, 0.94840, 0.92520, 0.89860, 0.87960, 0.84970, 0.81960, 0.76860, 0.72540, 0.69130,
0.63620, 0.58540, 0.54710, 0.51010, 0.47450, 0.42570, 0.39700, 0.34730, 0.32840, 0.29360, 0.25990, 0.23970, 0.20910,
0.18810, 0.16480, 0.15410, 0.14130, 0.12570, 0.10670, 0.09940, 0.08810, 0.07330, 0.06930, 0.05720, 0.05530, 0.04630,
0.04460, 0.04070, 0.03310, 0.02810, 0.02680, 0.02290, 0.02260, 0.01700, 0.01740, 0.01320, 0.01490, 0.01210, 0.01320,
0.00820, 0.00850, 0.00840, 0.00640, 0.00590, 0.00480, 0.00450, 0.00490, 0.00410, 0.00420, 0.00340, 0.00250, 0.00240,
0.00240, 0.00210, 0.00190, 0.00160, 0.00140, 0.00120, 0.00110, 0.00100, 0.00100, 0.00100, 0.00100, 0.00080, 0.00070,
0.00050, 0.00050, 0.00040, 0.00040, 0.00030, 0.00030, 0.00020, 0.00020, 0.00010, 0.00008, 0.00007, 0.00005, 0.00004,
0.00003, 0.00003, 0.00003, 0.00002, 0.00000 },
{ 0.00862, 0.01195, 0.02447, 0.03508, 0.04894, 0.06921, 0.09112, 0.10590, 0.12771, 0.14786, 0.17785, 0.19920, 0.21340,
0.23145, 0.24271, 0.24778, 0.24990, 0.24935, 0.24448, 0.23939, 0.22668, 0.22055, 0.20740, 0.19235, 0.18224, 0.16538,
0.15272, 0.13764, 0.13035, 0.12133, 0.10990, 0.09531, 0.08952, 0.08034, 0.06793, 0.06450, 0.05393, 0.05224, 0.04416,
0.04261, 0.03904, 0.03200, 0.02731, 0.02608, 0.02238, 0.02209, 0.01671, 0.01710, 0.01303, 0.01468, 0.01195, 0.01303,
0.00813, 0.00843, 0.00833, 0.00636, 0.00587, 0.00478, 0.00448, 0.00488, 0.00408, 0.00418, 0.00339, 0.00230, 0.00239,
0.00239, 0.00210, 0.00110, 0.00190, 0.00120, 0.00160, 0.00100, 0.00110, 0.00150, 0.00100, 0.00120, 0.00070, 0.00020,
0.00080, 0.00050, 0.00030, 0.00000, 0.00050, 0.00010, 0.00050, 0.00010, 0.00010, 0.00010, 0.00020, 0.00020, 0.00030,
0.00010, 0.00020, 0.00000, 0.00000, 0.00000 },
{ 0.98948, 0.98576, 0.97183, 0.95993, 0.94406, 0.92004, 0.89268, 0.87322, 0.84270, 0.81206, 0.76033, 0.71665, 0.68225,
0.62677, 0.57574, 0.53734, 0.50030, 0.46471, 0.41601, 0.38741, 0.33797, 0.31920, 0.28467, 0.25130, 0.23133, 0.20113,
0.18044, 0.15753, 0.14702, 0.13447, 0.11920, 0.10065, 0.09354, 0.08254, 0.06819, 0.06432, 0.05265, 0.05082, 0.04218,
0.04055, 0.03683, 0.02959, 0.02486, 0.02363, 0.01997, 0.01969, 0.01447, 0.01484, 0.01096, 0.01252, 0.00996, 0.01096,
0.00643, 0.00670, 0.00661, 0.00484, 0.00440, 0.00345, 0.00319, 0.00353, 0.00285, 0.00293, 0.00226, 0.00136, 0.00144,
0.00144, 0.00120, 0.00045, 0.00105, 0.00052, 0.00082, 0.00038, 0.00045, 0.00074, 0.00038, 0.00052, 0.00018, 0.00008,
0.00025, 0.00006, 0.00004, 0.00000, 0.00006, 0.00010, 0.00006, 0.00010, 0.00010, 0.00010, 0.00008, 0.00008, 0.00004,
0.00010, 0.00008, 0.00000, 0.00000, 0.00000 },
{ 0.99312, 0.99004, 0.97797, 0.96727, 0.95274, 0.93036, 0.90452, 0.88598, 0.85670, 0.82714, 0.77687, 0.73415, 0.70035,
0.64563, 0.59506, 0.55686, 0.51990, 0.48429, 0.43539, 0.40659, 0.35663, 0.33760, 0.30253, 0.26850, 0.24807, 0.21707,
0.19576, 0.17207, 0.16118, 0.14813, 0.13220, 0.11275, 0.10526, 0.09366, 0.07841, 0.07428, 0.06175, 0.05978, 0.05042,
0.04865, 0.04457, 0.03661, 0.03134, 0.02996, 0.02583, 0.02551, 0.01953, 0.01996, 0.01544, 0.01727, 0.01424, 0.01544,
0.00997, 0.01030, 0.01019, 0.00796, 0.00740, 0.00615, 0.00581, 0.00627, 0.00535, 0.00547, 0.00454, 0.00324, 0.00336,
0.00336, 0.00300, 0.00175, 0.00275, 0.00188, 0.00238, 0.00162, 0.00175, 0.00226, 0.00162, 0.00188, 0.00122, 0.00048,
0.00135, 0.00094, 0.00064, 0.00000, 0.00094, 0.00030, 0.00094, 0.00030, 0.00030, 0.00030, 0.00048, 0.00048, 0.00064,
0.00030, 0.00048, 0.00000, 0.00000, 0.00000 }
};
double modulation3[6][117] = {
{ 10.00, 10.10, 10.20, 10.30, 10.40, 10.50, 10.60, 10.70, 10.80, 10.90, 11.00, 11.10, 11.20, 11.30, 11.40, 11.50,
11.60, 11.70, 11.80, 11.90, 12.00, 12.10, 12.20, 12.30, 12.40, 12.50, 12.60, 12.70, 12.80, 12.90, 13.00, 13.10,
13.20, 13.30, 13.40, 13.50, 13.60, 13.70, 13.80, 13.90, 14.00, 14.10, 14.20, 14.30, 14.40, 14.50, 14.60, 14.70,
14.90, 15.00, 15.10, 15.20, 15.30, 15.40, 15.50, 15.60, 15.70, 15.80, 15.90, 16.00, 16.10, 16.20, 16.30, 16.40,
16.50, 16.60, 16.70, 16.80, 16.90, 17.10, 17.20, 17.30, 17.40, 17.50, 17.60, 17.70, 17.80, 17.90, 18.00, 18.10,
18.20, 18.30, 18.40, 18.50, 18.60, 18.70, 18.80, 18.90, 19.00, 19.10, 19.20, 19.30, 19.40, 19.50, 19.60, 19.70,
19.80, 19.90, 20.00, 20.10, 20.20, 20.30, 20.40, 20.50, 20.60, 20.70, 20.80, 20.90, 21.00, 21.10, 21.20, 21.30,
21.40, 21.50, 21.60, 21.70, 21.80 },
{ 0.39109, 0.37994, 0.36904, 0.36186, 0.35172, 0.34069, 0.32445, 0.31707, 0.30757,
0.28951, 0.27937, 0.26696, 0.25737, 0.24826, 0.23413, 0.22045, 0.21144, 0.20244,
0.19049, 0.17783, 0.16793, 0.15746, 0.14697, 0.13387, 0.12757, 0.12354, 0.11370,
0.10474, 0.09701, 0.09219, 0.08535, 0.07516, 0.07240, 0.06492, 0.06394, 0.05577,
0.05399, 0.05040, 0.04632, 0.04287, 0.03918, 0.03327, 0.03376, 0.02855, 0.02791,
0.02417, 0.02412, 0.02111, 0.01801, 0.01482, 0.01486, 0.01324, 0.01167, 0.01137,
0.01127, 0.00911, 0.00930, 0.00650, 0.00748, 0.00615, 0.00610, 0.00487, 0.00492,
0.00364, 0.00448, 0.00477, 0.00231, 0.00295, 0.00256, 0.00266, 0.00182, 0.00192,
0.00182, 0.00123, 0.00158, 0.00153, 0.00153, 0.00093, 0.00093, 0.00064, 0.00064,
0.00059, 0.00069, 0.00034, 0.00034, 0.00054, 0.00039, 0.00010, 0.00025, 0.00049,
0.00030, 0.00034, 0.00015, 0.00034, 0.00030, 0.00034, 0.00005, 0.00020, 0.00020,
0.00015, 0.00010, 0.00010, 0.00010, 0.00010, 0.00010, 0.00020, 0.00000, 0.00005,
0.00000, 0.00005, 0.00010, 0.00020, 0.00010, 0.00005, 0.00005, 0.00020, 0.00000 },
{ 0.79460, 0.77200, 0.74980, 0.73520, 0.71470, 0.69220, 0.65920, 0.64420, 0.62490,
0.58830, 0.56760, 0.54240, 0.52290, 0.50440, 0.47570, 0.44790, 0.42960, 0.41130,
0.38710, 0.36140, 0.34120, 0.32000, 0.29860, 0.27200, 0.25920, 0.25100, 0.23100,
0.21280, 0.19710, 0.18730, 0.17340, 0.15270, 0.14710, 0.13190, 0.12990, 0.11330,
0.10970, 0.10240, 0.09410, 0.08710, 0.07960, 0.06760, 0.06860, 0.05800, 0.05670,
0.04910, 0.04900, 0.04290, 0.03660, 0.03010, 0.03020, 0.02690, 0.02370, 0.02310,
0.02290, 0.01850, 0.01890, 0.01520, 0.01320, 0.01250, 0.01240, 0.01000, 0.01000,
0.00940, 0.00910, 0.00970, 0.00700, 0.00600, 0.00520, 0.00540, 0.00390, 0.00390,
0.00370, 0.00320, 0.00320, 0.00310, 0.00310, 0.00190, 0.00190, 0.00130, 0.00130,
0.00120, 0.00140, 0.00090, 0.00080, 0.00070, 0.00070, 0.00070, 0.00060, 0.00060,
0.00060, 0.00050, 0.00050, 0.00050, 0.00040, 0.00040, 0.00040, 0.00040, 0.00040,
0.00030, 0.00020, 0.00020, 0.00020, 0.00020, 0.00020, 0.00015, 0.00014, 0.00013,
0.00012, 0.00011, 0.00010, 0.00009, 0.00008, 0.00007, 0.00006, 0.00005, 0.00000 },
{ 0.16321, 0.17602, 0.18760, 0.19468, 0.20390, 0.21306, 0.22465, 0.22921, 0.23440,
0.24220, 0.24543, 0.24820, 0.24948, 0.24998, 0.24941, 0.24729, 0.24504, 0.24213,
0.23725, 0.23079, 0.22478, 0.21760, 0.20944, 0.19802, 0.19201, 0.18800, 0.17764,
0.16752, 0.15825, 0.15222, 0.14333, 0.12938, 0.12546, 0.11450, 0.11303, 0.10046,
0.09767, 0.09191, 0.08525, 0.07951, 0.07326, 0.06303, 0.06389, 0.05464, 0.05348,
0.04669, 0.04660, 0.04106, 0.03526, 0.02919, 0.02929, 0.02618, 0.02314, 0.02257,
0.02238, 0.01816, 0.01854, 0.01303, 0.01497, 0.01234, 0.01225, 0.00980, 0.00990,
0.00734, 0.00902, 0.00961, 0.00468, 0.00596, 0.00517, 0.00537, 0.00369, 0.00388,
0.00369, 0.00249, 0.00319, 0.00309, 0.00309, 0.00190, 0.00190, 0.00130, 0.00130,
0.00120, 0.00140, 0.00070, 0.00070, 0.00110, 0.00080, 0.00020, 0.00050, 0.00100,
0.00060, 0.00070, 0.00030, 0.00070, 0.00060, 0.00070, 0.00010, 0.00040, 0.00040,
0.00030, 0.00020, 0.00020, 0.00020, 0.00020, 0.00020, 0.00040, 0.00000, 0.00010,
0.00000, 0.00010, 0.00020, 0.00040, 0.00020, 0.00010, 0.00010, 0.00040, 0.00000 },
{ 0.78668, 0.76378, 0.74131, 0.72655, 0.70585, 0.68315, 0.64991, 0.63482, 0.61541,
0.57865, 0.55789, 0.53263, 0.51311, 0.49460, 0.46591, 0.43815, 0.41990, 0.40165,
0.37755, 0.35198, 0.33191, 0.31086, 0.28963, 0.26328, 0.25061, 0.24250, 0.22274,
0.20478, 0.18930, 0.17965, 0.16598, 0.14565, 0.14016, 0.12527, 0.12331, 0.10709,
0.10358, 0.09646, 0.08838, 0.08157, 0.07429, 0.06268, 0.06365, 0.05342, 0.05217,
0.04487, 0.04477, 0.03893, 0.03292, 0.02675, 0.02685, 0.02373, 0.02072, 0.02016,
0.01997, 0.01586, 0.01623, 0.01096, 0.01280, 0.01032, 0.01023, 0.00796, 0.00805,
0.00572, 0.00724, 0.00778, 0.00336, 0.00449, 0.00379, 0.00396, 0.00251, 0.00268,
0.00251, 0.00152, 0.00209, 0.00201, 0.00201, 0.00105, 0.00105, 0.00059, 0.00059,
0.00052, 0.00067, 0.00018, 0.00018, 0.00045, 0.00025, 0.00008, 0.00006, 0.00038,
0.00012, 0.00018, 0.00004, 0.00018, 0.00012, 0.00018, 0.00010, 0.00001, 0.00001,
0.00004, 0.00008, 0.00008, 0.00008, 0.00008, 0.00008, 0.00001, 0.00000, 0.00010,
0.00000, 0.00010, 0.00008, 0.00001, 0.00008, 0.00010, 0.00010, 0.00001, 0.00000 },
{ 0.80252, 0.78022, 0.75829, 0.74385, 0.72355, 0.70125, 0.66849, 0.65358, 0.63439,
0.59795, 0.57731, 0.55217, 0.53269, 0.51420, 0.48549, 0.45765, 0.43930, 0.42095,
0.39665, 0.37082, 0.35049, 0.32914, 0.30757, 0.28072, 0.26779, 0.25950, 0.23926,
0.22082, 0.20490, 0.19495, 0.18082, 0.15975, 0.15404, 0.13853, 0.13649, 0.11951,
0.11582, 0.10834, 0.09982, 0.09263, 0.08490, 0.07252, 0.07355, 0.06258, 0.06123,
0.05334, 0.05323, 0.04687, 0.04028, 0.03345, 0.03355, 0.03007, 0.02668, 0.02604,
0.02583, 0.02114, 0.02157, 0.01544, 0.01760, 0.01468, 0.01457, 0.01184, 0.01195,
0.00908, 0.01096, 0.01162, 0.00604, 0.00751, 0.00661, 0.00684, 0.00489, 0.00512,
0.00489, 0.00348, 0.00431, 0.00419, 0.00419, 0.00275, 0.00275, 0.00201, 0.00201,
0.00188, 0.00213, 0.00122, 0.00122, 0.00175, 0.00135, 0.00048, 0.00094, 0.00162,
0.00108, 0.00122, 0.00064, 0.00122, 0.00108, 0.00122, 0.00030, 0.00079, 0.00079,
0.00064, 0.00048, 0.00048, 0.00048, 0.00048, 0.00048, 0.00079, 0.00000, 0.00030,
0.00000, 0.00030, 0.00048, 0.00079, 0.00048, 0.00030, 0.00030, 0.00079, 0.00000 }
};
double modulation4[6][115] = {
{ 20.00, 20.10, 20.20, 20.30, 20.40, 20.50, 20.60, 20.70, 20.80, 20.90, 21.00, 21.10, 21.20, 21.30, 21.40, 21.50,
21.60, 21.70, 21.80, 21.90, 22.00, 22.10, 22.20, 22.30, 22.40, 22.50, 22.60, 22.70, 22.80, 22.90, 23.00, 23.10,
23.20, 23.30, 23.40, 23.50, 23.60, 23.70, 23.80, 23.90, 24.00, 24.10, 24.20, 24.30, 24.40, 24.50, 24.60, 24.70,
24.80, 24.90, 25.00, 25.10, 25.20, 25.30, 25.40, 25.50, 25.60, 25.70, 25.80, 25.90, 26.00, 26.10, 26.20, 26.30,
26.40, 26.50, 26.60, 26.70, 26.80, 26.90, 27.10, 27.20, 27.30, 27.40, 27.50, 27.60, 27.70, 27.80, 27.90, 28.00,
28.10, 28.20, 28.30, 28.40, 28.50, 28.60, 28.70, 28.80, 28.90, 29.00, 29.10, 29.20, 29.30, 29.40, 29.50, 29.60,
29.70, 29.80, 29.90, 30.00, 30.10, 30.20, 30.30, 30.40, 30.50, 30.60, 30.70, 30.80, 30.90, 31.00, 31.10, 31.20,
31.30, 31.40, 31.50 },
{ 0.33107, 0.32310, 0.31789, 0.31805, 0.31352, 0.30854, 0.30697, 0.29615, 0.29218, 0.28319, 0.27982, 0.27112, 0.27369,
0.26701, 0.26180, 0.25450, 0.25144, 0.24541, 0.23739, 0.23148, 0.23259, 0.23020, 0.22530, 0.21333, 0.20806, 0.20799,
0.19834, 0.19916, 0.19431, 0.18956, 0.18273, 0.18543, 0.17783, 0.17627, 0.17182, 0.16563, 0.15979, 0.15714, 0.15541,
0.15025, 0.14868, 0.14430, 0.13602, 0.13636, 0.13467, 0.12758, 0.12542, 0.12828, 0.12015, 0.11889, 0.11511, 0.10993,
0.10791, 0.10339, 0.10542, 0.10187, 0.09945, 0.09516, 0.08852, 0.09033, 0.09222, 0.08730, 0.08405, 0.08084, 0.08054,
0.07719, 0.07267, 0.06947, 0.07170, 0.06786, 0.06610, 0.06346, 0.05817, 0.06174, 0.06139, 0.05859, 0.05682, 0.05319,
0.05322, 0.05096, 0.05004, 0.04921, 0.04771, 0.04506, 0.04220, 0.04323, 0.04337, 0.04082, 0.04035, 0.03932, 0.03570,
0.03526, 0.03798, 0.03680, 0.03391, 0.03413, 0.03184, 0.02968, 0.02886, 0.02931, 0.02955, 0.02795, 0.02603, 0.02478,
0.02541, 0.02669, 0.02407, 0.02403, 0.02353, 0.02260, 0.02004, 0.02105, 0.02135, 0.01855, 0.02085 },
{ 0.68910, 0.67470, 0.66370, 0.66340, 0.65400, 0.64460, 0.64120, 0.61740, 0.61020, 0.59290, 0.58240, 0.56690, 0.57110,
0.55810, 0.54650, 0.53130, 0.52610, 0.51200, 0.49810, 0.48530, 0.48690, 0.48150, 0.47100, 0.44610, 0.43360, 0.43630,
0.41640, 0.41670, 0.40760, 0.39680, 0.38090, 0.38680, 0.37150, 0.36880, 0.36050, 0.34570, 0.33380, 0.32750, 0.32550,
0.31570, 0.31170, 0.30200, 0.28510, 0.28540, 0.28240, 0.26730, 0.26210, 0.26730, 0.25150, 0.24950, 0.24100, 0.23150,
0.22630, 0.21650, 0.22150, 0.21430, 0.20760, 0.19990, 0.18610, 0.18940, 0.19290, 0.18350, 0.17690, 0.16830, 0.17030,
0.16210, 0.15310, 0.14570, 0.14960, 0.14150, 0.13860, 0.13350, 0.12300, 0.12880, 0.12900, 0.12350, 0.11900, 0.11280,
0.11120, 0.10710, 0.10500, 0.10350, 0.10030, 0.09460, 0.08850, 0.09070, 0.09010, 0.08600, 0.08490, 0.08210, 0.07550,
0.07440, 0.07960, 0.07740, 0.07190, 0.07100, 0.06770, 0.06190, 0.06050, 0.06170, 0.06200, 0.05870, 0.05490, 0.05240,
0.05300, 0.05540, 0.05070, 0.05070, 0.04940, 0.04670, 0.04440, 0.04240, 0.04300, 0.04100, 0.04200 },
{ 0.21424, 0.21948, 0.22320, 0.22330, 0.22628, 0.22909, 0.23006, 0.23622, 0.23786, 0.24137, 0.24321, 0.24552, 0.24494,
0.24662, 0.24784, 0.24902, 0.24932, 0.24986, 0.25000, 0.24978, 0.24983, 0.24966, 0.24916, 0.24710, 0.24559, 0.24594,
0.24301, 0.24306, 0.24146, 0.23935, 0.23581, 0.23719, 0.23349, 0.23279, 0.23054, 0.22619, 0.22238, 0.22024, 0.21955,
0.21603, 0.21454, 0.21080, 0.20382, 0.20395, 0.20265, 0.19585, 0.19340, 0.19585, 0.18825, 0.18725, 0.18292, 0.17791,
0.17509, 0.16963, 0.17244, 0.16838, 0.16450, 0.15994, 0.15147, 0.15353, 0.15569, 0.14983, 0.14561, 0.13997, 0.14130,
0.13582, 0.12966, 0.12447, 0.12722, 0.12148, 0.11939, 0.11568, 0.10787, 0.11221, 0.11236, 0.10825, 0.10484, 0.10008,
0.09884, 0.09563, 0.09398, 0.09279, 0.09024, 0.08565, 0.08067, 0.08247, 0.08198, 0.07860, 0.07769, 0.07536, 0.06980,
0.06886, 0.07326, 0.07141, 0.06673, 0.06596, 0.06312, 0.05807, 0.05684, 0.05789, 0.05816, 0.05525, 0.05189, 0.04965,
0.05019, 0.05233, 0.04813, 0.04813, 0.04696, 0.04452, 0.04060, 0.04243, 0.04115, 0.03932, 0.04024 },
{ 0.68003, 0.66552, 0.65444, 0.65414, 0.64468, 0.63522, 0.63180, 0.60787, 0.60064, 0.58327, 0.57273, 0.55719, 0.56140,
0.54837, 0.53674, 0.52152, 0.51631, 0.50220, 0.48830, 0.47550, 0.47710, 0.47171, 0.46122, 0.43636, 0.42389, 0.42658,
0.40674, 0.40704, 0.39797, 0.38721, 0.37138, 0.37725, 0.36203, 0.35934, 0.35109, 0.33638, 0.32456, 0.31830, 0.31632,
0.30659, 0.30262, 0.29300, 0.27625, 0.27655, 0.27358, 0.25863, 0.25348, 0.25863, 0.24300, 0.24102, 0.23262, 0.22323,
0.21810, 0.20843, 0.21336, 0.20626, 0.19965, 0.19206, 0.17847, 0.18172, 0.18517, 0.17591, 0.16942, 0.16097, 0.16293,
0.15488, 0.14604, 0.13878, 0.14261, 0.13467, 0.13183, 0.12683, 0.11656, 0.12223, 0.12243, 0.11705, 0.11265, 0.10660,
0.10504, 0.10104, 0.09899, 0.09753, 0.09441, 0.08886, 0.08293, 0.08507, 0.08449, 0.08050, 0.07944, 0.07672, 0.07032,
0.06926, 0.07429, 0.07216, 0.06684, 0.06597, 0.06278, 0.05718, 0.05583, 0.05698, 0.05727, 0.05409, 0.05044, 0.04803,
0.04861, 0.05092, 0.04640, 0.04640, 0.04515, 0.04256, 0.03845, 0.04036, 0.03043, 0.02871, 0.02957 },
{ 0.69817, 0.68388, 0.67296, 0.67266, 0.66332, 0.65398, 0.65060, 0.62693, 0.61976, 0.60253, 0.59207, 0.57661, 0.58080,
0.56783, 0.55626, 0.54108, 0.53589, 0.52180, 0.50790, 0.49510, 0.49670, 0.49129, 0.48078, 0.45584, 0.44331, 0.44602,
0.42606, 0.42636, 0.41723, 0.40639, 0.39042, 0.39635, 0.38097, 0.37826, 0.36991, 0.35502, 0.34304, 0.33670, 0.33468,
0.32481, 0.32078, 0.31100, 0.29395, 0.29425, 0.29122, 0.27597, 0.27072, 0.27597, 0.26000, 0.25798, 0.24938, 0.23977,
0.23450, 0.22457, 0.22964, 0.22234, 0.21555, 0.20774, 0.19373, 0.19708, 0.20063, 0.19109, 0.18438, 0.17563, 0.17767,
0.16932, 0.16016, 0.15262, 0.15659, 0.14833, 0.14537, 0.14017, 0.12944, 0.13537, 0.13557, 0.12995, 0.12535, 0.11900,
0.11736, 0.11316, 0.11101, 0.10947, 0.10619, 0.10034, 0.09407, 0.09633, 0.09571, 0.09150, 0.09036, 0.08748, 0.08068,
0.07954, 0.08490, 0.08264, 0.07696, 0.07603, 0.07262, 0.06662, 0.06517, 0.06642, 0.06673, 0.06331, 0.05937, 0.05677,
0.05739, 0.05988, 0.05500, 0.05500, 0.05365, 0.05084, 0.04635, 0.04844, 0.05557, 0.05329, 0.05443 },
};
double modulation5[6][547] = {
{ 50.00, 50.10, 50.20, 50.30, 50.40, 50.50, 50.60, 50.70, 50.80, 50.90, 51.00, 51.10, 51.20, 51.30, 51.40, 51.50,
51.60, 51.70, 51.80, 51.90, 52.00, 52.10, 52.20, 52.30, 52.40, 52.50, 52.60, 52.70, 52.80, 52.90, 53.00, 53.10,
53.20, 53.30, 53.40, 53.50, 53.60, 53.70, 53.80, 53.90, 54.00, 54.10, 54.20, 54.30, 54.40, 54.50, 54.60, 54.70,
54.80, 54.90, 55.00, 55.10, 55.20, 55.30, 55.40, 55.50, 55.60, 55.70, 55.80, 55.90, 56.00, 56.10, 56.20, 56.30,
56.40, 56.50, 56.60, 56.70, 56.80, 56.90, 57.00, 57.10, 57.20, 57.30, 57.40, 57.50, 57.60, 57.70, 57.80, 57.90,
58.00, 58.10, 58.20, 58.30, 58.40, 58.50, 58.60, 58.70, 58.80, 58.90, 59.00, 59.10, 59.20, 59.30, 59.40, 59.50,
59.60, 59.70, 59.80, 59.90, 60.00, 60.10, 60.20, 60.30, 60.40, 60.50, 60.60, 60.70, 60.80, 60.90, 61.00, 61.10,
61.20, 61.30, 61.40, 61.50, 61.60, 61.70, 61.80, 61.90, 62.00, 62.10, 62.20, 62.30, 62.40, 62.50, 62.60, 62.70,
62.80, 62.90, 63.00, 63.10, 63.20, 63.30, 63.40, 63.50, 63.60, 63.70, 63.80, 63.90, 64.00, 64.10, 64.20, 64.30,
64.40, 64.50, 64.60, 64.70, 64.80, 64.90, 65.00, 65.10, 65.20, 65.30, 65.40, 65.50, 65.60, 65.70, 65.80, 65.90,
66.00, 66.10, 66.20, 66.30, 66.40, 66.50, 66.60, 66.70, 66.80, 66.90, 67.00, 67.10, 67.20, 67.30, 67.40, 67.50,
67.60, 67.70, 67.80, 67.90, 68.00, 68.10, 68.20, 68.30, 68.40, 68.50, 68.60, 68.70, 68.80, 68.90, 69.00, 69.10,
69.20, 69.30, 69.40, 69.50, 69.60, 69.70, 69.80, 69.90, 70.00, 70.10, 70.20, 70.30, 70.40, 70.50, 70.60, 70.70,
70.80, 70.90, 71.00, 71.10, 71.20, 71.30, 71.40, 71.50, 71.60, 71.70, 71.80, 71.90, 72.00, 72.10, 72.20, 72.30,
72.40, 72.50, 72.60, 72.70, 72.80, 72.90, 73.00, 73.10, 73.20, 73.30, 73.40, 73.50, 73.60, 73.70, 73.80, 73.90,
74.00, 74.10, 74.20, 74.30, 74.40, 74.50, 74.60, 74.70, 74.80, 74.90, 75.00, 75.10, 75.20, 75.30, 75.40, 75.50,
75.60, 75.70, 75.80, 75.90, 76.00, 76.10, 76.20, 76.30, 76.40, 76.50, 76.60, 76.70, 76.80, 76.90, 77.00, 77.10,
77.20, 77.30, 77.40, 77.50, 77.60, 77.70, 77.80, 77.90, 78.00, 78.10, 78.20, 78.30, 78.40, 78.50, 78.60, 78.70,
78.80, 78.90, 79.00, 79.10, 79.20, 79.30, 79.40, 79.50, 79.60, 79.70, 79.80, 79.90, 80.00, 80.10, 80.20, 80.30,
80.40, 80.50, 80.60, 80.70, 80.80, 80.90, 81.00, 81.10, 81.20, 81.30, 81.40, 81.50, 81.60, 81.70, 81.80, 81.90,
82.00, 82.10, 82.20, 82.30, 82.40, 82.50, 82.60, 82.70, 82.80, 82.90, 83.00, 83.10, 83.20, 83.30, 83.40, 83.50,
83.60, 83.70, 83.80, 83.90, 84.00, 84.10, 84.20, 84.30, 84.40, 84.50, 84.60, 84.70, 84.80, 84.90, 85.00, 85.10,
85.20, 85.30, 85.40, 85.50, 85.60, 85.70, 85.80, 85.90, 86.00, 86.10, 86.20, 86.30, 86.40, 86.50, 86.60, 86.70,
86.80, 86.90, 87.00, 87.10, 87.20, 87.30, 87.40, 87.50, 87.60, 87.70, 87.80, 87.90, 88.00, 88.10, 88.20, 88.30,
88.40, 88.50, 88.60, 88.70, 88.80, 88.90, 89.00, 89.10, 89.20, 89.30, 89.40, 89.50, 89.60, 89.70, 89.80, 89.90,
90.00, 90.10, 90.20, 90.30, 90.40, 90.50, 90.60, 90.70, 90.80, 90.90, 91.00, 91.10, 91.20, 91.30, 91.40, 91.50,
91.60, 91.70, 91.80, 91.90, 92.00, 92.10, 92.20, 92.30, 92.40, 92.50, 92.60, 92.70, 92.80, 92.90, 93.00, 93.10,
93.20, 93.30, 93.40, 93.50, 93.60, 93.70, 93.80, 93.90, 94.00, 94.10, 94.20, 94.30, 94.40, 94.50, 94.60, 94.70,
94.80, 94.90, 95.00, 96.00, 96.10, 96.20, 96.30, 96.40, 96.50, 96.60, 96.70, 96.80, 96.90, 97.00, 97.10, 97.20,
97.30, 97.40, 97.50, 97.60, 97.70, 97.80, 97.90, 98.00, 98.10, 98.20, 98.30, 98.40, 98.50, 98.60, 98.70, 98.80,
98.90, 99.00, 99.10, 99.20, 99.30, 99.40, 99.50, 99.60, 99.70, 99.80, 99.90, 100.00, 100.10, 100.20, 100.30, 100.40,
100.50, 100.60, 100.70, 100.80, 100.90, 101.00, 101.10, 101.20, 101.30, 101.40, 101.50, 101.60, 101.70, 101.80,
101.90, 102.00, 102.10, 102.20, 102.30, 102.40, 102.50, 102.60, 102.70, 102.80, 102.90, 103.00, 103.10, 103.20,
103.30, 103.40, 103.50, 103.60, 103.70, 103.80, 103.90, 104.00, 104.10, 104.20, 104.30, 104.40, 104.50, 104.60,
104.70, 104.80, 104.90, 105.00 },
{ 0.46874, 0.46753, 0.46863, 0.46778, 0.46771, 0.46740, 0.46399, 0.46725, 0.46422, 0.46493, 0.46519, 0.46289, 0.46231,
0.46265, 0.46173, 0.46049, 0.45981, 0.45721, 0.45743, 0.45867, 0.45599, 0.45719, 0.45515, 0.45272, 0.45396, 0.45432,
0.45263, 0.44926, 0.44898, 0.45062, 0.45024, 0.44840, 0.44469, 0.44360, 0.44467, 0.44375, 0.44466, 0.44159, 0.44011,
0.43992, 0.43979, 0.43863, 0.44184, 0.43579, 0.43560, 0.43449, 0.43185, 0.43021, 0.43098, 0.42802, 0.42823, 0.42574,
0.42867, 0.42309, 0.42344, 0.42089, 0.42158, 0.41947, 0.41761, 0.41779, 0.41695, 0.41723, 0.41540, 0.40973, 0.41315,
0.40834, 0.40579, 0.40460, 0.40443, 0.40311, 0.39945, 0.40115, 0.40351, 0.39952, 0.39711, 0.39469, 0.39120, 0.39256,
0.39325, 0.39029, 0.38713, 0.38405, 0.38310, 0.38170, 0.38153, 0.38150, 0.37932, 0.37625, 0.37639, 0.37513, 0.36934,
0.37158, 0.36743, 0.36725, 0.36754, 0.36367, 0.36349, 0.36127, 0.35845, 0.35664, 0.35571, 0.34821, 0.35324, 0.34971,
0.34971, 0.35046, 0.34550, 0.34232, 0.34107, 0.33753, 0.34123, 0.33774, 0.33267, 0.33334, 0.32925, 0.32793, 0.32465,
0.32587, 0.32283, 0.32465, 0.31899, 0.31939, 0.31609, 0.31355, 0.31146, 0.30996, 0.30590, 0.30941, 0.30495, 0.30232,
0.30000, 0.30592, 0.30067, 0.29949, 0.29367, 0.29305, 0.29100, 0.28859, 0.28693, 0.28460, 0.28802, 0.28214, 0.28012,
0.27655, 0.27398, 0.27489, 0.27265, 0.27207, 0.27215, 0.26801, 0.27007, 0.26242, 0.26167, 0.25807, 0.26060, 0.25424,
0.25617, 0.25184, 0.25211, 0.24963, 0.24654, 0.24889, 0.24176, 0.24156, 0.24427, 0.23891, 0.23345, 0.23369, 0.23111,
0.22584, 0.22942, 0.22945, 0.22418, 0.22058, 0.22445, 0.21787, 0.22024, 0.22024, 0.21310, 0.21312, 0.21306, 0.21014,
0.21204, 0.20921, 0.20454, 0.20235, 0.20241, 0.19851, 0.20200, 0.19926, 0.19586, 0.19828, 0.19279, 0.19168, 0.18899,
0.18156, 0.18563, 0.18633, 0.18394, 0.18089, 0.17964, 0.17685, 0.17630, 0.17696, 0.17502, 0.17138, 0.17179, 0.17177,
0.16918, 0.16656, 0.16816, 0.16230, 0.16106, 0.15727, 0.15690, 0.15554, 0.15106, 0.15557, 0.14960, 0.15174, 0.14814,
0.14777, 0.14698, 0.14451, 0.14344, 0.14489, 0.14124, 0.14074, 0.13459, 0.13994, 0.13606, 0.13941, 0.13231, 0.13203,
0.12701, 0.13091, 0.12635, 0.12740, 0.12701, 0.12425, 0.12362, 0.12399, 0.12174, 0.12099, 0.11940, 0.11865, 0.11551,
0.11818, 0.11366, 0.11303, 0.11050, 0.10948, 0.11105, 0.10813, 0.11124, 0.10642, 0.10827, 0.11041, 0.10285, 0.10473,
0.09880, 0.10248, 0.09540, 0.09905, 0.09991, 0.09618, 0.09506, 0.09641, 0.09405, 0.09332, 0.09131, 0.09068, 0.09243,
0.08471, 0.08641, 0.08408, 0.08723, 0.08609, 0.08705, 0.08511, 0.08122, 0.08053, 0.07947, 0.07747, 0.08165, 0.07549,
0.07670, 0.07824, 0.07534, 0.07525, 0.07588, 0.07390, 0.07203, 0.07413, 0.07441, 0.06786, 0.07505, 0.06733, 0.06543,
0.06713, 0.06481, 0.06620, 0.06451, 0.06596, 0.06732, 0.06286, 0.06340, 0.06110, 0.06586, 0.05799, 0.06174, 0.05731,
0.06178, 0.05907, 0.05567, 0.05586, 0.05653, 0.05728, 0.05270, 0.05378, 0.05503, 0.05143, 0.05158, 0.05056, 0.04994,
0.04988, 0.04934, 0.05066, 0.04965, 0.04614, 0.04920, 0.04983, 0.04556, 0.04978, 0.04673, 0.04594, 0.04701, 0.04590,
0.04294, 0.04526, 0.04284, 0.04478, 0.04237, 0.03920, 0.03740, 0.03988, 0.04055, 0.03832, 0.03959, 0.03906, 0.03856,
0.03672, 0.03585, 0.03492, 0.03618, 0.03672, 0.03633, 0.03628, 0.03366, 0.03619, 0.03560, 0.03449, 0.03371, 0.03517,
0.03176, 0.03113, 0.03128, 0.03226, 0.03109, 0.03163, 0.02916, 0.02963, 0.03264, 0.03274, 0.02953, 0.02802, 0.02895,
0.02822, 0.03060, 0.02658, 0.02759, 0.02779, 0.02575, 0.02637, 0.02603, 0.02783, 0.02525, 0.02744, 0.02429, 0.02613,
0.02264, 0.02385, 0.02370, 0.02473, 0.02229, 0.02346, 0.02491, 0.02229, 0.02040, 0.02307, 0.02292, 0.02118, 0.02177,
0.02030, 0.02219, 0.01899, 0.02055, 0.01909, 0.01870, 0.01938, 0.01836, 0.01850, 0.01899, 0.01918, 0.01671, 0.01957,
0.01603, 0.01816, 0.01700, 0.01559, 0.01773, 0.01773, 0.01685, 0.01530, 0.01612, 0.01622, 0.01467, 0.01627, 0.01564,
0.01448, 0.01467, 0.01612, 0.01467, 0.01565, 0.01516, 0.01394, 0.01394, 0.01477, 0.01428, 0.01302, 0.01423, 0.01146,
0.01311, 0.01418, 0.01302, 0.01224, 0.01269, 0.01190, 0.01055, 0.01258, 0.01185, 0.01088, 0.01122, 0.01059, 0.01035,
0.01132, 0.00947, 0.01234, 0.00914, 0.01054, 0.01054, 0.00918, 0.00841, 0.00987, 0.01030, 0.00972, 0.01035, 0.00743,
0.00860, 0.00923, 0.00894, 0.00948, 0.00908, 0.00801, 0.00792, 0.00826, 0.00724, 0.00801, 0.00728, 0.00782, 0.00724,
0.00777, 0.00694, 0.00811, 0.00796, 0.00665, 0.00753, 0.00724, 0.00583, 0.00656, 0.00675, 0.00646, 0.00787, 0.00719,
0.00660, 0.00796, 0.00568, 0.00787, 0.00622, 0.00690, 0.00694, 0.00563, 0.00597, 0.00627, 0.00660, 0.00578, 0.00719,
0.00442, 0.00524, 0.00583, 0.00617, 0.00622, 0.00612, 0.00583, 0.00554, 0.00481, 0.00432, 0.00476, 0.00403, 0.00534,
0.00418, 0.00490, 0.00466, 0.00534, 0.00520, 0.00379, 0.00510, 0.00422, 0.00335, 0.00427, 0.00437, 0.00452, 0.00374,
0.00524, 0.00442, 0.00320, 0.00403, 0.00388, 0.00461, 0.00379, 0.00345, 0.00364 },
{ 0.96640, 0.96400, 0.96580, 0.96400, 0.96420, 0.96330, 0.95670, 0.96270, 0.95660, 0.95880, 0.95890, 0.95390, 0.95320,
0.95380, 0.95170, 0.94910, 0.94770, 0.94270, 0.94250, 0.94510, 0.93970, 0.94230, 0.93810, 0.93310, 0.93570, 0.93640,
0.93310, 0.92610, 0.92570, 0.92820, 0.92750, 0.92470, 0.91640, 0.91400, 0.91720, 0.91460, 0.91660, 0.91030, 0.90710,
0.90660, 0.90650, 0.90360, 0.91050, 0.89860, 0.89820, 0.89550, 0.89050, 0.88670, 0.88830, 0.88260, 0.88290, 0.87750,
0.88350, 0.87280, 0.87280, 0.86770, 0.86900, 0.86460, 0.86070, 0.86080, 0.85960, 0.85980, 0.85630, 0.84450, 0.85140,
0.84130, 0.83630, 0.83390, 0.83410, 0.83120, 0.82320, 0.82660, 0.83190, 0.82300, 0.81830, 0.81350, 0.80630, 0.80950,
0.81020, 0.80420, 0.79810, 0.79170, 0.78960, 0.78720, 0.78590, 0.78610, 0.78180, 0.77540, 0.77590, 0.77300, 0.76140,
0.76630, 0.75710, 0.75710, 0.75770, 0.74930, 0.74910, 0.74500, 0.73840, 0.73500, 0.73370, 0.71750, 0.72810, 0.72090,
0.72030, 0.72250, 0.71240, 0.70560, 0.70260, 0.69540, 0.70310, 0.69620, 0.68590, 0.68740, 0.67870, 0.67590, 0.66930,
0.67200, 0.66590, 0.66930, 0.65740, 0.65780, 0.65160, 0.64690, 0.64180, 0.63860, 0.63080, 0.63760, 0.62840, 0.62330,
0.61840, 0.63040, 0.61950, 0.61740, 0.60520, 0.60400, 0.60050, 0.59470, 0.59160, 0.58650, 0.59390, 0.58170, 0.57710,
0.57010, 0.56440, 0.56660, 0.56190, 0.56080, 0.56090, 0.55270, 0.55660, 0.54050, 0.53990, 0.53180, 0.53700, 0.52390,
0.52790, 0.51930, 0.51950, 0.51460, 0.50850, 0.51290, 0.49840, 0.49800, 0.50330, 0.49200, 0.48130, 0.48150, 0.47620,
0.46580, 0.47300, 0.47270, 0.46220, 0.45480, 0.46250, 0.44910, 0.45430, 0.45400, 0.43910, 0.43900, 0.43930, 0.43380,
0.43720, 0.43110, 0.42150, 0.41690, 0.41710, 0.40910, 0.41680, 0.41090, 0.40370, 0.40880, 0.39740, 0.39520, 0.38930,
0.37410, 0.38230, 0.38400, 0.37900, 0.37280, 0.37040, 0.36430, 0.36310, 0.36480, 0.36080, 0.35330, 0.35380, 0.35410,
0.34870, 0.34340, 0.34650, 0.33470, 0.33180, 0.32400, 0.32350, 0.32060, 0.31130, 0.32040, 0.30830, 0.31290, 0.30530,
0.30480, 0.30300, 0.29800, 0.29560, 0.29850, 0.29100, 0.29050, 0.27730, 0.28850, 0.28050, 0.28740, 0.27250, 0.27230,
0.26170, 0.26980, 0.26060, 0.26240, 0.26170, 0.25610, 0.25490, 0.25530, 0.25110, 0.24920, 0.24610, 0.24430, 0.23820,
0.24380, 0.23420, 0.23300, 0.22770, 0.22570, 0.22910, 0.22300, 0.22930, 0.21930, 0.22310, 0.22770, 0.21230, 0.21590,
0.20360, 0.21110, 0.19670, 0.20420, 0.20590, 0.19840, 0.19580, 0.19860, 0.19390, 0.19240, 0.18810, 0.18680, 0.19040,
0.17470, 0.17800, 0.17330, 0.17970, 0.17770, 0.17960, 0.17560, 0.16750, 0.16600, 0.16380, 0.15960, 0.16820, 0.15580,
0.15800, 0.16110, 0.15540, 0.15520, 0.15650, 0.15270, 0.14830, 0.15290, 0.15340, 0.13980, 0.15480, 0.13890, 0.13490,
0.13830, 0.13390, 0.13630, 0.13300, 0.13590, 0.13870, 0.12970, 0.13070, 0.12580, 0.13560, 0.11940, 0.12720, 0.11800,
0.12730, 0.12190, 0.11480, 0.11510, 0.11640, 0.11820, 0.10860, 0.11100, 0.11340, 0.10590, 0.10620, 0.10410, 0.10300,
0.10270, 0.10160, 0.10430, 0.10240, 0.09500, 0.10140, 0.10260, 0.09380, 0.10250, 0.09630, 0.09460, 0.09680, 0.09460,
0.08860, 0.09320, 0.08820, 0.09230, 0.08740, 0.08080, 0.07720, 0.08220, 0.08350, 0.07900, 0.08160, 0.08060, 0.07940,
0.07570, 0.07390, 0.07190, 0.07450, 0.07560, 0.07490, 0.07470, 0.06940, 0.07460, 0.07330, 0.07110, 0.06940, 0.07250,
0.06540, 0.06410, 0.06440, 0.06660, 0.06410, 0.06520, 0.06030, 0.06100, 0.06720, 0.06740, 0.06080, 0.05770, 0.05960,
0.05810, 0.06310, 0.05490, 0.05680, 0.05730, 0.05310, 0.05430, 0.05360, 0.05730, 0.05200, 0.05650, 0.05010, 0.05380,
0.04670, 0.04920, 0.04880, 0.05110, 0.04590, 0.04830, 0.05130, 0.04590, 0.04210, 0.04750, 0.04720, 0.04370, 0.04500,
0.04180, 0.04570, 0.03910, 0.04240, 0.03930, 0.03850, 0.03990, 0.03780, 0.03810, 0.03910, 0.03950, 0.03440, 0.04030,
0.03310, 0.03740, 0.03500, 0.03210, 0.03650, 0.03650, 0.03470, 0.03150, 0.03320, 0.03350, 0.03020, 0.03350, 0.03220,
0.02990, 0.03020, 0.03320, 0.03020, 0.03240, 0.03130, 0.02870, 0.02870, 0.03040, 0.02940, 0.02680, 0.02930, 0.02360,
0.02700, 0.02920, 0.02680, 0.02520, 0.02630, 0.02450, 0.02180, 0.02590, 0.02450, 0.02240, 0.02310, 0.02190, 0.02130,
0.02330, 0.01950, 0.02550, 0.01890, 0.02170, 0.02170, 0.01890, 0.01740, 0.02040, 0.02120, 0.02010, 0.02140, 0.01530,
0.01770, 0.01900, 0.01840, 0.01960, 0.01870, 0.01650, 0.01630, 0.01700, 0.01500, 0.01650, 0.01500, 0.01610, 0.01490,
0.01600, 0.01430, 0.01670, 0.01640, 0.01370, 0.01550, 0.01490, 0.01200, 0.01350, 0.01390, 0.01330, 0.01620, 0.01490,
0.01360, 0.01640, 0.01170, 0.01620, 0.01290, 0.01420, 0.01430, 0.01160, 0.01230, 0.01300, 0.01360, 0.01190, 0.01490,
0.00910, 0.01080, 0.01200, 0.01270, 0.01280, 0.01260, 0.01200, 0.01140, 0.00990, 0.00890, 0.00980, 0.00830, 0.01100,
0.00860, 0.01010, 0.00960, 0.01100, 0.01070, 0.00780, 0.01050, 0.00870, 0.00690, 0.00880, 0.00900, 0.00930, 0.00780,
0.01080, 0.00920, 0.00660, 0.00830, 0.00800, 0.00950, 0.00780, 0.00710, 0.00750 },
{ 0.03247, 0.03470, 0.03303, 0.03470, 0.03452, 0.03535, 0.04142, 0.03591, 0.04152, 0.03950, 0.03941, 0.04398, 0.04461,
0.04407, 0.04597, 0.04831, 0.04956, 0.05402, 0.05419, 0.05189, 0.05666, 0.05437, 0.05807, 0.06242, 0.06017, 0.05955,
0.06242, 0.06844, 0.06878, 0.06664, 0.06724, 0.06963, 0.07661, 0.07860, 0.07594, 0.07811, 0.07644, 0.08165, 0.08427,
0.08468, 0.08476, 0.08711, 0.08149, 0.09112, 0.09144, 0.09358, 0.09751, 0.10046, 0.09922, 0.10362, 0.10339, 0.10749,
0.10293, 0.11102, 0.11102, 0.11480, 0.11384, 0.11707, 0.11990, 0.11982, 0.12069, 0.12054, 0.12305, 0.13132, 0.12652,
0.13351, 0.13690, 0.13851, 0.13838, 0.14031, 0.14554, 0.14333, 0.13984, 0.14567, 0.14869, 0.15172, 0.15618, 0.15421,
0.15378, 0.15746, 0.16114, 0.16491, 0.16613, 0.16752, 0.16826, 0.16815, 0.17059, 0.17416, 0.17388, 0.17547, 0.18167,
0.17908, 0.18390, 0.18390, 0.18359, 0.18785, 0.18795, 0.18998, 0.19317, 0.19478, 0.19538, 0.20269, 0.19797, 0.20120,
0.20147, 0.20049, 0.20489, 0.20773, 0.20895, 0.21182, 0.20875, 0.21151, 0.21544, 0.21488, 0.21807, 0.21906, 0.22134,
0.22042, 0.22248, 0.22134, 0.22523, 0.22510, 0.22702, 0.22842, 0.22989, 0.23079, 0.23289, 0.23107, 0.23351, 0.23480,
0.23598, 0.23300, 0.23572, 0.23622, 0.23893, 0.23918, 0.23990, 0.24103, 0.24161, 0.24252, 0.24118, 0.24333, 0.24406,
0.24509, 0.24585, 0.24556, 0.24617, 0.24630, 0.24629, 0.24722, 0.24680, 0.24836, 0.24841, 0.24899, 0.24863, 0.24943,
0.24922, 0.24963, 0.24962, 0.24979, 0.24993, 0.24983, 0.25000, 0.25000, 0.24999, 0.24994, 0.24965, 0.24966, 0.24943,
0.24883, 0.24927, 0.24926, 0.24857, 0.24796, 0.24859, 0.24741, 0.24791, 0.24788, 0.24629, 0.24628, 0.24632, 0.24562,
0.24606, 0.24525, 0.24384, 0.24309, 0.24313, 0.24174, 0.24308, 0.24206, 0.24073, 0.24168, 0.23947, 0.23902, 0.23775,
0.23415, 0.23615, 0.23654, 0.23536, 0.23382, 0.23320, 0.23159, 0.23126, 0.23172, 0.23062, 0.22848, 0.22863, 0.22871,
0.22711, 0.22548, 0.22644, 0.22268, 0.22171, 0.21902, 0.21885, 0.21782, 0.21439, 0.21774, 0.21325, 0.21499, 0.21209,
0.21190, 0.21119, 0.20920, 0.20822, 0.20940, 0.20632, 0.20611, 0.20040, 0.20527, 0.20182, 0.20480, 0.19824, 0.19815,
0.19321, 0.19701, 0.19269, 0.19355, 0.19321, 0.19051, 0.18993, 0.19012, 0.18805, 0.18710, 0.18554, 0.18462, 0.18146,
0.18436, 0.17935, 0.17871, 0.17585, 0.17476, 0.17661, 0.17327, 0.17672, 0.17121, 0.17333, 0.17585, 0.16723, 0.16929,
0.16215, 0.16654, 0.15801, 0.16250, 0.16351, 0.15904, 0.15746, 0.15916, 0.15630, 0.15538, 0.15272, 0.15191, 0.15415,
0.14418, 0.14632, 0.14327, 0.14741, 0.14612, 0.14734, 0.14477, 0.13944, 0.13844, 0.13697, 0.13413, 0.13991, 0.13153,
0.13304, 0.13515, 0.13125, 0.13111, 0.13201, 0.12938, 0.12631, 0.12952, 0.12987, 0.12026, 0.13084, 0.11961, 0.11670,
0.11917, 0.11597, 0.11772, 0.11531, 0.11743, 0.11946, 0.11288, 0.11362, 0.10997, 0.11721, 0.10514, 0.11102, 0.10408,
0.11109, 0.10704, 0.10162, 0.10185, 0.10285, 0.10423, 0.09681, 0.09868, 0.10054, 0.09469, 0.09492, 0.09326, 0.09239,
0.09215, 0.09128, 0.09342, 0.09191, 0.08597, 0.09112, 0.09207, 0.08500, 0.09199, 0.08703, 0.08565, 0.08743, 0.08565,
0.08075, 0.08451, 0.08042, 0.08378, 0.07976, 0.07427, 0.07124, 0.07544, 0.07653, 0.07276, 0.07494, 0.07410, 0.07310,
0.06997, 0.06844, 0.06673, 0.06895, 0.06989, 0.06929, 0.06912, 0.06458, 0.06903, 0.06793, 0.06605, 0.06458, 0.06724,
0.06112, 0.05999, 0.06025, 0.06216, 0.05999, 0.06095, 0.05666, 0.05728, 0.06268, 0.06286, 0.05710, 0.05437, 0.05605,
0.05472, 0.05912, 0.05189, 0.05357, 0.05402, 0.05028, 0.05135, 0.05073, 0.05402, 0.04930, 0.05331, 0.04759, 0.05091,
0.04452, 0.04678, 0.04642, 0.04849, 0.04379, 0.04597, 0.04867, 0.04379, 0.04033, 0.04524, 0.04497, 0.04179, 0.04297,
0.04005, 0.04361, 0.03757, 0.04060, 0.03776, 0.03702, 0.03831, 0.03637, 0.03665, 0.03757, 0.03794, 0.03322, 0.03868,
0.03200, 0.03600, 0.03377, 0.03107, 0.03517, 0.03517, 0.03350, 0.03051, 0.03210, 0.03238, 0.02929, 0.03238, 0.03116,
0.02901, 0.02929, 0.03210, 0.02929, 0.03135, 0.03032, 0.02788, 0.02788, 0.02948, 0.02854, 0.02608, 0.02844, 0.02304,
0.02627, 0.02835, 0.02608, 0.02457, 0.02561, 0.02390, 0.02133, 0.02523, 0.02390, 0.02190, 0.02257, 0.02142, 0.02085,
0.02276, 0.01912, 0.02485, 0.01854, 0.02123, 0.02123, 0.01854, 0.01710, 0.01998, 0.02075, 0.01970, 0.02094, 0.01507,
0.01739, 0.01864, 0.01806, 0.01922, 0.01835, 0.01623, 0.01603, 0.01671, 0.01477, 0.01623, 0.01477, 0.01584, 0.01468,
0.01574, 0.01410, 0.01642, 0.01613, 0.01351, 0.01526, 0.01468, 0.01186, 0.01332, 0.01371, 0.01312, 0.01594, 0.01468,
0.01341, 0.01613, 0.01156, 0.01594, 0.01273, 0.01400, 0.01410, 0.01146, 0.01215, 0.01283, 0.01341, 0.01176, 0.01468,
0.00902, 0.01068, 0.01186, 0.01254, 0.01264, 0.01244, 0.01186, 0.01127, 0.00980, 0.00882, 0.00970, 0.00823, 0.01088,
0.00853, 0.01000, 0.00951, 0.01088, 0.01059, 0.00774, 0.01039, 0.00862, 0.00685, 0.00872, 0.00892, 0.00921, 0.00774,
0.01068, 0.00911, 0.00656, 0.00823, 0.00794, 0.00941, 0.00774, 0.00705, 0.00744 },
{ 0.96287, 0.96035, 0.96224, 0.96035, 0.96056, 0.95961, 0.95271, 0.95899, 0.95261, 0.95490, 0.95501, 0.94979, 0.94906,
0.94969, 0.94750, 0.94479, 0.94334, 0.93815, 0.93794, 0.94063, 0.93503, 0.93773, 0.93338, 0.92820, 0.93089, 0.93162,
0.92820, 0.92097, 0.92056, 0.92314, 0.92242, 0.91953, 0.91097, 0.90851, 0.91180, 0.90912, 0.91118, 0.90470, 0.90141,
0.90090, 0.90079, 0.89782, 0.90490, 0.89268, 0.89227, 0.88950, 0.88438, 0.88049, 0.88213, 0.87629, 0.87660, 0.87107,
0.87721, 0.86627, 0.86627, 0.86106, 0.86239, 0.85789, 0.85391, 0.85401, 0.85279, 0.85299, 0.84942, 0.83740, 0.84443,
0.83414, 0.82905, 0.82661, 0.82681, 0.82386, 0.81572, 0.81918, 0.82457, 0.81552, 0.81074, 0.80587, 0.79855, 0.80180,
0.80251, 0.79642, 0.79023, 0.78374, 0.78161, 0.77918, 0.77786, 0.77806, 0.77370, 0.76722, 0.76773, 0.76479, 0.75305,
0.75801, 0.74869, 0.74869, 0.74930, 0.74081, 0.74060, 0.73646, 0.72979, 0.72635, 0.72504, 0.70868, 0.71938, 0.71211,
0.71150, 0.71372, 0.70353, 0.69667, 0.69364, 0.68638, 0.69415, 0.68719, 0.67680, 0.67831, 0.66955, 0.66673, 0.66008,
0.66280, 0.65665, 0.66008, 0.64810, 0.64850, 0.64226, 0.63753, 0.63240, 0.62918, 0.62134, 0.62818, 0.61893, 0.61380,
0.60888, 0.62094, 0.60998, 0.60787, 0.59562, 0.59441, 0.59090, 0.58508, 0.58197, 0.57685, 0.58427, 0.57203, 0.56742,
0.56040, 0.55468, 0.55689, 0.55217, 0.55107, 0.55117, 0.54295, 0.54686, 0.53073, 0.53013, 0.52202, 0.52723, 0.51411,
0.51811, 0.50951, 0.50971, 0.50480, 0.49870, 0.50310, 0.48860, 0.48820, 0.49350, 0.48220, 0.47151, 0.47171, 0.46641,
0.45602, 0.46321, 0.46292, 0.45243, 0.44504, 0.45273, 0.43935, 0.44454, 0.44424, 0.42937, 0.42927, 0.42957, 0.42409,
0.42748, 0.42139, 0.41182, 0.40724, 0.40744, 0.39946, 0.40714, 0.40126, 0.39408, 0.39916, 0.38781, 0.38562, 0.37974,
0.36462, 0.37278, 0.37447, 0.36949, 0.36332, 0.36094, 0.35487, 0.35367, 0.35536, 0.35139, 0.34393, 0.34443, 0.34473,
0.33936, 0.33409, 0.33717, 0.32545, 0.32257, 0.31483, 0.31433, 0.31145, 0.30223, 0.31125, 0.29925, 0.30381, 0.29627,
0.29578, 0.29399, 0.28903, 0.28666, 0.28953, 0.28210, 0.28160, 0.26853, 0.27962, 0.27170, 0.27853, 0.26377, 0.26358,
0.25309, 0.26110, 0.25200, 0.25378, 0.25309, 0.24754, 0.24636, 0.24675, 0.24260, 0.24072, 0.23766, 0.23588, 0.22985,
0.23538, 0.22590, 0.22471, 0.21948, 0.21751, 0.22086, 0.21484, 0.22106, 0.21119, 0.21494, 0.21948, 0.20428, 0.20784,
0.19571, 0.20310, 0.18891, 0.19630, 0.19798, 0.19058, 0.18802, 0.19078, 0.18615, 0.18467, 0.18044, 0.17916, 0.18271,
0.16726, 0.17050, 0.16588, 0.17217, 0.17021, 0.17208, 0.16814, 0.16018, 0.15871, 0.15655, 0.15242, 0.16087, 0.14869,
0.15085, 0.15390, 0.14830, 0.14810, 0.14938, 0.14565, 0.14133, 0.14585, 0.14634, 0.13300, 0.14771, 0.13212, 0.12820,
0.13153, 0.12723, 0.12957, 0.12634, 0.12918, 0.13193, 0.12312, 0.12409, 0.11930, 0.12889, 0.11305, 0.12067, 0.11168,
0.12077, 0.11549, 0.10855, 0.10884, 0.11011, 0.11187, 0.10250, 0.10484, 0.10719, 0.09987, 0.10016, 0.09811, 0.09704,
0.09675, 0.09568, 0.09831, 0.09646, 0.08925, 0.09548, 0.09665, 0.08809, 0.09656, 0.09052, 0.08886, 0.09101, 0.08886,
0.08303, 0.08750, 0.08264, 0.08663, 0.08186, 0.07546, 0.07197, 0.07682, 0.07808, 0.07371, 0.07623, 0.07526, 0.07410,
0.07051, 0.06877, 0.06684, 0.06935, 0.07042, 0.06974, 0.06955, 0.06442, 0.06945, 0.06819, 0.06606, 0.06442, 0.06742,
0.06055, 0.05930, 0.05959, 0.06171, 0.05930, 0.06036, 0.05563, 0.05631, 0.06229, 0.06249, 0.05612, 0.05313, 0.05496,
0.05352, 0.05833, 0.05044, 0.05226, 0.05275, 0.04870, 0.04986, 0.04919, 0.05275, 0.04765, 0.05198, 0.04582, 0.04938,
0.04256, 0.04496, 0.04458, 0.04678, 0.04180, 0.04410, 0.04698, 0.04180, 0.03816, 0.04333, 0.04304, 0.03969, 0.04094,
0.03788, 0.04161, 0.03530, 0.03845, 0.03549, 0.03473, 0.03606, 0.03406, 0.03435, 0.03530, 0.03568, 0.03083, 0.03644,
0.02959, 0.03368, 0.03140, 0.02865, 0.03282, 0.03282, 0.03111, 0.02808, 0.02969, 0.02997, 0.02685, 0.02997, 0.02874,
0.02656, 0.02685, 0.02969, 0.02685, 0.02893, 0.02789, 0.02543, 0.02543, 0.02704, 0.02609, 0.02363, 0.02600, 0.02063,
0.02382, 0.02590, 0.02363, 0.02213, 0.02316, 0.02147, 0.01894, 0.02279, 0.02147, 0.01950, 0.02016, 0.01903, 0.01847,
0.02034, 0.01679, 0.02241, 0.01623, 0.01884, 0.01884, 0.01623, 0.01484, 0.01763, 0.01838, 0.01735, 0.01856, 0.01289,
0.01512, 0.01632, 0.01577, 0.01688, 0.01605, 0.01400, 0.01382, 0.01447, 0.01262, 0.01400, 0.01262, 0.01363, 0.01252,
0.01354, 0.01197, 0.01419, 0.01391, 0.01142, 0.01308, 0.01252, 0.00987, 0.01124, 0.01161, 0.01106, 0.01373, 0.01252,
0.01133, 0.01391, 0.00959, 0.01373, 0.01069, 0.01188, 0.01197, 0.00950, 0.01014, 0.01078, 0.01133, 0.00978, 0.01252,
0.00724, 0.00877, 0.00987, 0.01051, 0.01060, 0.01041, 0.00987, 0.00932, 0.00796, 0.00706, 0.00787, 0.00652, 0.00896,
0.00679, 0.00814, 0.00769, 0.00896, 0.00868, 0.00608, 0.00850, 0.00688, 0.00528, 0.00697, 0.00715, 0.00742, 0.00608,
0.00877, 0.00733, 0.00501, 0.00652, 0.00625, 0.00760, 0.00608, 0.00545, 0.00581 },
{ 0.96993, 0.96765, 0.96936, 0.96765, 0.96784, 0.96698, 0.96069, 0.96641, 0.96059, 0.96270, 0.96279, 0.95801, 0.95734,
0.95791, 0.95590, 0.95341, 0.95206, 0.94725, 0.94706, 0.94956, 0.94437, 0.94687, 0.94282, 0.93800, 0.94051, 0.94118,
0.93800, 0.93123, 0.93084, 0.93326, 0.93258, 0.92987, 0.92183, 0.91949, 0.92260, 0.92008, 0.92202, 0.91590, 0.91279,
0.91230, 0.91221, 0.90938, 0.91609, 0.90452, 0.90413, 0.90150, 0.89662, 0.89291, 0.89447, 0.88891, 0.88920, 0.88393,
0.88979, 0.87933, 0.87933, 0.87434, 0.87561, 0.87131, 0.86749, 0.86759, 0.86641, 0.86660, 0.86318, 0.85160, 0.85837,
0.84846, 0.84355, 0.84120, 0.84139, 0.83854, 0.83068, 0.83402, 0.83923, 0.83048, 0.82586, 0.82113, 0.81405, 0.81720,
0.81789, 0.81198, 0.80597, 0.79966, 0.79759, 0.79522, 0.79394, 0.79414, 0.78990, 0.78358, 0.78407, 0.78121, 0.76975,
0.77459, 0.76550, 0.76550, 0.76610, 0.75779, 0.75760, 0.75354, 0.74701, 0.74365, 0.74236, 0.72632, 0.73682, 0.72969,
0.72910, 0.73128, 0.72127, 0.71453, 0.71156, 0.70442, 0.71205, 0.70521, 0.69500, 0.69649, 0.68785, 0.68507, 0.67852,
0.68120, 0.67514, 0.67852, 0.66670, 0.66710, 0.66094, 0.65627, 0.65120, 0.64802, 0.64026, 0.64702, 0.63787, 0.63280,
0.62792, 0.63986, 0.62902, 0.62693, 0.61478, 0.61359, 0.61010, 0.60432, 0.60123, 0.59615, 0.60353, 0.59137, 0.58678,
0.57980, 0.57412, 0.57631, 0.57163, 0.57053, 0.57063, 0.56244, 0.56634, 0.55027, 0.54967, 0.54158, 0.54677, 0.53369,
0.53768, 0.52909, 0.52929, 0.52440, 0.51830, 0.52270, 0.50820, 0.50780, 0.51310, 0.50180, 0.49109, 0.49129, 0.48599,
0.47558, 0.48279, 0.48248, 0.47197, 0.46456, 0.47227, 0.45885, 0.46406, 0.46376, 0.44883, 0.44873, 0.44903, 0.44351,
0.44692, 0.44081, 0.43118, 0.42656, 0.42676, 0.41874, 0.42646, 0.42054, 0.41332, 0.41844, 0.40699, 0.40478, 0.39886,
0.38358, 0.39182, 0.39353, 0.38851, 0.38228, 0.37987, 0.37373, 0.37253, 0.37423, 0.37021, 0.36267, 0.36317, 0.36347,
0.35804, 0.35271, 0.35583, 0.34395, 0.34103, 0.33317, 0.33267, 0.32975, 0.32038, 0.32955, 0.31735, 0.32199, 0.31433,
0.31382, 0.31201, 0.30696, 0.30454, 0.30747, 0.29990, 0.29940, 0.28607, 0.29738, 0.28930, 0.29627, 0.28123, 0.28103,
0.27032, 0.27850, 0.26920, 0.27102, 0.27032, 0.26465, 0.26344, 0.26385, 0.25960, 0.25768, 0.25454, 0.25272, 0.24655,
0.25222, 0.24250, 0.24129, 0.23592, 0.23389, 0.23734, 0.23116, 0.23754, 0.22741, 0.23126, 0.23592, 0.22032, 0.22396,
0.21149, 0.21910, 0.20449, 0.21210, 0.21382, 0.20622, 0.20358, 0.20642, 0.20165, 0.20013, 0.19576, 0.19444, 0.19809,
0.18214, 0.18550, 0.18072, 0.18723, 0.18519, 0.18712, 0.18306, 0.17482, 0.17329, 0.17105, 0.16678, 0.17553, 0.16291,
0.16515, 0.16831, 0.16250, 0.16230, 0.16362, 0.15975, 0.15527, 0.15995, 0.16046, 0.14660, 0.16189, 0.14568, 0.14160,
0.14507, 0.14058, 0.14303, 0.13966, 0.14262, 0.14547, 0.13628, 0.13731, 0.13230, 0.14231, 0.12576, 0.13373, 0.12432,
0.13383, 0.12831, 0.12105, 0.12136, 0.12269, 0.12453, 0.11470, 0.11716, 0.11961, 0.11193, 0.11224, 0.11009, 0.10896,
0.10865, 0.10752, 0.11029, 0.10834, 0.10075, 0.10732, 0.10855, 0.09951, 0.10844, 0.10208, 0.10034, 0.10260, 0.10034,
0.09417, 0.09890, 0.09376, 0.09797, 0.09294, 0.08614, 0.08243, 0.08758, 0.08892, 0.08429, 0.08697, 0.08594, 0.08470,
0.08088, 0.07903, 0.07696, 0.07965, 0.08078, 0.08006, 0.07985, 0.07438, 0.07975, 0.07841, 0.07614, 0.07438, 0.07758,
0.07025, 0.06890, 0.06921, 0.07149, 0.06890, 0.07004, 0.06497, 0.06569, 0.07211, 0.07231, 0.06548, 0.06227, 0.06424,
0.06269, 0.06787, 0.05937, 0.06134, 0.06186, 0.05749, 0.05874, 0.05801, 0.06186, 0.05635, 0.06103, 0.05438, 0.05822,
0.05084, 0.05344, 0.05302, 0.05542, 0.05000, 0.05250, 0.05562, 0.05000, 0.04604, 0.05167, 0.05136, 0.04771, 0.04906,
0.04572, 0.04979, 0.04290, 0.04635, 0.04311, 0.04227, 0.04374, 0.04154, 0.04185, 0.04290, 0.04332, 0.03797, 0.04415,
0.03661, 0.04112, 0.03860, 0.03556, 0.04018, 0.04018, 0.03829, 0.03492, 0.03671, 0.03703, 0.03355, 0.03703, 0.03566,
0.03324, 0.03355, 0.03671, 0.03355, 0.03587, 0.03471, 0.03197, 0.03197, 0.03377, 0.03271, 0.02996, 0.03261, 0.02658,
0.03018, 0.03250, 0.02996, 0.02827, 0.02944, 0.02753, 0.02466, 0.02901, 0.02753, 0.02530, 0.02604, 0.02477, 0.02413,
0.02626, 0.02221, 0.02859, 0.02157, 0.02456, 0.02456, 0.02157, 0.01996, 0.02317, 0.02402, 0.02285, 0.02424, 0.01771,
0.02028, 0.02168, 0.02103, 0.02232, 0.02135, 0.01900, 0.01878, 0.01953, 0.01738, 0.01900, 0.01738, 0.01857, 0.01727,
0.01846, 0.01663, 0.01921, 0.01889, 0.01598, 0.01792, 0.01727, 0.01413, 0.01576, 0.01620, 0.01554, 0.01867, 0.01727,
0.01587, 0.01889, 0.01381, 0.01867, 0.01511, 0.01652, 0.01663, 0.01370, 0.01446, 0.01522, 0.01587, 0.01402, 0.01727,
0.01096, 0.01283, 0.01413, 0.01490, 0.01500, 0.01479, 0.01413, 0.01348, 0.01184, 0.01074, 0.01173, 0.01008, 0.01304,
0.01041, 0.01206, 0.01151, 0.01304, 0.01272, 0.00952, 0.01250, 0.01052, 0.00852, 0.01063, 0.01085, 0.01118, 0.00952,
0.01283, 0.01107, 0.00819, 0.01008, 0.00975, 0.01140, 0.00952, 0.00875, 0.00919 }
};
double modulation6[6][626] = {
{ 65.00, 65.10, 65.20, 65.30, 65.40, 65.50, 65.60, 65.70, 65.80, 65.90, 66.00, 66.10, 66.20, 66.30, 66.40, 66.50,
66.60, 66.70, 66.80, 66.90, 67.00, 67.10, 67.20, 67.30, 67.40, 67.50, 67.60, 67.70, 67.80, 67.90, 68.00, 68.10,
68.20, 68.30, 68.40, 68.50, 68.60, 68.70, 68.80, 68.90, 69.00, 69.10, 69.20, 69.30, 69.40, 69.50, 69.60, 69.70,
69.80, 69.90, 70.00, 70.10, 70.20, 70.30, 70.40, 70.50, 70.60, 70.70, 70.80, 70.90, 71.00, 71.10, 71.20, 71.30,
71.40, 71.50, 71.60, 71.70, 71.80, 71.90, 72.00, 72.10, 72.20, 72.30, 72.40, 72.50, 72.60, 72.70, 72.80, 72.90,
73.00, 73.10, 73.20, 73.30, 73.40, 73.50, 73.60, 73.70, 73.80, 73.90, 74.00, 74.10, 74.20, 74.30, 74.40, 74.50,
74.60, 74.70, 74.80, 74.90, 75.00, 75.10, 75.20, 75.30, 75.40, 75.50, 75.60, 75.70, 75.80, 75.90, 76.00, 76.10,
76.20, 76.30, 76.40, 76.50, 76.60, 76.70, 76.80, 76.90, 77.00, 77.10, 77.20, 77.30, 77.40, 77.50, 77.60, 77.70,
77.80, 77.90, 78.00, 78.10, 78.20, 78.30, 78.40, 78.50, 78.60, 78.70, 78.80, 78.90, 79.00, 79.10, 79.20, 79.30,
79.40, 79.50, 79.60, 79.70, 79.80, 79.90, 80.00, 80.10, 80.20, 80.30, 80.40, 80.50, 80.60, 80.70, 80.80, 80.90,
81.00, 81.10, 81.20, 81.30, 81.40, 81.50, 81.60, 81.70, 81.80, 81.90, 82.00, 82.10, 82.20, 82.30, 82.40, 82.50,
82.60, 82.70, 82.80, 82.90, 83.00, 83.10, 83.20, 83.30, 83.40, 83.50, 83.60, 83.70, 83.80, 83.90, 84.00, 84.10,
84.20, 84.30, 84.40, 84.50, 84.60, 84.70, 84.80, 84.90, 85.00, 85.10, 85.20, 85.30, 85.40, 85.50, 85.60, 85.70,
85.80, 85.90, 86.00, 86.10, 86.20, 86.30, 86.40, 86.50, 86.60, 86.70, 86.80, 86.90, 87.00, 87.10, 87.20, 87.30,
87.40, 87.50, 87.60, 87.70, 87.80, 87.90, 88.00, 88.10, 88.20, 88.30, 88.40, 88.50, 88.60, 88.70, 88.80, 88.90,
89.00, 89.10, 89.20, 89.30, 89.40, 89.50, 89.60, 89.70, 89.80, 89.90, 90.00, 90.10, 90.20, 90.30, 90.40, 90.50,
90.60, 90.70, 90.80, 90.90, 91.00, 91.10, 91.20, 91.30, 91.40, 91.50, 91.60, 91.70, 91.80, 91.90, 92.00, 92.10,
92.20, 92.30, 92.40, 92.50, 92.60, 92.70, 92.80, 92.90, 93.00, 93.10, 93.20, 93.30, 93.40, 93.50, 93.60, 93.70,
93.80, 93.90, 94.00, 94.10, 94.20, 94.30, 94.40, 94.50, 94.60, 94.70, 94.80, 94.90, 95.00, 95.10, 95.20, 95.30,
95.40, 95.50, 95.60, 95.70, 95.80, 95.90, 96.00, 96.10, 96.20, 96.30, 96.40, 96.50, 96.60, 96.70, 96.80, 96.90,
97.00, 97.10, 97.20, 97.30, 97.40, 97.50, 97.60, 97.70, 97.80, 97.90, 98.00, 98.10, 98.20, 98.30, 98.40, 98.50,
98.60, 98.70, 98.80, 98.90, 99.00, 99.10, 99.20, 99.30, 99.40, 99.50, 99.60, 99.70, 99.80, 99.90, 100.00, 100.10,
100.20, 100.30, 100.40, 100.50, 100.60, 100.70, 100.80, 100.90, 101.00, 101.10, 101.20, 101.30, 101.40, 101.50,
101.60, 101.70, 101.80, 101.90, 102.00, 102.10, 102.20, 102.30, 102.40, 102.50, 102.60, 102.70, 102.80, 102.90,
103.00, 103.10, 103.20, 103.30, 103.40, 103.50, 103.60, 103.70, 103.80, 103.90, 104.00, 104.10, 104.20, 104.30,
104.40, 104.50, 104.60, 104.70, 104.80, 104.90, 105.00, 105.10, 105.20, 105.30, 105.40, 105.50, 105.60, 105.70,
105.80, 105.90, 106.00, 106.10, 106.20, 106.30, 106.40, 106.50, 106.60, 106.70, 106.80, 106.90, 107.00, 107.10,
107.20, 107.30, 107.40, 107.50, 107.60, 107.70, 107.80, 107.90, 108.00, 108.10, 108.20, 108.30, 108.40, 108.50,
108.60, 108.70, 108.80, 108.90, 109.00, 109.10, 109.20, 109.30, 109.40, 109.50, 109.60, 109.70, 109.80, 109.90,
110.00, 110.10, 110.20, 110.30, 110.40, 110.50, 110.60, 110.70, 110.80, 110.90, 111.00, 111.10, 111.20, 111.30,
111.40, 111.50, 111.60, 111.70, 111.80, 111.90, 112.00, 112.10, 112.20, 112.30, 112.40, 112.50, 112.60, 112.70,
112.80, 112.90, 113.00, 113.10, 113.20, 113.30, 113.40, 113.50, 113.60, 113.70, 113.80, 113.90, 114.00, 114.10,
114.20, 114.30, 114.40, 114.50, 114.60, 114.70, 114.80, 114.90, 115.00, 115.10, 115.20, 115.30, 115.40, 115.50,
115.60, 115.70, 115.80, 115.90, 116.00, 116.10, 116.20, 116.30, 116.40, 116.50, 116.60, 116.70, 116.80, 116.90,
117.00, 117.10, 117.20, 117.30, 117.40, 117.50, 117.60, 117.70, 117.80, 117.90, 118.00, 118.10, 118.20, 118.30,
118.40, 118.50, 118.60, 118.70, 118.80, 118.90, 119.00, 119.10, 119.20, 119.30, 119.40, 119.50, 119.60, 119.70,
119.80, 119.90, 120.00, 120.10, 120.20, 120.30, 120.40, 120.50, 120.60, 120.70, 120.80, 120.90, 121.00, 121.10,
121.20, 121.30, 121.40, 121.50, 121.60, 121.70, 121.80, 121.90, 122.00, 122.10, 122.20, 122.30, 122.40, 122.50,
122.60, 122.70, 122.80, 122.90, 123.00, 124.00, 124.10, 124.20, 124.30, 124.40, 124.50, 124.60, 124.70, 124.80,
124.90, 125.00, 125.10, 125.20, 125.30, 125.40, 125.50, 125.60, 125.70 },
{ 0.46118, 0.46267, 0.46260, 0.46062, 0.45988, 0.45750, 0.46021, 0.45820, 0.45774, 0.45697, 0.45678, 0.45633, 0.45606,
0.45543, 0.45327, 0.45136, 0.45307, 0.45066, 0.45022, 0.45080, 0.45273, 0.44948, 0.44888, 0.44860, 0.44675, 0.44709,
0.44582, 0.44565, 0.44609, 0.44360, 0.44545, 0.44266, 0.44093, 0.43993, 0.44263, 0.43984, 0.44125, 0.43735, 0.43871,
0.43871, 0.43657, 0.43548, 0.43303, 0.43389, 0.43231, 0.43082, 0.42820, 0.43007, 0.42968, 0.42675, 0.42627, 0.42764,
0.42337, 0.42284, 0.42278, 0.42405, 0.42300, 0.42091, 0.42366, 0.41906, 0.41808, 0.41793, 0.41369, 0.41378, 0.41458,
0.40974, 0.41490, 0.40885, 0.40906, 0.40843, 0.40971, 0.40465, 0.40670, 0.40583, 0.40500, 0.40214, 0.39765, 0.39891,
0.39995, 0.39777, 0.39554, 0.39643, 0.39355, 0.39314, 0.39298, 0.39014, 0.39016, 0.38465, 0.38676, 0.38720, 0.38353,
0.38203, 0.38124, 0.37889, 0.37913, 0.38090, 0.37601, 0.37684, 0.37213, 0.37500, 0.36958, 0.37097, 0.36830, 0.36682,
0.36694, 0.36576, 0.36606, 0.36664, 0.36577, 0.35699, 0.35730, 0.36052, 0.35415, 0.35786, 0.35534, 0.35470, 0.35333,
0.34656, 0.34505, 0.34741, 0.34548, 0.34278, 0.34095, 0.34258, 0.34055, 0.33822, 0.34134, 0.33565, 0.33245, 0.33118,
0.33255, 0.33021, 0.33177, 0.32911, 0.32361, 0.32331, 0.32341, 0.31790, 0.32211, 0.31771, 0.31716, 0.31626, 0.31212,
0.31109, 0.31258, 0.31131, 0.30939, 0.30945, 0.30670, 0.30392, 0.30476, 0.29625, 0.29820, 0.29838, 0.29118, 0.29760,
0.29542, 0.29289, 0.29306, 0.29124, 0.28701, 0.29202, 0.28291, 0.28125, 0.28487, 0.28201, 0.28330, 0.27724, 0.27599,
0.27545, 0.27225, 0.26982, 0.27139, 0.27038, 0.26739, 0.27304, 0.26271, 0.26461, 0.26286, 0.26207, 0.25751, 0.25496,
0.25117, 0.25785, 0.25969, 0.25750, 0.25104, 0.24651, 0.24727, 0.24331, 0.24747, 0.24436, 0.24197, 0.24228, 0.23812,
0.23746, 0.24105, 0.23958, 0.23261, 0.23509, 0.23063, 0.22904, 0.22771, 0.22589, 0.22494, 0.22919, 0.21779, 0.22510,
0.22190, 0.22851, 0.22021, 0.21828, 0.21555, 0.21002, 0.21568, 0.21790, 0.21169, 0.20729, 0.20910, 0.20595, 0.20535,
0.20659, 0.20241, 0.19891, 0.20217, 0.19881, 0.19875, 0.19408, 0.19711, 0.19132, 0.19490, 0.19370, 0.19445, 0.18866,
0.19095, 0.18546, 0.18449, 0.18135, 0.18628, 0.18052, 0.18081, 0.18175, 0.17860, 0.18217, 0.17379, 0.17589, 0.17549,
0.17115, 0.17109, 0.16823, 0.16760, 0.16847, 0.16650, 0.16673, 0.16417, 0.15719, 0.16389, 0.16475, 0.16396, 0.15941,
0.15694, 0.15821, 0.15311, 0.15547, 0.15958, 0.15608, 0.15193, 0.15027, 0.15130, 0.15188, 0.14897, 0.14370, 0.14713,
0.14235, 0.13992, 0.13778, 0.14128, 0.14296, 0.13726, 0.13844, 0.13587, 0.13568, 0.13714, 0.13412, 0.13302, 0.13634,
0.13058, 0.13133, 0.13256, 0.12865, 0.12876, 0.12829, 0.12406, 0.12533, 0.12706, 0.12624, 0.11936, 0.11965, 0.11939,
0.11757, 0.11776, 0.11811, 0.11718, 0.11292, 0.11913, 0.10995, 0.11550, 0.11022, 0.11052, 0.10881, 0.10867, 0.10698,
0.10993, 0.10747, 0.10380, 0.10409, 0.10705, 0.10460, 0.10166, 0.10276, 0.10485, 0.09890, 0.10002, 0.09657, 0.09693,
0.09508, 0.09633, 0.09700, 0.09512, 0.09168, 0.09455, 0.09765, 0.09106, 0.09576, 0.09068, 0.09121, 0.09251, 0.08922,
0.08709, 0.08406, 0.08608, 0.08811, 0.08714, 0.08411, 0.08723, 0.08366, 0.08314, 0.08139, 0.08106, 0.08273, 0.07820,
0.08163, 0.07717, 0.07587, 0.07916, 0.07616, 0.07180, 0.07727, 0.07398, 0.07423, 0.07447, 0.07200, 0.07306, 0.06731,
0.07200, 0.06953, 0.07260, 0.07068, 0.06838, 0.06614, 0.06788, 0.06488, 0.06502, 0.06604, 0.06503, 0.06189, 0.06450,
0.06353, 0.06871, 0.06509, 0.06091, 0.06271, 0.06141, 0.05912, 0.06207, 0.05918, 0.05966, 0.05936, 0.05913, 0.05385,
0.05791, 0.05680, 0.05699, 0.05690, 0.05578, 0.05569, 0.05763, 0.05589, 0.05162, 0.05217, 0.05249, 0.05286, 0.05150,
0.05125, 0.05162, 0.04853, 0.05216, 0.04819, 0.05178, 0.04746, 0.04974, 0.05071, 0.04636, 0.04751, 0.04621, 0.04922,
0.04485, 0.04282, 0.04456, 0.04577, 0.04733, 0.04461, 0.04297, 0.03982, 0.04220, 0.04204, 0.04470, 0.03948, 0.04224,
0.03938, 0.04113, 0.03856, 0.03958, 0.03687, 0.03819, 0.03968, 0.03604, 0.03745, 0.03770, 0.03881, 0.03740, 0.03711,
0.03711, 0.03750, 0.03827, 0.03633, 0.03664, 0.03596, 0.03561, 0.03440, 0.03416, 0.03353, 0.03344, 0.03290, 0.03280,
0.03212, 0.03479, 0.03208, 0.03169, 0.03309, 0.03087, 0.03068, 0.03111, 0.03014, 0.03140, 0.03072, 0.03159, 0.02948,
0.02990, 0.03048, 0.03073, 0.02976, 0.02836, 0.03049, 0.02816, 0.02985, 0.02744, 0.02492, 0.02753, 0.02632, 0.02492,
0.02622, 0.02767, 0.02521, 0.02632, 0.02540, 0.02395, 0.02473, 0.02274, 0.02603, 0.02361, 0.02216, 0.02414, 0.02342,
0.02327, 0.02178, 0.02352, 0.02192, 0.02400, 0.02081, 0.02298, 0.01936, 0.02235, 0.02110, 0.02090, 0.02042, 0.02318,
0.02076, 0.01984, 0.01979, 0.02071, 0.01921, 0.02177, 0.02046, 0.01824, 0.01985, 0.01935, 0.01999, 0.01950, 0.02037,
0.01824, 0.01713, 0.01912, 0.01771, 0.01959, 0.01809, 0.01877, 0.01690, 0.01863, 0.01684, 0.01844, 0.01568, 0.01858,
0.01810, 0.01786, 0.01757, 0.01451, 0.01602, 0.01583, 0.01534, 0.01389, 0.01630, 0.01461, 0.01572, 0.01592, 0.01519,
0.01655, 0.01476, 0.01345, 0.01369, 0.01722, 0.01485, 0.01427, 0.01345, 0.01456, 0.01480, 0.01374, 0.01747, 0.01403,
0.01456, 0.01442, 0.01209, 0.01239, 0.01311, 0.01268, 0.01253, 0.01195, 0.01306, 0.01249, 0.01355, 0.01229, 0.01413,
0.01359, 0.01127, 0.01166, 0.01045, 0.01079, 0.01041, 0.01350, 0.01326, 0.01060, 0.00977, 0.00905, 0.00856, 0.01248,
0.00943, 0.00992, 0.00987, 0.01074, 0.00943, 0.01185, 0.01118, 0.00890, 0.00986, 0.00929, 0.00822, 0.00939, 0.00827,
0.00818 },
{ 0.95430, 0.95690, 0.95710, 0.95300, 0.95170, 0.94690, 0.95250, 0.94820, 0.94680, 0.94550, 0.94480, 0.94400, 0.94340,
0.94230, 0.93770, 0.93400, 0.93730, 0.93230, 0.93170, 0.93250, 0.93700, 0.93000, 0.92880, 0.92830, 0.92400, 0.92500,
0.92250, 0.92190, 0.92260, 0.91810, 0.92150, 0.91580, 0.91230, 0.91040, 0.91540, 0.91020, 0.91280, 0.90520, 0.90780,
0.90810, 0.90300, 0.90080, 0.89620, 0.89770, 0.89490, 0.89140, 0.88610, 0.88970, 0.88870, 0.88260, 0.88200, 0.88520,
0.87580, 0.87510, 0.87460, 0.87710, 0.87520, 0.87080, 0.87690, 0.86720, 0.86490, 0.86480, 0.85620, 0.85650, 0.85760,
0.84760, 0.85830, 0.84620, 0.84630, 0.84530, 0.84780, 0.83740, 0.84160, 0.83980, 0.83790, 0.83190, 0.82300, 0.82610,
0.82790, 0.82320, 0.81820, 0.82010, 0.81460, 0.81430, 0.81360, 0.80740, 0.80730, 0.79670, 0.80050, 0.80120, 0.79360,
0.79050, 0.78920, 0.78410, 0.78480, 0.78850, 0.77820, 0.78020, 0.77010, 0.77600, 0.76480, 0.76720, 0.76240, 0.75910,
0.75940, 0.75700, 0.75770, 0.75840, 0.75710, 0.73930, 0.73940, 0.74600, 0.73270, 0.74030, 0.73500, 0.73360, 0.73120,
0.71730, 0.71400, 0.71880, 0.71490, 0.70910, 0.70550, 0.70900, 0.70450, 0.70000, 0.70600, 0.69440, 0.68800, 0.68560,
0.68800, 0.68340, 0.68620, 0.68080, 0.66950, 0.66890, 0.66940, 0.65770, 0.66640, 0.65780, 0.65660, 0.65440, 0.64580,
0.64390, 0.64670, 0.64380, 0.64030, 0.64000, 0.63430, 0.62900, 0.63060, 0.61280, 0.61750, 0.61770, 0.60290, 0.61590,
0.61130, 0.60600, 0.60600, 0.60260, 0.59420, 0.60440, 0.58570, 0.58170, 0.58960, 0.58370, 0.58660, 0.57360, 0.57090,
0.56980, 0.56350, 0.55850, 0.56160, 0.55940, 0.55320, 0.56540, 0.54380, 0.54730, 0.54410, 0.54220, 0.53280, 0.52760,
0.51980, 0.53340, 0.53730, 0.53260, 0.51970, 0.50970, 0.51180, 0.50390, 0.51240, 0.50590, 0.50140, 0.50140, 0.49290,
0.49120, 0.49880, 0.49580, 0.48140, 0.48620, 0.47760, 0.47370, 0.47130, 0.46800, 0.46530, 0.47400, 0.45070, 0.46620,
0.45950, 0.47260, 0.45560, 0.45180, 0.44590, 0.43500, 0.44630, 0.45130, 0.43800, 0.42900, 0.43270, 0.42640, 0.42490,
0.42720, 0.41910, 0.41150, 0.41870, 0.41130, 0.41100, 0.40170, 0.40770, 0.39580, 0.40330, 0.40110, 0.40260, 0.39040,
0.39520, 0.38380, 0.38170, 0.37530, 0.38540, 0.37330, 0.37410, 0.37630, 0.36970, 0.37700, 0.35940, 0.36390, 0.36300,
0.35430, 0.35430, 0.34790, 0.34680, 0.34850, 0.34450, 0.34470, 0.33970, 0.32510, 0.33920, 0.34090, 0.33960, 0.33040,
0.32500, 0.32710, 0.31720, 0.32180, 0.33020, 0.32280, 0.31430, 0.31060, 0.31280, 0.31410, 0.30810, 0.29720, 0.30420,
0.29460, 0.28930, 0.28550, 0.29230, 0.29610, 0.28380, 0.28660, 0.28110, 0.28090, 0.28390, 0.27740, 0.27540, 0.28190,
0.27000, 0.27190, 0.27410, 0.26600, 0.26640, 0.26560, 0.25670, 0.25940, 0.26290, 0.26130, 0.24690, 0.24740, 0.24730,
0.24320, 0.24350, 0.24440, 0.24220, 0.23360, 0.24650, 0.22780, 0.23900, 0.22790, 0.22890, 0.22520, 0.22490, 0.22140,
0.22740, 0.22250, 0.21510, 0.21580, 0.22200, 0.21630, 0.21040, 0.21240, 0.21700, 0.20470, 0.20710, 0.19970, 0.20080,
0.19680, 0.19940, 0.20060, 0.19670, 0.18960, 0.19590, 0.20210, 0.18840, 0.19820, 0.18790, 0.18880, 0.19140, 0.18470,
0.18020, 0.17380, 0.17820, 0.18240, 0.18040, 0.17400, 0.18040, 0.17310, 0.17220, 0.16860, 0.16790, 0.17110, 0.16200,
0.16890, 0.15960, 0.15690, 0.16380, 0.15770, 0.14860, 0.15980, 0.15320, 0.15370, 0.15430, 0.14900, 0.15110, 0.13940,
0.14900, 0.14390, 0.15050, 0.14610, 0.14160, 0.13680, 0.14040, 0.13420, 0.13440, 0.13650, 0.13460, 0.12820, 0.13350,
0.13150, 0.14210, 0.13480, 0.12600, 0.12990, 0.12710, 0.12230, 0.12840, 0.12250, 0.12340, 0.12270, 0.12240, 0.11140,
0.11970, 0.11740, 0.11780, 0.11780, 0.11530, 0.11520, 0.11940, 0.11570, 0.10680, 0.10820, 0.10850, 0.10980, 0.10690,
0.10620, 0.10680, 0.10040, 0.10790, 0.09990, 0.10720, 0.09820, 0.10300, 0.10490, 0.09600, 0.09820, 0.09570, 0.10200,
0.09280, 0.08860, 0.09210, 0.09460, 0.09810, 0.09240, 0.08890, 0.08230, 0.08740, 0.08690, 0.09240, 0.08180, 0.08750,
0.08140, 0.08510, 0.07970, 0.08190, 0.07620, 0.07920, 0.08220, 0.07450, 0.07750, 0.07810, 0.08040, 0.07740, 0.07670,
0.07670, 0.07760, 0.07920, 0.07510, 0.07610, 0.07460, 0.07360, 0.07120, 0.07060, 0.06940, 0.06920, 0.06810, 0.06780,
0.06640, 0.07210, 0.06630, 0.06550, 0.06840, 0.06390, 0.06350, 0.06430, 0.06230, 0.06490, 0.06350, 0.06530, 0.06120,
0.06180, 0.06300, 0.06360, 0.06160, 0.05880, 0.06320, 0.05830, 0.06170, 0.05680, 0.05150, 0.05690, 0.05450, 0.05150,
0.05430, 0.05720, 0.05210, 0.05450, 0.05260, 0.04950, 0.05120, 0.04700, 0.05380, 0.04880, 0.04590, 0.05000, 0.04840,
0.04810, 0.04520, 0.04870, 0.04530, 0.04960, 0.04310, 0.04750, 0.04020, 0.04630, 0.04370, 0.04320, 0.04230, 0.04800,
0.04300, 0.04100, 0.04100, 0.04280, 0.03970, 0.04500, 0.04230, 0.03780, 0.04120, 0.04000, 0.04140, 0.04030, 0.04220,
0.03780, 0.03540, 0.03970, 0.03670, 0.04050, 0.03740, 0.03880, 0.03510, 0.03860, 0.03490, 0.03820, 0.03250, 0.03850,
0.03750, 0.03710, 0.03640, 0.03000, 0.03320, 0.03290, 0.03170, 0.02880, 0.03370, 0.03020, 0.03250, 0.03290, 0.03140,
0.03420, 0.03050, 0.02780, 0.02830, 0.03560, 0.03070, 0.02950, 0.02780, 0.03010, 0.03060, 0.02840, 0.03620, 0.02900,
0.03010, 0.02980, 0.02500, 0.02560, 0.02710, 0.02630, 0.02590, 0.02470, 0.02700, 0.02590, 0.02810, 0.02540, 0.02930,
0.02810, 0.02330, 0.02410, 0.02160, 0.02230, 0.02160, 0.02800, 0.02740, 0.02200, 0.02020, 0.01870, 0.01770, 0.02580,
0.01950, 0.02050, 0.02040, 0.02220, 0.01950, 0.02450, 0.02310, 0.01840, 0.02050, 0.01930, 0.01700, 0.01940, 0.01710,
0.01690 },
{ 0.04361, 0.04124, 0.04106, 0.04479, 0.04597, 0.05028, 0.04524, 0.04912, 0.05037, 0.05153, 0.05215, 0.05286, 0.05340,
0.05437, 0.05842, 0.06164, 0.05877, 0.06312, 0.06363, 0.06294, 0.05903, 0.06510, 0.06613, 0.06656, 0.07022, 0.06938,
0.07149, 0.07200, 0.07141, 0.07519, 0.07234, 0.07711, 0.08001, 0.08157, 0.07744, 0.08174, 0.07960, 0.08581, 0.08370,
0.08345, 0.08759, 0.08936, 0.09303, 0.09183, 0.09405, 0.09681, 0.10093, 0.09813, 0.09891, 0.10362, 0.10408, 0.10162,
0.10877, 0.10930, 0.10967, 0.10780, 0.10923, 0.11251, 0.10795, 0.11516, 0.11685, 0.11692, 0.12312, 0.12291, 0.12212,
0.12917, 0.12162, 0.13015, 0.13008, 0.13077, 0.12904, 0.13616, 0.13331, 0.13454, 0.13582, 0.13984, 0.14567, 0.14366,
0.14248, 0.14554, 0.14875, 0.14754, 0.15103, 0.15122, 0.15166, 0.15551, 0.15557, 0.16197, 0.15970, 0.15928, 0.16380,
0.16561, 0.16636, 0.16929, 0.16889, 0.16677, 0.17261, 0.17149, 0.17705, 0.17382, 0.17988, 0.17860, 0.18115, 0.18287,
0.18271, 0.18395, 0.18359, 0.18323, 0.18390, 0.19274, 0.19269, 0.18948, 0.19585, 0.19226, 0.19478, 0.19543, 0.19655,
0.20278, 0.20420, 0.20213, 0.20382, 0.20628, 0.20777, 0.20632, 0.20818, 0.21000, 0.20756, 0.21221, 0.21466, 0.21555,
0.21466, 0.21636, 0.21533, 0.21731, 0.22127, 0.22147, 0.22130, 0.22513, 0.22231, 0.22510, 0.22548, 0.22616, 0.22874,
0.22929, 0.22848, 0.22932, 0.23032, 0.23040, 0.23196, 0.23336, 0.23294, 0.23728, 0.23619, 0.23615, 0.23941, 0.23657,
0.23761, 0.23876, 0.23876, 0.23947, 0.24113, 0.23910, 0.24266, 0.24333, 0.24197, 0.24299, 0.24250, 0.24458, 0.24497,
0.24513, 0.24597, 0.24658, 0.24621, 0.24647, 0.24717, 0.24572, 0.24808, 0.24776, 0.24805, 0.24822, 0.24892, 0.24924,
0.24961, 0.24888, 0.24861, 0.24894, 0.24961, 0.24991, 0.24986, 0.24999, 0.24985, 0.24996, 0.25000, 0.25000, 0.24995,
0.24992, 0.25000, 0.24998, 0.24965, 0.24981, 0.24950, 0.24931, 0.24918, 0.24898, 0.24880, 0.24932, 0.24757, 0.24886,
0.24836, 0.24925, 0.24803, 0.24768, 0.24707, 0.24577, 0.24712, 0.24763, 0.24616, 0.24496, 0.24547, 0.24458, 0.24436,
0.24470, 0.24346, 0.24217, 0.24339, 0.24213, 0.24208, 0.24034, 0.24148, 0.23914, 0.24065, 0.24022, 0.24051, 0.23799,
0.23902, 0.23650, 0.23600, 0.23445, 0.23687, 0.23395, 0.23415, 0.23470, 0.23302, 0.23487, 0.23023, 0.23148, 0.23123,
0.22877, 0.22877, 0.22687, 0.22653, 0.22705, 0.22582, 0.22588, 0.22430, 0.21941, 0.22414, 0.22469, 0.22427, 0.22124,
0.21937, 0.22011, 0.21658, 0.21824, 0.22117, 0.21860, 0.21552, 0.21413, 0.21496, 0.21544, 0.21317, 0.20887, 0.21166,
0.20781, 0.20561, 0.20399, 0.20686, 0.20842, 0.20326, 0.20446, 0.20208, 0.20200, 0.20330, 0.20045, 0.19956, 0.20243,
0.19710, 0.19797, 0.19897, 0.19524, 0.19543, 0.19506, 0.19081, 0.19211, 0.19378, 0.19302, 0.18594, 0.18619, 0.18614,
0.18405, 0.18421, 0.18467, 0.18354, 0.17903, 0.18574, 0.17591, 0.18188, 0.17596, 0.17650, 0.17449, 0.17432, 0.17238,
0.17569, 0.17299, 0.16883, 0.16923, 0.17272, 0.16951, 0.16613, 0.16729, 0.16991, 0.16280, 0.16421, 0.15982, 0.16048,
0.15807, 0.15964, 0.16036, 0.15801, 0.15365, 0.15752, 0.16126, 0.15291, 0.15892, 0.15259, 0.15316, 0.15477, 0.15059,
0.14773, 0.14359, 0.14644, 0.14913, 0.14786, 0.14372, 0.14786, 0.14314, 0.14255, 0.14017, 0.13971, 0.14183, 0.13576,
0.14037, 0.13413, 0.13228, 0.13697, 0.13283, 0.12652, 0.13426, 0.12973, 0.13008, 0.13049, 0.12680, 0.12827, 0.11997,
0.12680, 0.12319, 0.12785, 0.12476, 0.12155, 0.11809, 0.12069, 0.11619, 0.11634, 0.11787, 0.11648, 0.11177, 0.11568,
0.11421, 0.12191, 0.11663, 0.11012, 0.11303, 0.11095, 0.10734, 0.11191, 0.10749, 0.10817, 0.10765, 0.10742, 0.09899,
0.10537, 0.10362, 0.10392, 0.10392, 0.10201, 0.10193, 0.10514, 0.10231, 0.09539, 0.09649, 0.09673, 0.09774, 0.09547,
0.09492, 0.09539, 0.09032, 0.09626, 0.08992, 0.09571, 0.08856, 0.09239, 0.09390, 0.08678, 0.08856, 0.08654, 0.09160,
0.08419, 0.08075, 0.08362, 0.08565, 0.08848, 0.08386, 0.08100, 0.07553, 0.07976, 0.07935, 0.08386, 0.07511, 0.07984,
0.07477, 0.07786, 0.07335, 0.07519, 0.07039, 0.07293, 0.07544, 0.06895, 0.07149, 0.07200, 0.07394, 0.07141, 0.07082,
0.07082, 0.07158, 0.07293, 0.06946, 0.07031, 0.06903, 0.06818, 0.06613, 0.06562, 0.06458, 0.06441, 0.06346, 0.06320,
0.06199, 0.06690, 0.06190, 0.06121, 0.06372, 0.05982, 0.05947, 0.06017, 0.05842, 0.06069, 0.05947, 0.06104, 0.05745,
0.05798, 0.05903, 0.05955, 0.05781, 0.05534, 0.05921, 0.05490, 0.05789, 0.05357, 0.04885, 0.05366, 0.05153, 0.04885,
0.05135, 0.05393, 0.04939, 0.05153, 0.04983, 0.04705, 0.04858, 0.04479, 0.05091, 0.04642, 0.04379, 0.04750, 0.04606,
0.04579, 0.04316, 0.04633, 0.04325, 0.04714, 0.04124, 0.04524, 0.03858, 0.04416, 0.04179, 0.04133, 0.04051, 0.04570,
0.04115, 0.03932, 0.03932, 0.04097, 0.03812, 0.04297, 0.04051, 0.03637, 0.03950, 0.03840, 0.03969, 0.03868, 0.04042,
0.03637, 0.03415, 0.03812, 0.03535, 0.03886, 0.03600, 0.03730, 0.03387, 0.03711, 0.03368, 0.03674, 0.03144, 0.03702,
0.03609, 0.03572, 0.03508, 0.02910, 0.03210, 0.03182, 0.03070, 0.02797, 0.03256, 0.02929, 0.03144, 0.03182, 0.03041,
0.03303, 0.02957, 0.02703, 0.02750, 0.03433, 0.02976, 0.02863, 0.02703, 0.02919, 0.02966, 0.02759, 0.03489, 0.02816,
0.02919, 0.02891, 0.02438, 0.02494, 0.02637, 0.02561, 0.02523, 0.02409, 0.02627, 0.02523, 0.02731, 0.02475, 0.02844,
0.02731, 0.02276, 0.02352, 0.02113, 0.02180, 0.02113, 0.02722, 0.02665, 0.02152, 0.01979, 0.01835, 0.01739, 0.02513,
0.01912, 0.02008, 0.01998, 0.02171, 0.01912, 0.02390, 0.02257, 0.01806, 0.02008, 0.01893, 0.01671, 0.01902, 0.01681,
0.01661 },
{ 0.95021, 0.95292, 0.95313, 0.94885, 0.94750, 0.94251, 0.94833, 0.94386, 0.94240, 0.94105, 0.94032, 0.93949, 0.93887,
0.93773, 0.93296, 0.92913, 0.93255, 0.92738, 0.92676, 0.92758, 0.93224, 0.92500, 0.92376, 0.92324, 0.91881, 0.91984,
0.91726, 0.91664, 0.91736, 0.91273, 0.91623, 0.91036, 0.90676, 0.90480, 0.90995, 0.90460, 0.90727, 0.89946, 0.90213,
0.90244, 0.89720, 0.89494, 0.89022, 0.89176, 0.88889, 0.88530, 0.87987, 0.88356, 0.88254, 0.87629, 0.87568, 0.87895,
0.86934, 0.86862, 0.86811, 0.87067, 0.86872, 0.86423, 0.87046, 0.86055, 0.85820, 0.85810, 0.84932, 0.84963, 0.85075,
0.84056, 0.85147, 0.83913, 0.83923, 0.83821, 0.84076, 0.83017, 0.83444, 0.83261, 0.83068, 0.82457, 0.81552, 0.81867,
0.82050, 0.81572, 0.81064, 0.81257, 0.80698, 0.80668, 0.80597, 0.79967, 0.79957, 0.78881, 0.79267, 0.79338, 0.78567,
0.78252, 0.78121, 0.77604, 0.77675, 0.78050, 0.77006, 0.77208, 0.76185, 0.76783, 0.75649, 0.75892, 0.75406, 0.75072,
0.75102, 0.74859, 0.74930, 0.75001, 0.74869, 0.73069, 0.73080, 0.73747, 0.72403, 0.73171, 0.72635, 0.72493, 0.72251,
0.70847, 0.70514, 0.70999, 0.70605, 0.70020, 0.69657, 0.70010, 0.69556, 0.69102, 0.69707, 0.68537, 0.67892, 0.67650,
0.67892, 0.67428, 0.67710, 0.67166, 0.66028, 0.65968, 0.66018, 0.64840, 0.65716, 0.64850, 0.64729, 0.64508, 0.63643,
0.63452, 0.63733, 0.63441, 0.63089, 0.63059, 0.62486, 0.61953, 0.62114, 0.60325, 0.60797, 0.60818, 0.59331, 0.60637,
0.60175, 0.59642, 0.59642, 0.59301, 0.58457, 0.59482, 0.57605, 0.57203, 0.57996, 0.57404, 0.57695, 0.56391, 0.56120,
0.56010, 0.55378, 0.54877, 0.55188, 0.54967, 0.54346, 0.55568, 0.53404, 0.53754, 0.53434, 0.53243, 0.52302, 0.51782,
0.51001, 0.52362, 0.52753, 0.52282, 0.50991, 0.49990, 0.50200, 0.49410, 0.50260, 0.49610, 0.49160, 0.49160, 0.48310,
0.48140, 0.48900, 0.48600, 0.47161, 0.47640, 0.46781, 0.46391, 0.46152, 0.45822, 0.45552, 0.46421, 0.44095, 0.45642,
0.44973, 0.46281, 0.44584, 0.44205, 0.43616, 0.42528, 0.43656, 0.44155, 0.42828, 0.41930, 0.42299, 0.41671, 0.41521,
0.41750, 0.40943, 0.40186, 0.40903, 0.40165, 0.40136, 0.39209, 0.39807, 0.38621, 0.39369, 0.39149, 0.39299, 0.38084,
0.38562, 0.37427, 0.37218, 0.36581, 0.37586, 0.36382, 0.36462, 0.36680, 0.36024, 0.36750, 0.35000, 0.35447, 0.35357,
0.34492, 0.34492, 0.33856, 0.33747, 0.33916, 0.33519, 0.33538, 0.33042, 0.31592, 0.32992, 0.33161, 0.33032, 0.32118,
0.31582, 0.31790, 0.30808, 0.31264, 0.32098, 0.31364, 0.30520, 0.30153, 0.30371, 0.30500, 0.29905, 0.28824, 0.29518,
0.28567, 0.28041, 0.27665, 0.28339, 0.28715, 0.27496, 0.27774, 0.27229, 0.27209, 0.27506, 0.26863, 0.26664, 0.27308,
0.26130, 0.26318, 0.26536, 0.25734, 0.25773, 0.25694, 0.24814, 0.25081, 0.25427, 0.25269, 0.23845, 0.23894, 0.23884,
0.23479, 0.23509, 0.23598, 0.23380, 0.22531, 0.23805, 0.21958, 0.23064, 0.21968, 0.22067, 0.21701, 0.21672, 0.21326,
0.21918, 0.21435, 0.20705, 0.20774, 0.21385, 0.20823, 0.20241, 0.20438, 0.20892, 0.19679, 0.19916, 0.19186, 0.19295,
0.18901, 0.19157, 0.19275, 0.18891, 0.18192, 0.18812, 0.19423, 0.18074, 0.19039, 0.18024, 0.18113, 0.18369, 0.17709,
0.17267, 0.16637, 0.17070, 0.17483, 0.17286, 0.16657, 0.17286, 0.16568, 0.16480, 0.16126, 0.16057, 0.16372, 0.15478,
0.16156, 0.15242, 0.14977, 0.15655, 0.15056, 0.14163, 0.15262, 0.14614, 0.14663, 0.14722, 0.14202, 0.14408, 0.13261,
0.14202, 0.13702, 0.14349, 0.13918, 0.13477, 0.13006, 0.13359, 0.12752, 0.12771, 0.12977, 0.12791, 0.12165, 0.12683,
0.12488, 0.13526, 0.12811, 0.11950, 0.12331, 0.12057, 0.11588, 0.12184, 0.11607, 0.11695, 0.11627, 0.11598, 0.10523,
0.11334, 0.11109, 0.11148, 0.11148, 0.10904, 0.10894, 0.11305, 0.10943, 0.10075, 0.10211, 0.10240, 0.10367, 0.10084,
0.10016, 0.10075, 0.09451, 0.10182, 0.09402, 0.10114, 0.09237, 0.09704, 0.09889, 0.09023, 0.09237, 0.08993, 0.09607,
0.08711, 0.08303, 0.08643, 0.08886, 0.09227, 0.08672, 0.08332, 0.07691, 0.08186, 0.08138, 0.08672, 0.07643, 0.08196,
0.07604, 0.07963, 0.07439, 0.07652, 0.07100, 0.07391, 0.07682, 0.06935, 0.07226, 0.07284, 0.07507, 0.07216, 0.07148,
0.07148, 0.07236, 0.07391, 0.06993, 0.07090, 0.06945, 0.06848, 0.06616, 0.06558, 0.06442, 0.06423, 0.06316, 0.06287,
0.06152, 0.06703, 0.06142, 0.06065, 0.06345, 0.05911, 0.05872, 0.05949, 0.05756, 0.06007, 0.05872, 0.06046, 0.05650,
0.05708, 0.05824, 0.05882, 0.05689, 0.05419, 0.05843, 0.05371, 0.05698, 0.05226, 0.04717, 0.05236, 0.05005, 0.04717,
0.04986, 0.05265, 0.04774, 0.05005, 0.04822, 0.04525, 0.04688, 0.04285, 0.04938, 0.04458, 0.04180, 0.04573, 0.04419,
0.04391, 0.04113, 0.04448, 0.04122, 0.04535, 0.03912, 0.04333, 0.03635, 0.04218, 0.03969, 0.03921, 0.03836, 0.04381,
0.03902, 0.03711, 0.03711, 0.03883, 0.03587, 0.04094, 0.03836, 0.03406, 0.03730, 0.03616, 0.03750, 0.03644, 0.03826,
0.03406, 0.03178, 0.03587, 0.03302, 0.03664, 0.03368, 0.03501, 0.03149, 0.03482, 0.03130, 0.03444, 0.02902, 0.03473,
0.03378, 0.03340, 0.03273, 0.02666, 0.02969, 0.02940, 0.02827, 0.02552, 0.03016, 0.02685, 0.02902, 0.02940, 0.02798,
0.03064, 0.02713, 0.02458, 0.02505, 0.03197, 0.02732, 0.02618, 0.02458, 0.02675, 0.02722, 0.02514, 0.03254, 0.02571,
0.02675, 0.02647, 0.02194, 0.02250, 0.02392, 0.02316, 0.02279, 0.02166, 0.02382, 0.02279, 0.02486, 0.02232, 0.02600,
0.02486, 0.02034, 0.02109, 0.01875, 0.01941, 0.01875, 0.02477, 0.02420, 0.01912, 0.01744, 0.01605, 0.01512, 0.02269,
0.01679, 0.01772, 0.01763, 0.01931, 0.01679, 0.02147, 0.02016, 0.01577, 0.01772, 0.01660, 0.01447, 0.01670, 0.01456,
0.01437 },
{ 0.95839, 0.96088, 0.96107, 0.95715, 0.95590, 0.95130, 0.95667, 0.95254, 0.95120, 0.94995, 0.94928, 0.94851, 0.94793,
0.94687, 0.94244, 0.93887, 0.94205, 0.93722, 0.93664, 0.93742, 0.94176, 0.93500, 0.93384, 0.93336, 0.92919, 0.93016,
0.92774, 0.92716, 0.92784, 0.92348, 0.92677, 0.92124, 0.91784, 0.91600, 0.92085, 0.91580, 0.91833, 0.91094, 0.91347,
0.91376, 0.90880, 0.90666, 0.90218, 0.90364, 0.90091, 0.89750, 0.89233, 0.89584, 0.89486, 0.88891, 0.88832, 0.89145,
0.88226, 0.88158, 0.88109, 0.88353, 0.88168, 0.87737, 0.88334, 0.87385, 0.87160, 0.87150, 0.86308, 0.86337, 0.86445,
0.85464, 0.86513, 0.85327, 0.85337, 0.85239, 0.85484, 0.84463, 0.84876, 0.84699, 0.84512, 0.83923, 0.83048, 0.83353,
0.83530, 0.83068, 0.82576, 0.82763, 0.82222, 0.82192, 0.82123, 0.81513, 0.81503, 0.80459, 0.80833, 0.80902, 0.80153,
0.79848, 0.79719, 0.79216, 0.79285, 0.79650, 0.78634, 0.78832, 0.77835, 0.78417, 0.77311, 0.77548, 0.77074, 0.76748,
0.76778, 0.76541, 0.76610, 0.76679, 0.76550, 0.74791, 0.74800, 0.75453, 0.74137, 0.74889, 0.74365, 0.74226, 0.73989,
0.72613, 0.72286, 0.72761, 0.72375, 0.71800, 0.71443, 0.71790, 0.71344, 0.70898, 0.71493, 0.70343, 0.69708, 0.69470,
0.69708, 0.69252, 0.69529, 0.68994, 0.67872, 0.67812, 0.67862, 0.66700, 0.67564, 0.66710, 0.66591, 0.66372, 0.65517,
0.65329, 0.65607, 0.65319, 0.64971, 0.64941, 0.64374, 0.63847, 0.64006, 0.62235, 0.62703, 0.62723, 0.61249, 0.62543,
0.62085, 0.61558, 0.61558, 0.61219, 0.60382, 0.61398, 0.59535, 0.59137, 0.59924, 0.59336, 0.59625, 0.58329, 0.58060,
0.57950, 0.57322, 0.56823, 0.57132, 0.56913, 0.56294, 0.57512, 0.55356, 0.55706, 0.55386, 0.55197, 0.54258, 0.53739,
0.52959, 0.54318, 0.54707, 0.54238, 0.52949, 0.51950, 0.52160, 0.51370, 0.52220, 0.51570, 0.51120, 0.51120, 0.50270,
0.50100, 0.50860, 0.50560, 0.49119, 0.49600, 0.48739, 0.48349, 0.48108, 0.47778, 0.47508, 0.48379, 0.46045, 0.47598,
0.46927, 0.48239, 0.46536, 0.46155, 0.45564, 0.44472, 0.45604, 0.46105, 0.44772, 0.43870, 0.44241, 0.43609, 0.43459,
0.43690, 0.42877, 0.42114, 0.42837, 0.42095, 0.42064, 0.41131, 0.41733, 0.40538, 0.41291, 0.41071, 0.41221, 0.39996,
0.40478, 0.39333, 0.39122, 0.38479, 0.39494, 0.38278, 0.38358, 0.38579, 0.37916, 0.38650, 0.36880, 0.37333, 0.37243,
0.36368, 0.36368, 0.35724, 0.35613, 0.35784, 0.35381, 0.35402, 0.34898, 0.33428, 0.34848, 0.35019, 0.34888, 0.33962,
0.33418, 0.33630, 0.32632, 0.33096, 0.33942, 0.33196, 0.32340, 0.31967, 0.32189, 0.32320, 0.31715, 0.30616, 0.31322,
0.30353, 0.29819, 0.29435, 0.30121, 0.30505, 0.29264, 0.29546, 0.28991, 0.28971, 0.29274, 0.28618, 0.28416, 0.29072,
0.27870, 0.28062, 0.28284, 0.27466, 0.27507, 0.27426, 0.26526, 0.26799, 0.27153, 0.26991, 0.25535, 0.25586, 0.25576,
0.25161, 0.25191, 0.25282, 0.25060, 0.24189, 0.25495, 0.23602, 0.24736, 0.23612, 0.23713, 0.23339, 0.23308, 0.22954,
0.23561, 0.23065, 0.22315, 0.22386, 0.23015, 0.22437, 0.21839, 0.22042, 0.22508, 0.21261, 0.21504, 0.20754, 0.20865,
0.20459, 0.20723, 0.20845, 0.20449, 0.19728, 0.20368, 0.20997, 0.19606, 0.20601, 0.19556, 0.19647, 0.19911, 0.19231,
0.18773, 0.18123, 0.18570, 0.18997, 0.18794, 0.18143, 0.18794, 0.18052, 0.17960, 0.17594, 0.17523, 0.17848, 0.16922,
0.17624, 0.16678, 0.16403, 0.17105, 0.16484, 0.15557, 0.16698, 0.16026, 0.16077, 0.16138, 0.15598, 0.15812, 0.14619,
0.15598, 0.15078, 0.15751, 0.15302, 0.14843, 0.14353, 0.14721, 0.14088, 0.14108, 0.14323, 0.14129, 0.13475, 0.14017,
0.13812, 0.14894, 0.14149, 0.13250, 0.13649, 0.13363, 0.12872, 0.13496, 0.12893, 0.12985, 0.12913, 0.12882, 0.11757,
0.12606, 0.12371, 0.12412, 0.12412, 0.12156, 0.12146, 0.12576, 0.12197, 0.11285, 0.11429, 0.11460, 0.11593, 0.11296,
0.11224, 0.11285, 0.10629, 0.11398, 0.10578, 0.11326, 0.10403, 0.10896, 0.11091, 0.10177, 0.10403, 0.10147, 0.10793,
0.09849, 0.09417, 0.09777, 0.10034, 0.10393, 0.09808, 0.09448, 0.08769, 0.09294, 0.09242, 0.09808, 0.08717, 0.09304,
0.08676, 0.09057, 0.08501, 0.08728, 0.08140, 0.08449, 0.08758, 0.07965, 0.08274, 0.08336, 0.08573, 0.08264, 0.08192,
0.08192, 0.08284, 0.08449, 0.08027, 0.08130, 0.07975, 0.07872, 0.07624, 0.07562, 0.07438, 0.07417, 0.07304, 0.07273,
0.07128, 0.07717, 0.07118, 0.07035, 0.07335, 0.06869, 0.06828, 0.06911, 0.06704, 0.06973, 0.06828, 0.07014, 0.06590,
0.06652, 0.06776, 0.06838, 0.06631, 0.06341, 0.06797, 0.06289, 0.06642, 0.06134, 0.05583, 0.06144, 0.05895, 0.05583,
0.05874, 0.06175, 0.05646, 0.05895, 0.05697, 0.05375, 0.05552, 0.05115, 0.05822, 0.05302, 0.05000, 0.05427, 0.05261,
0.05229, 0.04927, 0.05292, 0.04938, 0.05386, 0.04708, 0.05167, 0.04405, 0.05042, 0.04771, 0.04718, 0.04625, 0.05219,
0.04698, 0.04489, 0.04489, 0.04677, 0.04353, 0.04906, 0.04625, 0.04154, 0.04510, 0.04384, 0.04530, 0.04415, 0.04614,
0.04154, 0.03902, 0.04353, 0.04038, 0.04436, 0.04112, 0.04258, 0.03871, 0.04238, 0.03850, 0.04196, 0.03598, 0.04227,
0.04122, 0.04081, 0.04007, 0.03334, 0.03671, 0.03640, 0.03513, 0.03208, 0.03724, 0.03355, 0.03598, 0.03640, 0.03482,
0.03776, 0.03387, 0.03102, 0.03155, 0.03923, 0.03408, 0.03282, 0.03102, 0.03345, 0.03398, 0.03166, 0.03986, 0.03229,
0.03345, 0.03313, 0.02806, 0.02870, 0.03028, 0.02944, 0.02901, 0.02774, 0.03018, 0.02901, 0.03134, 0.02848, 0.03261,
0.03134, 0.02626, 0.02711, 0.02445, 0.02519, 0.02445, 0.03123, 0.03060, 0.02488, 0.02296, 0.02135, 0.02028, 0.02891,
0.02221, 0.02328, 0.02317, 0.02509, 0.02221, 0.02753, 0.02604, 0.02103, 0.02328, 0.02200, 0.01953, 0.02210, 0.01964,
0.01943 }
};
#endif /* WIMAX_DEFAULT_TRACES_H */
| zy901002-gpsr | src/wimax/model/default-traces.h | C | gpl2 | 85,332 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 INRIA
* 2009 TELEMATICS LAB, Politecnico di Bari
*
* 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: Giuseppe Piro <g.piro@poliba.it>
*/
/* BS outbound scheduler as per in Section 6.3.5.1 */
#ifndef BS_SCHEDULER_RTPS_H
#define BS_SCHEDULER_RTPS_H
#include <list>
#include "ns3/packet.h"
#include "wimax-phy.h"
#include "ns3/packet-burst.h"
#include "dl-mac-messages.h"
#include "bs-scheduler.h"
namespace ns3 {
class BaseStationNetDevice;
class GenericMacHeader;
class WimaxConnection;
class Cid;
/**
* \ingroup wimax
* \brief This class implements a simple downlink scheduler for rtPS flows.
*
* The DL-rtPS-Scheduler assigns the available bandwidth the service flows
* in the following order: IR Connections, Broadcast Connections, Basic and
* Primary Connections, UGS Connections, rtPS Connections, nrtPS Connections,
* BE Connections.
* The IR, Broadcast and Basic/Primary Connections must transmit
* all packet in the queue. The UGS flows can transmit the quota of date equal to
* the "Grant Size" (that is one of service flows QoS parameters) according to their
* requested MaxLatency (another QoS parameter).
* All rtPS flows are able to transmit all packet in the queue according to the available
* bandwidth. The bandwidth saturation control has been implemented to redistribute
*the effective available bandwidth to all rtPS flows that have at least one packet
* to transmit. The remaining bandwidth is allocated to rntPS and BE Connections.
*/
class BSSchedulerRtps : public BSScheduler
{
public:
BSSchedulerRtps ();
BSSchedulerRtps (Ptr<BaseStationNetDevice> bs);
~BSSchedulerRtps (void);
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<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > >*
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
* \param diuc downlink iuc
* \param modulationType the modulation type of the burst
* \param burst the downlink burst to add to the downlink sub frame
*/
void AddDownlinkBurst (Ptr<const WimaxConnection> connection, uint8_t diuc,
WimaxPhy::ModulationType modulationType, Ptr<PacketBurst> burst);
/**
* \brief Schedule function.
*/
void Schedule (void);
/**
* \brief Check for IR and Broadcast connections that have packets to transmit.
* \param connection will point to a initial ranging or broadcast connection
* wich have packets to transmit
* \returns false if no initial ranging or broadcast connection has packets
* to transmit, true otherwise
*/
bool SelectIRandBCConnection (Ptr<WimaxConnection> &connection);
/**
* \brief Check for Basic and Primary connections that have packets to transmit.
* \param connection will point to a basic or primary connection
* wich have packets to transmit
* \returns false if no basic or primary connection has packets
* to transmit, true otherwise
*/
bool SelectMenagementConnection (Ptr<WimaxConnection> &connection);
/**
* \brief Check for UGS connections that have packets to transmit.
*
* The method return the UGS connection that have packets to transmits,
* according to the MaxLatency specifications.
*/
bool SelectUGSConnection (Ptr<WimaxConnection> &connection);
/**
* \brief Check for rtPS connections that have packets to transmit.
*/
bool SelectRTPSConnection (Ptr<WimaxConnection> &connection);
/**
* \brief Check for nrtPS connections that have packets to transmit.
*/
bool SelectNRTPSConnection (Ptr<WimaxConnection> &connection);
/**
* \brief Check for BE connections that have packets to transmit.
*/
bool SelectBEConnection (Ptr<WimaxConnection> &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<WimaxConnection> &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
*/
void BSSchedulerUGSConnection (uint32_t &availableSymbols);
/**
* \brief Downlink Scheduler for rtPS connections.
*
* \param availableSymbols available symbols for rtPS flows
*
* This method represent the DL Scheduler for rtPS connections.
* The scheduler is designed to serve all rtPS connections that
* have at least one packet to transmit, every DL Subframe.
* To each rtPS connections are allocated, at the beginning,
* the bandwidth to transmit a quota of data equal to the
* queue length.
* If the sum of all pre-allocated bandwidth exceed the available
* symbols for rtPS connections, the Channel Saturation Control function
* is called to redistribute the available bandwidth.
*/
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
* \param availableSymbols maximum number of OFDM symbols to be used by the burst
* \returns a Burst (list of packets)
*/
Ptr<PacketBurst> CreateUgsBurst (ServiceFlow *serviceFlow,
WimaxPhy::ModulationType modulationType, uint32_t availableSymbols);
private:
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *m_downlinkBursts;
};
} // namespace ns3
#endif /* BS_SCHEDULER_RTPS_H */
| zy901002-gpsr | src/wimax/model/bs-scheduler-rtps.h | C++ | gpl2 | 7,855 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#ifndef SIMPLE_OFDM_WIMAX_CHANNEL_H
#define SIMPLE_OFDM_WIMAX_CHANNEL_H
#include <list>
#include "wimax-channel.h"
#include "bvec.h"
#include "wimax-phy.h"
#include "ns3/propagation-loss-model.h"
#include "simple-ofdm-send-param.h"
namespace ns3 {
class Packet;
class PacketBurst;
class SimpleOfdmWimaxPhy;
/**
* \ingroup wimax
*/
class SimpleOfdmWimaxChannel : public WimaxChannel
{
public:
SimpleOfdmWimaxChannel (void);
~SimpleOfdmWimaxChannel (void);
enum PropModel
{
RANDOM_PROPAGATION,
FRIIS_PROPAGATION,
LOG_DISTANCE_PROPAGATION,
COST231_PROPAGATION
};
/**
* \brief Creates a channel and sets the propagation model
* \param propModel the propagation model to use
*/
SimpleOfdmWimaxChannel (PropModel propModel);
/**
* \brief Sends a dummy fec block to all connected physical devices
* \param BlockTime the time needed to send the block
* \param burstSize the size of the burst
* \param phy the sender device
* \param isFirstBlock true if this block is the first one, false otherwise
* \param isLastBlock true if this block is the last one, false otherwise
* \param frequency the frequency on which the block is sent
* \param modulationType the modulation used to send the fec block
* \param direction uplink or downlink
* \param txPowerDbm the transmission power
* \param burst the packet burst to send
*/
void Send (Time BlockTime,
uint32_t burstSize, Ptr<WimaxPhy> phy, bool isFirstBlock,
bool isLastBlock,
uint64_t frequency, WimaxPhy::ModulationType modulationType,
uint8_t direction, double txPowerDbm, Ptr<PacketBurst> burst);
/**
* \brief sets the propagation model
* \param propModel the propagation model to used
*/
void SetPropagationModel (PropModel propModel);
private:
void DoAttach (Ptr<WimaxPhy> phy);
std::list<Ptr<SimpleOfdmWimaxPhy> > m_phyList;
uint32_t DoGetNDevices (void) const;
void EndSendDummyBlock (Ptr<SimpleOfdmWimaxPhy> rxphy, simpleOfdmSendParam * param);
Ptr<NetDevice> DoGetDevice (uint32_t i) const;
Ptr<PropagationLossModel> m_loss;
};
} // namespace ns3
#endif /* SIMPLE_OFDM_WIMAX_CHANNEL_H */
| zy901002-gpsr | src/wimax/model/simple-ofdm-wimax-channel.h | C++ | gpl2 | 3,102 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "mac-messages.h"
#include "ns3/address-utils.h"
#include "ns3/uinteger.h"
#include "ns3/log.h"
#include "wimax-tlv.h"
NS_LOG_COMPONENT_DEFINE ("MACMESSAGES");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (ManagementMessageType);
ManagementMessageType::ManagementMessageType (void)
: m_type (~0)
{
}
ManagementMessageType::ManagementMessageType (uint8_t type)
: m_type (type)
{
}
ManagementMessageType::~ManagementMessageType (void)
{
}
void
ManagementMessageType::SetType (uint8_t type)
{
m_type = type;
}
uint8_t
ManagementMessageType::GetType (void) const
{
return m_type;
}
std::string
ManagementMessageType::GetName (void) const
{
return "Management Message Type";
}
TypeId
ManagementMessageType::GetTypeId (void)
{
static TypeId tid =
TypeId ("ns3::ManagementMessageType").SetParent<Header> ().AddConstructor<ManagementMessageType> ();
return tid;
}
TypeId
ManagementMessageType::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
ManagementMessageType::Print (std::ostream &os) const
{
os << " management message type = " << (uint32_t) m_type;
}
uint32_t
ManagementMessageType::GetSerializedSize (void) const
{
return 1;
}
void
ManagementMessageType::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_type);
}
uint32_t
ManagementMessageType::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_type = i.ReadU8 ();
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (RngReq);
RngReq::RngReq (void)
: m_reserved (0),
m_reqDlBurstProfile (0),
m_macAddress (Mac48Address ("00:00:00:00:00:00")),
m_rangingAnomalies (0)
{
}
RngReq::~RngReq (void)
{
}
void
RngReq::SetReqDlBurstProfile (uint8_t reqDlBurstProfile)
{
m_reqDlBurstProfile = reqDlBurstProfile;
}
void
RngReq::SetMacAddress (Mac48Address macAddress)
{
m_macAddress = macAddress;
}
void
RngReq::SetRangingAnomalies (uint8_t rangingAnomalies)
{
m_rangingAnomalies = rangingAnomalies;
}
uint8_t
RngReq::GetReqDlBurstProfile (void) const
{
return m_reqDlBurstProfile;
}
Mac48Address
RngReq::GetMacAddress (void) const
{
return m_macAddress;
}
uint8_t
RngReq::GetRangingAnomalies (void) const
{
return m_rangingAnomalies;
}
std::string
RngReq::GetName (void) const
{
return "RNG-REQ";
}
TypeId
RngReq::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RngReq").SetParent<Header> ().AddConstructor<RngReq> ();
return tid;
}
TypeId
RngReq::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
RngReq::Print (std::ostream &os) const
{
os << " requested dl burst profile = " << (uint32_t) m_reqDlBurstProfile << ", mac address = " << m_macAddress
<< ", ranging anomalies = " << (uint32_t) m_rangingAnomalies;
}
void
RngReq::PrintDebug (void) const
{
NS_LOG_DEBUG (" requested dl burst profile = " << (uint32_t) m_reqDlBurstProfile << ", mac address = "
<< m_macAddress << ", ranging anomalies = "
<< (uint32_t) m_rangingAnomalies);
}
uint32_t
RngReq::GetSerializedSize (void) const
{
return 1 + 1 + 6 + 1;
}
void
RngReq::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_reserved);
i.WriteU8 (m_reqDlBurstProfile);
WriteTo (i, m_macAddress);
i.WriteU8 (m_rangingAnomalies);
}
uint32_t
RngReq::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_reserved = i.ReadU8 ();
m_reqDlBurstProfile = i.ReadU8 ();
ReadFrom (i, m_macAddress);
m_rangingAnomalies = i.ReadU8 ();
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (RngRsp);
RngRsp::RngRsp (void)
: m_reserved (0),
m_timingAdjust (0),
m_powerLevelAdjust (0),
m_offsetFreqAdjust (0),
m_rangStatus (0),
m_dlFreqOverride (0),
m_ulChnlIdOverride (0),
m_dlOperBurstProfile (0),
m_macAddress (Mac48Address ("00:00:00:00:00:00")),
m_basicCid (),
m_primaryCid (),
m_aasBdcastPermission (0),
m_frameNumber (0),
m_initRangOppNumber (0),
m_rangSubchnl (0)
{
}
RngRsp::~RngRsp (void)
{
}
void
RngRsp::SetTimingAdjust (uint32_t timingAdjust)
{
m_timingAdjust = timingAdjust;
}
void
RngRsp::SetPowerLevelAdjust (uint8_t powerLevelAdjust)
{
m_powerLevelAdjust = powerLevelAdjust;
}
void
RngRsp::SetOffsetFreqAdjust (uint32_t offsetFreqAdjust)
{
m_offsetFreqAdjust = offsetFreqAdjust;
}
void
RngRsp::SetRangStatus (uint8_t rangStatus)
{
m_rangStatus = rangStatus;
}
void
RngRsp::SetDlFreqOverride (uint32_t dlFreqOverride)
{
m_dlFreqOverride = dlFreqOverride;
}
void
RngRsp::SetUlChnlIdOverride (uint8_t ulChnlIdOverride)
{
m_ulChnlIdOverride = ulChnlIdOverride;
}
void
RngRsp::SetDlOperBurstProfile (uint16_t dlOperBurstProfile)
{
m_dlOperBurstProfile = dlOperBurstProfile;
}
void
RngRsp::SetMacAddress (Mac48Address macAddress)
{
m_macAddress = macAddress;
}
void
RngRsp::SetBasicCid (Cid basicCid)
{
m_basicCid = basicCid;
}
void
RngRsp::SetPrimaryCid (Cid primaryCid)
{
m_primaryCid = primaryCid;
}
void
RngRsp::SetAasBdcastPermission (uint8_t aasBdcastPermission)
{
m_aasBdcastPermission = aasBdcastPermission;
}
void
RngRsp::SetFrameNumber (uint32_t frameNumber)
{
m_frameNumber = frameNumber;
}
void
RngRsp::SetInitRangOppNumber (uint8_t initRangOppNumber)
{
m_initRangOppNumber = initRangOppNumber;
}
void
RngRsp::SetRangSubchnl (uint8_t rangSubchnl)
{
m_rangSubchnl = rangSubchnl;
}
uint32_t
RngRsp::GetTimingAdjust (void) const
{
return m_timingAdjust;
}
uint8_t
RngRsp::GetPowerLevelAdjust (void) const
{
return m_powerLevelAdjust;
}
uint32_t
RngRsp::GetOffsetFreqAdjust (void) const
{
return m_offsetFreqAdjust;
}
uint8_t
RngRsp::GetRangStatus (void) const
{
return m_rangStatus;
}
uint32_t
RngRsp::GetDlFreqOverride (void) const
{
return m_dlFreqOverride;
}
uint8_t
RngRsp::GetUlChnlIdOverride (void) const
{
return m_ulChnlIdOverride;
}
uint16_t
RngRsp::GetDlOperBurstProfile (void) const
{
return m_dlOperBurstProfile;
}
Mac48Address
RngRsp::GetMacAddress (void) const
{
return m_macAddress;
}
Cid
RngRsp::GetBasicCid (void) const
{
return m_basicCid;
}
Cid
RngRsp::GetPrimaryCid (void) const
{
return m_primaryCid;
}
uint8_t
RngRsp::GetAasBdcastPermission (void) const
{
return m_aasBdcastPermission;
}
uint32_t
RngRsp::GetFrameNumber (void) const
{
return m_frameNumber;
}
uint8_t
RngRsp::GetInitRangOppNumber (void) const
{
return m_initRangOppNumber;
}
uint8_t
RngRsp::GetRangSubchnl (void) const
{
return m_rangSubchnl;
}
std::string
RngRsp::GetName (void) const
{
return "RNG-RSP";
}
TypeId
RngRsp::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RngRsp").SetParent<Header> ().AddConstructor<RngRsp> ();
return tid;
}
TypeId
RngRsp::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
RngRsp::Print (std::ostream &os) const
{
os << " timing adjust = " << m_timingAdjust << ", power level adjust = " << (uint32_t) m_powerLevelAdjust
<< ", offset freq adjust = " << m_offsetFreqAdjust << ", ranging status = " << (uint32_t) m_rangStatus
<< ", dl freq override = " << m_dlFreqOverride << ", ul channel id override = " << (uint32_t) m_ulChnlIdOverride
<< ", dl operational burst profile = " << (uint32_t) m_dlOperBurstProfile << ", mac address = " << m_macAddress
<< ", basic cid = " << m_basicCid << ", primary management cid = " << m_primaryCid
<< ", aas broadcast permission = " << (uint32_t) m_aasBdcastPermission << ", frame number = " << m_frameNumber
<< ", initial ranging opportunity number = " << (uint32_t) m_initRangOppNumber << ", ranging subchannel = "
<< (uint32_t) m_rangSubchnl;
}
uint32_t
RngRsp::GetSerializedSize (void) const
{
return 1 + 4 + 1 + 4 + 1 + 4 + 1 + 2 + 6 + 2 + 2 + 1 + 4 + 1 + 1;
}
void
RngRsp::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_reserved);
i.WriteU32 (m_timingAdjust);
i.WriteU8 (m_powerLevelAdjust);
i.WriteU32 (m_offsetFreqAdjust);
i.WriteU8 (m_rangStatus);
i.WriteU32 (m_dlFreqOverride);
i.WriteU8 (m_ulChnlIdOverride);
i.WriteU16 (m_dlOperBurstProfile);
WriteTo (i, m_macAddress);
i.WriteU16 (m_basicCid.GetIdentifier ());
i.WriteU16 (m_primaryCid.GetIdentifier ());
i.WriteU8 (m_aasBdcastPermission);
i.WriteU32 (m_frameNumber);
i.WriteU8 (m_initRangOppNumber);
i.WriteU8 (m_rangSubchnl);
}
uint32_t
RngRsp::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_reserved = i.ReadU8 ();
m_timingAdjust = i.ReadU32 ();
m_powerLevelAdjust = i.ReadU8 ();
m_offsetFreqAdjust = i.ReadU32 ();
m_rangStatus = i.ReadU8 ();
m_dlFreqOverride = i.ReadU32 ();
m_ulChnlIdOverride = i.ReadU8 ();
m_dlOperBurstProfile = i.ReadU16 ();
ReadFrom (i, m_macAddress); // length (6) shall also be written in packet instead of hard coded, see ARP example
m_basicCid = i.ReadU16 ();
m_primaryCid = i.ReadU16 ();
m_aasBdcastPermission = i.ReadU8 ();
m_frameNumber = i.ReadU32 ();
m_initRangOppNumber = i.ReadU8 ();
m_rangSubchnl = i.ReadU8 ();
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (DsaReq);
DsaReq::DsaReq (void)
: m_transactionId (0),
m_sfid (0),
m_cid (),
m_serviceFlow (ServiceFlow::SF_DIRECTION_DOWN)
{
}
DsaReq::DsaReq (ServiceFlow sf)
{
m_transactionId = 0;
m_serviceFlow = sf;
}
DsaReq::~DsaReq (void)
{
}
void
DsaReq::SetTransactionId (uint16_t transactionId)
{
m_transactionId = transactionId;
}
uint16_t
DsaReq::GetTransactionId (void) const
{
return m_transactionId;
}
void
DsaReq::SetSfid (uint32_t sfid)
{
m_sfid = sfid;
}
uint32_t
DsaReq::GetSfid (void) const
{
return m_sfid;
}
void
DsaReq::SetCid (Cid cid)
{
m_cid = cid;
}
Cid
DsaReq::GetCid (void) const
{
return m_cid;
}
std::string
DsaReq::GetName (void) const
{
return "DSA-REQ";
}
TypeId
DsaReq::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::DsaReq").SetParent<Header> ().AddConstructor<DsaReq> ();
return tid;
}
TypeId
DsaReq::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
DsaReq::Print (std::ostream &os) const
{
os << " transaction id = " << (uint32_t) m_transactionId << ", m_sfid = " << m_sfid << ", cid = " << m_cid;
}
/*
* 0 7 15 23
* +-------------+-------------+-------------+
* |Mngt msg type| Transaction ID |
* +-------------+-------------+-------------+
* | Service Flow TLV |
* +~~~~~~~~~~~~~+~~~~~~~~~~~~~+~~~~~~~~~~~~~+
*
*/
uint32_t
DsaReq::GetSerializedSize (void) const
{
Tlv t = m_serviceFlow.ToTlv ();
uint32_t size = 2 + t.GetSerializedSize ();
return size;
}
void
DsaReq::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_transactionId);
Tlv t = m_serviceFlow.ToTlv ();
t.Serialize (i);
}
uint32_t
DsaReq::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_transactionId = i.ReadU16 ();
Tlv tlv;
uint32_t size = tlv.Deserialize (i);
m_serviceFlow = ServiceFlow (tlv);
return size + 2;
}
ServiceFlow
DsaReq::GetServiceFlow (void) const
{
return m_serviceFlow;
}
void
DsaReq::SetServiceFlow (ServiceFlow sf)
{
m_serviceFlow = sf;
}
// ----------------------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (DsaRsp);
DsaRsp::DsaRsp (void)
: m_transactionId (0),
m_confirmationCode (0),
m_sfid (0),
m_cid ()
{
}
DsaRsp::~DsaRsp (void)
{
}
void
DsaRsp::SetTransactionId (uint16_t transactionId)
{
m_transactionId = transactionId;
}
uint16_t
DsaRsp::GetTransactionId (void) const
{
return m_transactionId;
}
ServiceFlow
DsaRsp::GetServiceFlow (void) const
{
return m_serviceFlow;
}
void
DsaRsp::SetServiceFlow (ServiceFlow sf)
{
m_serviceFlow = sf;
}
void
DsaRsp::SetConfirmationCode (uint16_t confirmationCode)
{
m_confirmationCode = confirmationCode;
}
uint16_t
DsaRsp::GetConfirmationCode (void) const
{
return m_confirmationCode;
}
void
DsaRsp::SetSfid (uint32_t sfid)
{
m_sfid = sfid;
}
uint32_t
DsaRsp::GetSfid (void) const
{
return m_sfid;
}
void
DsaRsp::SetCid (Cid cid)
{
m_cid = cid;
}
Cid
DsaRsp::GetCid (void) const
{
return m_cid;
}
std::string
DsaRsp::GetName (void) const
{
return "DSA-RSP";
}
TypeId
DsaRsp::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::DsaRsp").SetParent<Header> ().AddConstructor<DsaRsp> ();
return tid;
}
TypeId
DsaRsp::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
DsaRsp::Print (std::ostream &os) const
{
os << " transaction id = " << (uint32_t) m_transactionId << ", confirmation code = " << (uint32_t) m_confirmationCode
<< ", m_sfid = " << m_sfid << ", cid = " << m_cid;
}
uint32_t
DsaRsp::GetSerializedSize (void) const
{
return 2 + 1 + m_serviceFlow.ToTlv ().GetSerializedSize ();
}
/*
* 0 7 15 23
* +-------------+-------------+-------------+
* |Mngt msg type| Transaction ID |
* +-------------+-------------+-------------+
* | Conf Code | Service Flow TLV |
* +~~~~~~~~~~~~~+~~~~~~~~~~~~~+~~~~~~~~~~~~~+
*
*/
void
DsaRsp::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_transactionId);
i.WriteU8 (m_confirmationCode);
m_serviceFlow.ToTlv ().Serialize (i);
}
uint32_t
DsaRsp::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_transactionId = i.ReadU16 ();
m_confirmationCode = i.ReadU8 ();
Tlv tlv;
uint32_t size = tlv.Deserialize (i);
m_serviceFlow = ServiceFlow (tlv);
return size + 3;
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (DsaAck);
DsaAck::DsaAck (void)
: m_transactionId (0),
m_confirmationCode (0)
{
}
DsaAck::~DsaAck (void)
{
}
void
DsaAck::SetTransactionId (uint16_t transactionId)
{
m_transactionId = transactionId;
}
uint16_t
DsaAck::GetTransactionId (void) const
{
return m_transactionId;
}
void
DsaAck::SetConfirmationCode (uint16_t confirmationCode)
{
m_confirmationCode = confirmationCode;
}
uint16_t
DsaAck::GetConfirmationCode (void) const
{
return m_confirmationCode;
}
std::string
DsaAck::GetName (void) const
{
return "DSA-ACK";
}
TypeId
DsaAck::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::DsaAck").SetParent<Header> ().AddConstructor<DsaAck> ();
return tid;
}
TypeId
DsaAck::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
DsaAck::Print (std::ostream &os) const
{
os << " transaction id = " << (uint32_t) m_transactionId << ", confirmation code = " << (uint32_t) m_confirmationCode;
}
uint32_t
DsaAck::GetSerializedSize (void) const
{
return 2 + 1;
}
void
DsaAck::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_transactionId);
i.WriteU8 (m_confirmationCode);
}
uint32_t
DsaAck::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_transactionId = i.ReadU16 ();
m_confirmationCode = i.ReadU8 ();
return i.GetDistanceFrom (start);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/mac-messages.cc | C++ | gpl2 | 16,479 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef WIMAX_PHY_H
#define WIMAX_PHY_H
#include <stdint.h>
#include <list>
#include "ns3/callback.h"
#include "ns3/nstime.h"
#include "ns3/event-id.h"
#include "bvec.h"
#include "send-params.h"
#include "ns3/log.h"
#include "ns3/object.h"
#include "ns3/traced-callback.h"
namespace ns3 {
class WimaxChannel;
class WimaxNetDevice;
class NetDevice;
class Packet;
/**
* \ingroup wimax
*/
class WimaxPhy : public Object
{
public:
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
};
enum PhyState
{
PHY_STATE_IDLE, PHY_STATE_SCANNING, PHY_STATE_TX, PHY_STATE_RX
};
enum PhyType
{
SimpleWimaxPhy, simpleOfdmWimaxPhy
};
static TypeId GetTypeId (void);
WimaxPhy (void);
virtual ~WimaxPhy (void);
/**
* Attach the physical layer to a channel.
* \param channel the channel to which the physical layer will be attached
*/
void Attach (Ptr<WimaxChannel> channel);
/**
* \return the channel to which this physical layer is attached
*/
Ptr<WimaxChannel> GetChannel (void) const;
/**
* \brief Set the device in which this physical layer is installed
* \param device the device in which this physical layer is installed
*/
void SetDevice (Ptr<WimaxNetDevice> device);
/**
* \return the the device in which this physical layer is installed
*/
Ptr<NetDevice> GetDevice (void) const;
/**
* \brief set the callback function to call when a burst is received
* \param callback the callback function to call when a burst is received
*/
void SetReceiveCallback (Callback<void, Ptr<const PacketBurst> > callback);
/**
* \return the receive callback
*/
Callback<void, Ptr<const PacketBurst> > GetReceiveCallback (void) const;
/**
* \brief send a packet on the channel
* \param params the parameters used to send the packet
*/
virtual void Send (SendParams *params) = 0;
/**
* \brief Get the type of the physical layer
*/
virtual PhyType GetPhyType (void) const = 0;
/**
* \brief configure the physical layer in duplex mode
* \param rxFrequency the reception frequency
* \param txFrequency the transmission frequency
*/
void SetDuplex (uint64_t rxFrequency, uint64_t txFrequency);
/**
* \brief configure the physical layer in simplex mode
* \param frequency the frequency to be used for reception and transmission process
*/
void SetSimplex (uint64_t frequency);
/**
* \return the reception frequency
*/
uint64_t GetRxFrequency (void) const;
/**
* \return the transmission frequency
*/
uint64_t GetTxFrequency (void) const;
/**
* \return the scanning frequency
*/
uint64_t GetScanningFrequency (void) const;
/**
* \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
*/
uint8_t GetNrCarriers (void) const;
/**
* \brief Set the frame duration
* \param frameDuration the frame duration
*/
void SetFrameDuration (Time frameDuration);
/**
* \return the frame duration in seconds
*/
Time GetFrameDurationSec (void) const;
/**
* \return the frame duration
*/
Time GetFrameDuration (void) const;
/**
* \brief set the frequency on which the device should lock
* \param frequency the frequency to configure
*/
void SetFrequency (uint32_t frequency);
/**
* \return the frequency on which the device is locked
*/
uint32_t GetFrequency (void) const;
/**
* \brief Set the channel bandwidth
* \param channelBandwidth The channel bandwidth
*/
void SetChannelBandwidth (uint32_t channelBandwidth);
/**
* \return the channel bandwidth
*/
uint32_t GetChannelBandwidth (void) const;
/**
* \return the size of the FFT
*/
uint16_t GetNfft (void) const;
/**
* \return the sampling factor
*/
double GetSamplingFactor (void) const;
/**
* \return the sampling frequency
*/
double GetSamplingFrequency (void) const;
/**
* \brief set the physical slot duration in seconds
* \param psDuration the physical slot duration
*/
void SetPsDuration (Time psDuration);
/**
* \return the physical slot duration
*/
Time GetPsDuration (void) const;
/**
* \brief set the OFMD symbol duration in second
* \param symbolDuration the symbol duration is second
*/
void SetSymbolDuration (Time symbolDuration);
/**
* \return the symbol duration in second
*/
Time GetSymbolDuration (void) const;
/**
* \return the guard interval factor (The ratio TG/Td)
*/
double GetGValue (void) const;
/**
* \brief set the number of physical slots per symbol
* \param psPerSymbol the number of physical slots per symbol
*/
void SetPsPerSymbol (uint16_t psPerSymbol);
/**
* \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
*/
void SetPsPerFrame (uint16_t psPerFrame);
/**
* \return the number of physical slot per frame
*/
uint16_t GetPsPerFrame (void) const;
/**
* \brief set the number of symbols per frame
* \param symbolsPerFrame the number of symbols per frame
*/
void SetSymbolsPerFrame (uint32_t symbolsPerFrame);
/**
* \return the number of symbols per frame
*/
uint32_t GetSymbolsPerFrame (void) const;
/**
* \return true if the device is configured in duplex mode
*/
bool IsDuplex (void) const;
/**
* \brief set the state of the device
* \param state the state to be set (PHY_STATE_IDLE, PHY_STATE_SCANNING, PHY_STATE_TX, PHY_STATE_RX)
*/
void SetState (PhyState state);
/**
* \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
* \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
*/
void StartScanning (uint64_t frequency, Time timeout, Callback<void, bool, uint64_t> callback);
/**
* \brief calls the scanning call back function
*/
void SetScanningCallback (void) const;
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
* \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
* \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
* \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
* \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;
/**
* \return the transmit/receive transition gap
*/
uint16_t GetTtg (void) const;
/**
* \return the receive/transmit transition gap
*/
uint16_t GetRtg (void) const;
uint8_t GetFrameDurationCode (void) const;
Time GetFrameDuration (uint8_t frameDurationCode) const;
/**
* \brief computes the Physical parameters and store them
*/
void SetPhyParameters (void);
virtual void DoDispose (void);
/**
* \return the mobility model of the device
*/
virtual Ptr<Object> GetMobility (void);
/**
* \brief set the mobility model of the device
* \param mobility the mobility model to set
*/
virtual void SetMobility (Ptr<Object> mobility);
private:
void GetModulationFecParams (ModulationType modulationType, uint8_t &bitsPerSymbol, double &fecCode) const;
void EndScanning (void);
virtual Time DoGetTransmissionTime (uint32_t size, ModulationType modulationType) const = 0;
virtual void DoAttach (Ptr<WimaxChannel> channel) = 0;
virtual void DoSetDataRates (void) = 0;
virtual uint32_t DoGetDataRate (ModulationType modulationType) const = 0;
virtual uint64_t DoGetNrSymbols (uint32_t size, ModulationType modulationType) const = 0;
virtual uint64_t DoGetNrBytes (uint32_t symbols, ModulationType modulationType) const = 0;
virtual uint16_t DoGetTtg (void) const = 0;
virtual uint16_t DoGetRtg (void) const = 0;
virtual uint8_t DoGetFrameDurationCode (void) const = 0;
virtual Time DoGetFrameDuration (uint8_t frameDurationCode) const = 0;
virtual void DoSetPhyParameters (void) = 0;
virtual double DoGetSamplingFactor (void) const = 0;
virtual uint16_t DoGetNfft (void) const = 0;
virtual double DoGetSamplingFrequency (void) const = 0;
virtual double DoGetGValue (void) const = 0;
Ptr<WimaxNetDevice> m_device;
Ptr<WimaxChannel> m_channel;
uint64_t m_txFrequency;
uint64_t m_rxFrequency;
uint64_t m_scanningFrequency;
EventId m_dlChnlSrchTimeoutEvent;
bool m_duplex;
PhyState m_state;
Callback<void, Ptr<const PacketBurst> > m_rxCallback;
Callback<void, bool, uint64_t> m_scanningCallback;
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<Object> m_mobility;
};
} // namespace ns3
#endif /* WIMAX_PHY_H */
| zy901002-gpsr | src/wimax/model/wimax-phy.h | C++ | gpl2 | 11,247 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef CID_H
#define CID_H
#include <stdint.h>
#include <ostream>
namespace ns3 {
/**
* \ingroup wimax
*/
class Cid
{
public:
enum Type
{
BROADCAST = 1,
INITIAL_RANGING,
BASIC,
PRIMARY,
TRANSPORT,
MULTICAST,
PADDING
};
// Create a cid of unknown type
Cid (void);
Cid (uint16_t cid);
~Cid (void);
/**
* \return the identifier of the cid
*/
uint16_t GetIdentifier (void) const;
/**
* \return true if the cid is a multicast cid, false otherwise
*/
bool IsMulticast (void) const;
/**
* \return true if the cid is a broadcast cid, false otherwise
*/
bool IsBroadcast (void) const;
/**
* \return true if the cid is a padding cid, false otherwise
*/
bool IsPadding (void) const;
/**
* \return true if the cid is an initial ranging cid, false otherwise
*/
bool IsInitialRanging (void) const;
/**
* \return the broadcast cid
*/
static Cid Broadcast (void);
/**
* \return the padding cid
*/
static Cid Padding (void);
/**
* \return the initial ranging cid
*/
static Cid InitialRanging (void);
private:
friend class CidFactory;
friend bool operator == (const Cid &lhs, const Cid &rhs);
uint16_t m_identifier;
};
bool operator == (const Cid &lhs, const Cid &rhs);
bool operator != (const Cid &lhs, const Cid &rhs);
std::ostream & operator << (std::ostream &os, const Cid &cid);
} // namespace ns3
#endif /* CID_H */
| zy901002-gpsr | src/wimax/model/cid.h | C++ | gpl2 | 2,404 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
/*
*This file does not contain all MAC messages, the rest of MAC messages have
*This been categorized as DL and UL messages and are placed in
*This dl-mac-messages.h and ul-mac-messages.h files.
*/
#ifndef MANAGEMENT_MESSAGE_TYPE_H
#define MANAGEMENT_MESSAGE_TYPE_H
#include <stdint.h>
#include "ns3/header.h"
namespace ns3 {
/**
* \ingroup wimax
*/
class ManagementMessageType : public Header
{
public:
/*
* Section 6.3.2.3 MAC Management messages page 42, Table 14 page 43
*/
enum MessageType
{
MESSAGE_TYPE_UCD = 0,
MESSAGE_TYPE_DCD = 1,
MESSAGE_TYPE_DL_MAP = 2,
MESSAGE_TYPE_UL_MAP = 3,
MESSAGE_TYPE_RNG_REQ = 4,
MESSAGE_TYPE_RNG_RSP = 5,
MESSAGE_TYPE_REG_REQ = 6,
MESSAGE_TYPE_REG_RSP = 7,
MESSAGE_TYPE_DSA_REQ = 11,
MESSAGE_TYPE_DSA_RSP = 12,
MESSAGE_TYPE_DSA_ACK = 13
};
ManagementMessageType (void);
ManagementMessageType (uint8_t type);
virtual ~ManagementMessageType (void);
void SetType (uint8_t type);
uint8_t GetType (void) const;
std::string GetName (void) const;
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);
private:
uint8_t m_type;
};
} // namespace ns3
#endif /* MANAGEMENT_MESSAGE_TYPE_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef RNG_RSP_H
#define RNG_RSP_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/mac48-address.h"
#include "service-flow.h"
#include "cid.h"
namespace ns3 {
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);
/**
* \brief set the Tx timing offset adjustment (signed 32-bit).
* \param timingAdjust The time required to advance SS transmission so frames
* arrive at the expected time instance at the BS.
*/
void SetTimingAdjust (uint32_t timingAdjust);
/**
* \brief set the relative change in transmission power level that the SS should 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.
* \param powerLevelAdjust the relative change in transmission power level
*/
void SetPowerLevelAdjust (uint8_t powerLevelAdjust);
/**
* \brief set the relative change in transmission frequency that the SS should take in order to better match
* the BS. This is fine-frequency adjustment within a channel, not reassignment to a different channel
* \param offsetFreqAdjust
*/
void SetOffsetFreqAdjust (uint32_t offsetFreqAdjust);
void SetRangStatus (uint8_t rangStatus);
/**
* \brief set the Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging.
* \param dlFreqOverride the Center frequency in kHz
*/
void SetDlFreqOverride (uint32_t dlFreqOverride);
/**
* \brief set the identifier of the uplink channel with which the SS is to redo initial ranging
* \param ulChnlIdOverride the uplink channel index
*/
void SetUlChnlIdOverride (uint8_t ulChnlIdOverride);
void SetDlOperBurstProfile (uint16_t dlOperBurstProfile);
void SetMacAddress (Mac48Address macAddress);
void SetBasicCid (Cid basicCid);
void SetPrimaryCid (Cid primaryCid);
void SetAasBdcastPermission (uint8_t aasBdcastPermission);
void SetFrameNumber (uint32_t frameNumber);
void SetInitRangOppNumber (uint8_t initRangOppNumber);
void SetRangSubchnl (uint8_t rangSubchnl);
/**
* \return 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 GetTimingAdjust (void) const;
/**
* \return the relative change in transmission power level that the SS should take 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 GetPowerLevelAdjust (void) const;
/**
* \return the relative change in transmission frequency that the SS should take in order to better match
* the BS. This is fine-frequency adjustment within a channel, not reassignment to a different channel.
*/
uint32_t GetOffsetFreqAdjust (void) const;
uint8_t GetRangStatus (void) const;
/**
* \return Center frequency, in kHz, of new downlink channel where the SS should redo initial ranging.
*/
uint32_t GetDlFreqOverride (void) const;
/**
* \return The identifier of the uplink channel with which the SS is to redo initial ranging
*/
uint8_t GetUlChnlIdOverride (void) const;
/**
* \return DlOperBurstProfile: This parameter is sent in response to the RNG-REQ Requested Downlink Burst Profile parameter
*/
uint16_t GetDlOperBurstProfile (void) const;
Mac48Address GetMacAddress (void) const;
Cid GetBasicCid (void) const;
Cid GetPrimaryCid (void) const;
uint8_t GetAasBdcastPermission (void) const;
uint32_t GetFrameNumber (void) const;
uint8_t GetInitRangOppNumber (void) const;
uint8_t GetRangSubchnl (void) const;
std::string GetName (void) const;
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);
private:
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.
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.
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.
uint32_t m_offsetFreqAdjust;
uint8_t m_rangStatus;
// 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).
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.
uint16_t m_dlOperBurstProfile;
Mac48Address m_macAddress;
Cid m_basicCid;
Cid m_primaryCid;
uint8_t m_aasBdcastPermission;
// 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
uint8_t m_initRangOppNumber;
// Used to indicate the OFDM subchannel reference that was used to transmit the initial ranging message
// (OFDM with subchannelization).
uint8_t m_rangSubchnl;
};
} // namespace ns3
#endif /* RNG_RSP_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef DSA_REQ_H
#define DSA_REQ_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/buffer.h"
#include "cid.h"
#include "service-flow.h"
namespace ns3 {
class serviceFlow;
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
*
*/
public:
DsaReq ();
~DsaReq ();
DsaReq (ServiceFlow sf);
void SetTransactionId (uint16_t transactionId);
/**
* \brief set the service flow identifier
* \param sfid the service flow identifier
*/
void SetSfid (uint32_t sfid);
/**
* \brief set the connection identifier
* \param cid the connection identifier
*/
void SetCid (Cid cid);
/**
* \brief specify a service flow to be requested by this message
* \param sf the service flow
*/
void SetServiceFlow (ServiceFlow sf);
/**
* \return the service flow requested by this message
*/
ServiceFlow GetServiceFlow (void) const;
uint16_t GetTransactionId (void) const;
/**
* \return the service flow identifier
*/
uint32_t GetSfid (void) const;
/**
* \return the connection identifier
*/
Cid GetCid (void) const;
std::string GetName (void) const;
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);
private:
uint16_t m_transactionId;
// TLV Encoded Information
uint32_t m_sfid;
Cid m_cid;
ServiceFlow m_serviceFlow;
};
} // namespace ns3
#endif /* DSA_REQ_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef DSA_RSP_H
#define DSA_RSP_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/buffer.h"
#include "cid.h"
namespace ns3 {
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
*/
public:
DsaRsp (void);
~DsaRsp (void);
void SetTransactionId (uint16_t transactionId);
uint16_t GetTransactionId (void) const;
void SetConfirmationCode (uint16_t confirmationCode);
uint16_t GetConfirmationCode (void) const;
/**
* \brief set the service flow identifier
* \param sfid the service flow identifier
*/
void SetSfid (uint32_t sfid);
/**
* \return the service flow identifier
*/
uint32_t GetSfid (void) const;
/**
* \brief set the connection identifier
* \param cid the connection identifier
*/
void SetCid (Cid cid);
/**
* \return the connection identifier
*/
Cid GetCid (void) const;
/**
* \brief specify a service flow to be requested by this message
* \param sf the service flow
*/
void SetServiceFlow (ServiceFlow sf);
/**
* \return the service flow requested by this message
*/
ServiceFlow GetServiceFlow (void) const;
std::string GetName (void) const;
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);
private:
uint16_t m_transactionId;
uint8_t m_confirmationCode;
// TLV Encoded Information
ServiceFlow m_serviceFlow;
uint32_t m_sfid;
Cid m_cid;
};
} // namespace ns3
#endif /* DSA_RSP_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef DSA_ACK_H
#define DSA_ACK_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/buffer.h"
namespace ns3 {
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);
void SetTransactionId (uint16_t transactionId);
uint16_t GetTransactionId (void) const;
void SetConfirmationCode (uint16_t confirmationCode);
uint16_t GetConfirmationCode (void) const;
std::string GetName (void) const;
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);
private:
uint16_t m_transactionId;
uint8_t m_confirmationCode;
};
} // namespace ns3
#endif /* DSA_ACK_H */
// ----------------------------------------------------------------------------------------------------------
#ifndef RNG_REQ_H
#define RNG_REQ_H
#include <stdint.h>
#include "ns3/header.h"
#include "ns3/mac48-address.h"
#include "service-flow.h"
namespace ns3 {
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);
void SetReqDlBurstProfile (uint8_t reqDlBurstProfile);
void SetMacAddress (Mac48Address macAddress);
void SetRangingAnomalies (uint8_t rangingAnomalies);
uint8_t GetReqDlBurstProfile (void) const;
Mac48Address GetMacAddress (void) const;
uint8_t GetRangingAnomalies (void) const;
std::string GetName (void) const;
static TypeId GetTypeId (void);
virtual TypeId GetInstanceTypeId (void) const;
void Print (std::ostream &os) const;
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
// TLV Encoded Information
uint8_t m_reqDlBurstProfile;
Mac48Address m_macAddress;
uint8_t m_rangingAnomalies;
};
} // namespace ns3
#endif /* RNG_REQ_H */
| zy901002-gpsr | src/wimax/model/mac-messages.h | C++ | gpl2 | 15,670 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef LINK_MANAGER_H
#define LINK_MANAGER_H
#include <stdint.h>
#include "wimax-net-device.h"
#include "ss-net-device.h"
#include "ns3/event-id.h"
#include "cid.h"
#include "mac-messages.h"
#include "ns3/nstime.h"
namespace ns3 {
/**
* \ingroup wimax
* \brief this class implements the link manager of subscriber station net device. An ss link manager is
* responsible for link scanning and ranging
*/
class SSLinkManager : public Object
{
public:
static TypeId GetTypeId (void);
SSLinkManager (Ptr<SubscriberStationNetDevice> ss);
~SSLinkManager (void);
void DoDispose (void);
void SetBsEirp (uint16_t bs_eirp);
void SetEirXPIrMax (uint16_t eir_x_p_ir_max);
void SetRangingIntervalFound (bool rangingIntervalFound);
bool GetRangingIntervalFound (void) const;
void SetNrRangingTransOpps (uint8_t nrRangingTransOpps);
void SetRangingCW (uint8_t rangingCW);
void IncrementNrInvitedPollsRecvd (void);
EventId GetDlMapSyncTimeoutEvent (void);
void PerformRanging (Cid cid, RngRsp rngrsp);
void StartScanning (SubscriberStationNetDevice::EventType type,
bool deleteParameters);
void SendRangingRequest (uint8_t uiuc, uint16_t allocationSize);
void StartContentionResolution (void);
void PerformBackoff (void);
bool IsUlChannelUsable (void);
void ScheduleScanningRestart (Time interval,
SubscriberStationNetDevice::EventType eventType,
bool deleteUlParameters, EventId &eventId);
private:
SSLinkManager (const SSLinkManager &);
SSLinkManager & operator= (const SSLinkManager &);
void EndScanning (bool status, uint64_t frequency);
void StartSynchronizing (void);
bool SearchForDlChannel (uint8_t channel);
void SelectRandomBackoff (void);
void IncreaseRangingRequestCW (void);
void ResetRangingRequestCW (void);
void DeleteUplinkParameters (void);
void AdjustRangingParameters (const RngRsp &rngrsp);
void NegotiateBasicCapabilities (void);
uint16_t CalculateMaxIRSignalStrength (void);
uint16_t GetMinTransmitPowerLevel (void);
Ptr<SubscriberStationNetDevice> m_ss;
WimaxNetDevice::RangingStatus m_rangingStatus;
// 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
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_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;
// 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;
};
} // namespace ns3
#endif /* LINK_MANAGER_H */
| zy901002-gpsr | src/wimax/model/ss-link-manager.h | C++ | gpl2 | 4,246 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "ns3/node.h"
#include "ns3/uinteger.h"
#include "ns3/double.h"
#include "ns3/string.h"
#include "wimax-net-device.h"
#include "simple-ofdm-wimax-phy.h"
#include "wimax-channel.h"
#include "ns3/packet-burst.h"
#include "wimax-mac-header.h"
#include "simple-ofdm-wimax-channel.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/random-variable.h"
#include <string>
#include <math.h>
NS_LOG_COMPONENT_DEFINE ("SimpleOfdmWimaxPhy");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (SimpleOfdmWimaxPhy);
TypeId SimpleOfdmWimaxPhy::GetTypeId (void)
{
static TypeId
tid =
TypeId ("ns3::SimpleOfdmWimaxPhy").SetParent<WimaxPhy> ()
.AddAttribute ("NoiseFigure",
"Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.",
DoubleValue (5),
MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetNoiseFigure, &SimpleOfdmWimaxPhy::GetNoiseFigure),
MakeDoubleChecker<double> ())
.AddAttribute ("TxPower",
"Transmission power (dB).",
DoubleValue (30),
MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetTxPower, &SimpleOfdmWimaxPhy::GetTxPower),
MakeDoubleChecker<double> ())
.AddAttribute ("G",
"This is the ratio of CP time to useful time.",
DoubleValue (0.25),
MakeDoubleAccessor (&SimpleOfdmWimaxPhy::DoSetGValue, &SimpleOfdmWimaxPhy::DoGetGValue),
MakeDoubleChecker<double> ())
.AddAttribute ("TxGain",
"Transmission gain (dB).",
DoubleValue (0),
MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetTxGain, &SimpleOfdmWimaxPhy::GetTxGain),
MakeDoubleChecker<double> ())
.AddAttribute ("RxGain",
"Reception gain (dB).",
DoubleValue (0),
MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetRxGain, &SimpleOfdmWimaxPhy::GetRxGain),
MakeDoubleChecker<double> ())
.AddAttribute ("Nfft",
"FFT size",
UintegerValue (256),
MakeUintegerAccessor (&SimpleOfdmWimaxPhy::DoSetNfft, &SimpleOfdmWimaxPhy::DoGetNfft),
MakeUintegerChecker<uint16_t> (256, 1024))
.AddAttribute ("TraceFilePath",
"Path to the directory containing SNR to block error rate files",
StringValue (""),
MakeStringAccessor (&SimpleOfdmWimaxPhy::GetTraceFilePath,
&SimpleOfdmWimaxPhy::SetTraceFilePath),
MakeStringChecker ())
.AddTraceSource ("Rx", "Receive trace", MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_traceRx))
.AddTraceSource ("Tx", "Transmit trace", MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_traceTx))
.AddTraceSource ("PhyTxBegin",
"Trace source indicating a packet has begun transmitting over the channel medium",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxBeginTrace))
.AddTraceSource ("PhyTxEnd",
"Trace source indicating a packet has been completely transmitted over the channel",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxEndTrace))
.AddTraceSource ("PhyTxDrop",
"Trace source indicating a packet has been dropped by the device during transmission",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxDropTrace))
.AddTraceSource ("PhyRxBegin",
"Trace source indicating a packet has begun being received from the channel medium by the device",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxBeginTrace))
.AddTraceSource ("PhyRxEnd",
"Trace source indicating a packet has been completely received from the channel medium by the device",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxEndTrace))
.AddTraceSource ("PhyRxDrop",
"Trace source indicating a packet has been dropped by the device during reception",
MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxDropTrace));
return tid;
}
void
SimpleOfdmWimaxPhy::InitSimpleOfdmWimaxPhy (void)
{
m_fecBlockSize = 0;
m_nrFecBlocksSent = 0;
m_dataRateBpsk12 = 0;
m_dataRateQpsk12 = 0;
m_dataRateQpsk34 = 0;
m_dataRateQam16_12 = 0;
m_dataRateQam16_34 = 0;
m_dataRateQam64_23 = 0;
m_dataRateQam64_34 = 0;
m_nrBlocks = 0;
m_blockSize = 0;
m_paddingBits = 0;
m_rxGain = 0;
m_txGain = 0;
m_nfft = 256;
m_g = (double) 1 / 4;
SetNrCarriers (192);
m_fecBlocks = new std::list<bvec>;
m_receivedFecBlocks = new std::list<bvec>;
m_currentBurstSize = 0;
m_noiseFigure = 5; // dB
m_txPower = 30; // dBm
SetBandwidth (10000000); // 10Mhz
m_nbErroneousBlock = 0;
m_nrRecivedFecBlocks = 0;
m_snrToBlockErrorRateManager = new SNRToBlockErrorRateManager ();
}
SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy (void)
{
InitSimpleOfdmWimaxPhy ();
m_snrToBlockErrorRateManager->SetTraceFilePath ((char*) "");
m_snrToBlockErrorRateManager->LoadTraces ();
}
SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy (char * tracesPath)
{
InitSimpleOfdmWimaxPhy ();
m_snrToBlockErrorRateManager->SetTraceFilePath (tracesPath);
m_snrToBlockErrorRateManager->LoadTraces ();
}
SimpleOfdmWimaxPhy::~SimpleOfdmWimaxPhy (void)
{
}
void
SimpleOfdmWimaxPhy::ActivateLoss (bool loss)
{
m_snrToBlockErrorRateManager->ActivateLoss (loss);
}
void
SimpleOfdmWimaxPhy::SetSNRToBlockErrorRateTracesPath (char * tracesPath)
{
m_snrToBlockErrorRateManager->SetTraceFilePath (tracesPath);
m_snrToBlockErrorRateManager->ReLoadTraces ();
}
uint32_t
SimpleOfdmWimaxPhy::GetBandwidth (void) const
{
return WimaxPhy::GetChannelBandwidth ();
}
void
SimpleOfdmWimaxPhy::SetBandwidth (uint32_t BW)
{
WimaxPhy::SetChannelBandwidth (BW);
}
double
SimpleOfdmWimaxPhy::GetTxPower (void) const
{
return m_txPower;
}
void
SimpleOfdmWimaxPhy::SetTxPower (double txPower)
{
m_txPower = txPower;
}
double
SimpleOfdmWimaxPhy::GetNoiseFigure (void) const
{
return m_noiseFigure;
}
void
SimpleOfdmWimaxPhy::SetNoiseFigure (double noiseFigure)
{
m_noiseFigure = noiseFigure;
}
void
SimpleOfdmWimaxPhy::DoDispose (void)
{
delete m_receivedFecBlocks;
delete m_fecBlocks;
m_receivedFecBlocks = 0;
m_fecBlocks = 0;
delete m_snrToBlockErrorRateManager;
WimaxPhy::DoDispose ();
}
void
SimpleOfdmWimaxPhy::DoAttach (Ptr<WimaxChannel> channel)
{
GetChannel ()->Attach (this);
}
void
SimpleOfdmWimaxPhy::Send (SendParams *params)
{
OfdmSendParams *o_params = dynamic_cast<OfdmSendParams*> (params);
Send (o_params->GetBurst (),
(WimaxPhy::ModulationType) o_params->GetModulationType (),
o_params->GetDirection ());
}
WimaxPhy::PhyType
SimpleOfdmWimaxPhy::GetPhyType (void) const
{
return WimaxPhy::simpleOfdmWimaxPhy;
}
void
SimpleOfdmWimaxPhy::Send (Ptr<PacketBurst> burst,
WimaxPhy::ModulationType modulationType,
uint8_t direction)
{
if (GetState () != PHY_STATE_TX)
{
m_currentBurstSize = burst->GetSize ();
m_nrFecBlocksSent = 0;
m_currentBurst = burst;
SetBlockParameters (burst->GetSize (), modulationType);
NotifyTxBegin (m_currentBurst);
StartSendDummyFecBlock (true, modulationType, direction);
m_traceTx (burst);
}
}
void
SimpleOfdmWimaxPhy::StartSendDummyFecBlock (bool isFirstBlock,
WimaxPhy::ModulationType modulationType,
uint8_t direction)
{
SetState (PHY_STATE_TX);
bool isLastFecBlock = 0;
if (isFirstBlock)
{
m_blockTime = GetBlockTransmissionTime (modulationType);
}
SimpleOfdmWimaxChannel *channel = dynamic_cast<SimpleOfdmWimaxChannel*> (PeekPointer (GetChannel ()));
if (m_nrRemainingBlocksToSend==1)
{
isLastFecBlock = true;
}
else
{
isLastFecBlock = false;
}
channel->Send (m_blockTime,
m_currentBurstSize,
this,
isFirstBlock,
isLastFecBlock,
GetTxFrequency (),
modulationType,
direction,
m_txPower,
m_currentBurst);
m_nrRemainingBlocksToSend--;
Simulator::Schedule (m_blockTime, &SimpleOfdmWimaxPhy::EndSendFecBlock, this, modulationType, direction);
}
void
SimpleOfdmWimaxPhy::EndSendFecBlock (WimaxPhy::ModulationType modulationType,
uint8_t direction)
{
m_nrFecBlocksSent++;
SetState (PHY_STATE_IDLE);
if (m_nrFecBlocksSent * m_blockSize == m_currentBurstSize * 8 + m_paddingBits)
{
// this is the last FEC block of the burst
NS_ASSERT_MSG (m_nrRemainingBlocksToSend == 0, "Error while sending a burst");
NotifyTxEnd (m_currentBurst);
}
else
{
StartSendDummyFecBlock (false,modulationType,direction);
}
}
void
SimpleOfdmWimaxPhy::EndSend (void)
{
SetState (PHY_STATE_IDLE);
}
void
SimpleOfdmWimaxPhy::StartReceive (uint32_t burstSize,
bool isFirstBlock,
uint64_t frequency,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
double rxPower,
Ptr<PacketBurst> burst)
{
UniformVariable URNG;
uint8_t drop = 0;
double Nwb = -114 + m_noiseFigure + 10 * log (GetBandwidth () / 1000000000.0) / 2.303;
double SNR = rxPower - Nwb;
SNRToBlockErrorRateRecord * record = m_snrToBlockErrorRateManager->GetSNRToBlockErrorRateRecord (SNR, modulationType);
double I1 = record->GetI1 ();
double I2 = record->GetI2 ();
double blockErrorRate = URNG.GetValue (I1, I2);
double rand = URNG.GetValue (0.0, 1.0);
if (rand < blockErrorRate)
{
drop = 1;
}
if (rand > blockErrorRate)
{
drop = 0;
}
if (blockErrorRate == 1.0)
{
drop = 1;
}
if (blockErrorRate == 0.0)
{
drop = 0;
}
delete record;
NS_LOG_INFO ("PHY: Receive rxPower=" << rxPower << ", Nwb=" << Nwb << ", SNR=" << SNR << ", Modulation="
<< modulationType << ", BlocErrorRate=" << blockErrorRate << ", drop=" << (int) drop);
switch (GetState ())
{
case PHY_STATE_SCANNING:
if (frequency == GetScanningFrequency ())
{
Simulator::Cancel (GetChnlSrchTimeoutEvent ());
SetScanningCallback ();
SetSimplex (frequency);
SetState (PHY_STATE_IDLE);
}
break;
case PHY_STATE_IDLE:
if (frequency == GetRxFrequency ())
{
if (isFirstBlock)
{
NotifyRxBegin (burst);
m_receivedFecBlocks->clear ();
m_nrRecivedFecBlocks=0;
SetBlockParameters (burstSize, modulationType);
m_blockTime = GetBlockTransmissionTime (modulationType);
}
Simulator::Schedule (m_blockTime,
&SimpleOfdmWimaxPhy::EndReceiveFecBlock,
this,
burstSize,
modulationType,
direction,
drop,
burst);
SetState (PHY_STATE_RX);
}
break;
case PHY_STATE_RX:
// drop
break;
case PHY_STATE_TX:
if (IsDuplex () && frequency == GetRxFrequency ())
{
}
break;
}
}
void
SimpleOfdmWimaxPhy::EndReceiveFecBlock (uint32_t burstSize,
WimaxPhy::ModulationType modulationType,
uint8_t direction,
uint8_t drop,
Ptr<PacketBurst> burst)
{
SetState (PHY_STATE_IDLE);
m_nrRecivedFecBlocks++;
if (drop == true)
{
m_nbErroneousBlock++;
}
if ((uint32_t) m_nrRecivedFecBlocks * m_blockSize == burstSize * 8 + m_paddingBits)
{
NotifyRxEnd (burst);
if (m_nbErroneousBlock == 0)
{
Simulator::Schedule (Seconds (0),
&SimpleOfdmWimaxPhy::EndReceive,
this,
burst);
}
else
{
NotifyRxDrop (burst);
}
m_nbErroneousBlock = 0;
m_nrRecivedFecBlocks = 0;
}
}
void
SimpleOfdmWimaxPhy::EndReceive (Ptr<const PacketBurst> burst)
{
Ptr<PacketBurst> b = burst->Copy ();
GetReceiveCallback () (b);
m_traceRx (burst);
}
bvec
SimpleOfdmWimaxPhy::ConvertBurstToBits (Ptr<const PacketBurst> burst)
{
bvec buffer (burst->GetSize () * 8, 0);
std::list<Ptr<Packet> > packets = burst->GetPackets ();
uint32_t j = 0;
for (std::list<Ptr<Packet> >::iterator iter = packets.begin (); iter != packets.end (); ++iter)
{
Ptr<Packet> packet = *iter;
uint8_t *pstart = (uint8_t*) malloc (packet->GetSize ());
memset (pstart, 0, packet->GetSize ());
packet->CopyData (pstart, packet->GetSize ());
bvec temp (8);
temp.resize (0, 0);
temp.resize (8, 0);
for (uint32_t i = 0; i < packet->GetSize (); i++)
{
for (uint8_t l = 0; l < 8; l++)
{
temp[l] = (bool)((((uint8_t) pstart[i]) >> (7 - l)) & 0x01);
buffer.at (j * 8 + l) = temp[l];
}
j++;
}
free (pstart);
}
return buffer;
}
/*
Converts back the bit buffer (bvec) to the actual burst.
Actually creates byte buffer from the bvec and resets the buffer
of each packet in the copy of the orifinal burst stored before transmitting.
By doing this it preserves the metadata and tags in the packet.
Function could also be named DeserializeBurst because actually it
copying to the burst's byte buffer.
*/
Ptr<PacketBurst>
SimpleOfdmWimaxPhy::ConvertBitsToBurst (bvec buffer)
{
uint8_t init[buffer.size () / 8];
uint8_t *pstart = init;
uint8_t temp;
int32_t j = 0;
// recreating byte buffer from bit buffer (bvec)
for (uint32_t i = 0; i < buffer.size (); i += 8)
{
temp = 0;
for (int l = 0; l < 8; l++)
{
bool bin = buffer.at (i + l);
temp += (uint8_t)(bin * pow (2, (7 - l)));
}
*(pstart + j) = temp;
j++;
}
uint16_t bufferSize = buffer.size () / 8;
uint16_t pos = 0;
Ptr<PacketBurst> RecvBurst = Create<PacketBurst> ();
while (pos < bufferSize)
{
uint16_t packetSize = 0;
// Get the header type: first bit
uint8_t ht = (pstart[pos] >> 7) & 0x01;
if (ht == 1)
{
// BW request header. Size is always 8 bytes
packetSize = 6;
}
else
{
// Read the size
uint8_t Len_MSB = pstart[pos + 1] & 0x07;
packetSize = (uint16_t)((uint16_t)(Len_MSB << 8) | (uint16_t)(pstart[pos + 2]));
if (packetSize == 0)
{
break; // padding
}
}
Ptr<Packet> p = Create<Packet> (&(pstart[pos]), packetSize);
RecvBurst->AddPacket (p);
pos += packetSize;
}
return RecvBurst;
}
void
SimpleOfdmWimaxPhy::CreateFecBlocks (const bvec &buffer, WimaxPhy::ModulationType modulationType)
{
bvec fecBlock (m_blockSize);
for (uint32_t i = 0, j = m_nrBlocks; j > 0; i += m_blockSize, j--)
{
if (j == 1 && m_paddingBits > 0) // last block can be smaller than block size
{
fecBlock = bvec (buffer.begin () + i, buffer.end ());
fecBlock.resize (m_blockSize, 0);
}
else
{
fecBlock = bvec (buffer.begin () + i, buffer.begin () + i + m_blockSize);
}
m_fecBlocks->push_back (fecBlock);
}
}
bvec
SimpleOfdmWimaxPhy::RecreateBuffer ()
{
bvec buffer (m_blockSize * m_nrBlocks);
bvec block (m_blockSize);
uint32_t i = 0;
for (uint32_t j = 0; j < m_nrBlocks; j++)
{
bvec tmpRecFecBloc = m_receivedFecBlocks->front ();
buffer.insert (buffer.begin () + i, tmpRecFecBloc.begin (), tmpRecFecBloc.end ());
m_receivedFecBlocks->pop_front ();
i += m_blockSize;
}
return buffer;
}
void
SimpleOfdmWimaxPhy::DoSetDataRates (void)
{
m_dataRateBpsk12 = CalculateDataRate (MODULATION_TYPE_BPSK_12); // 6912000 bps
m_dataRateQpsk12 = CalculateDataRate (MODULATION_TYPE_QPSK_12); // 13824000
m_dataRateQpsk34 = CalculateDataRate (MODULATION_TYPE_QPSK_34); // 20736000
m_dataRateQam16_12 = CalculateDataRate (MODULATION_TYPE_QAM16_12); // 27648000
m_dataRateQam16_34 = CalculateDataRate (MODULATION_TYPE_QAM16_34); // 41472000
m_dataRateQam64_23 = CalculateDataRate (MODULATION_TYPE_QAM64_23); // 55224000
m_dataRateQam64_34 = CalculateDataRate (MODULATION_TYPE_QAM64_34); // 62208000
}
void
SimpleOfdmWimaxPhy::GetModulationFecParams (WimaxPhy::ModulationType modulationType,
uint8_t &bitsPerSymbol,
double &fecCode) const
{
switch (modulationType)
{
case MODULATION_TYPE_BPSK_12:
bitsPerSymbol = 1;
fecCode = (double) 1 / 2;
break;
case MODULATION_TYPE_QPSK_12:
bitsPerSymbol = 2;
fecCode = (double) 1 / 2;
break;
case MODULATION_TYPE_QPSK_34:
bitsPerSymbol = 2;
fecCode = (double) 3 / 4;
break;
case MODULATION_TYPE_QAM16_12:
bitsPerSymbol = 4;
fecCode = (double) 1 / 2;
break;
case MODULATION_TYPE_QAM16_34:
bitsPerSymbol = 4;
fecCode = (double) 3 / 4;
break;
case MODULATION_TYPE_QAM64_23:
bitsPerSymbol = 6;
fecCode = (double) 2 / 3;
break;
case MODULATION_TYPE_QAM64_34:
bitsPerSymbol = 6;
fecCode = 0.75;
break;
}
}
uint32_t
SimpleOfdmWimaxPhy::CalculateDataRate (WimaxPhy::ModulationType modulationType) const
{
uint8_t bitsPerSymbol = 0;
double fecCode = 0;
GetModulationFecParams (modulationType, bitsPerSymbol, fecCode);
double symbolsPerSecond = 1 / GetSymbolDuration ().GetSeconds ();
uint16_t bitsTransmittedPerSymbol = (uint16_t)(bitsPerSymbol * GetNrCarriers () * fecCode);
// 96, 192, 288, 384, 576, 767 and 864 bits per symbol for the seven modulations, respectively
return (uint32_t) symbolsPerSecond * bitsTransmittedPerSymbol;
}
uint32_t
SimpleOfdmWimaxPhy::DoGetDataRate (WimaxPhy::ModulationType modulationType) const
{
switch (modulationType)
{
case MODULATION_TYPE_BPSK_12:
return m_dataRateBpsk12;
break;
case MODULATION_TYPE_QPSK_12:
return m_dataRateQpsk12;
break;
case MODULATION_TYPE_QPSK_34:
return m_dataRateQpsk34;
break;
case MODULATION_TYPE_QAM16_12:
return m_dataRateQam16_12;
break;
case MODULATION_TYPE_QAM16_34:
return m_dataRateQam16_34;
break;
case MODULATION_TYPE_QAM64_23:
return m_dataRateQam64_23;
break;
case MODULATION_TYPE_QAM64_34:
return m_dataRateQam64_34;
break;
}
NS_FATAL_ERROR ("Invalid modulation type");
return 0;
}
Time
SimpleOfdmWimaxPhy::GetBlockTransmissionTime (WimaxPhy::ModulationType modulationType) const
{
return Seconds ((double) GetFecBlockSize (modulationType) / DoGetDataRate (modulationType));
}
Time
SimpleOfdmWimaxPhy::DoGetTransmissionTime (uint32_t size, WimaxPhy::ModulationType modulationType) const
{
/*adding 3 extra nano second to cope with the loss of precision problem.
the time is internally stored in a 64 bit hence a floating-point time would loss
precision, e.g., 0.00001388888888888889 seconds will become 13888888888 femtoseconds.*/
return Seconds (DoGetNrSymbols (size, modulationType) * GetSymbolDuration ().GetSeconds ()) + NanoSeconds (3);
}
uint64_t
SimpleOfdmWimaxPhy::DoGetNrSymbols (uint32_t size, WimaxPhy::ModulationType modulationType) const
{
Time transmissionTime = Seconds ((double)(GetNrBlocks (size, modulationType) * GetFecBlockSize (modulationType))
/ DoGetDataRate (modulationType));
return (uint64_t) ceil (transmissionTime.GetSeconds () / GetSymbolDuration ().GetSeconds ());
}
uint64_t
SimpleOfdmWimaxPhy::DoGetNrBytes (uint32_t symbols, WimaxPhy::ModulationType modulationType) const
{
Time transmissionTime = Seconds (symbols * GetSymbolDuration ().GetSeconds ());
return (uint64_t) floor ((transmissionTime.GetSeconds () * DoGetDataRate (modulationType)) / 8);
}
uint32_t
SimpleOfdmWimaxPhy::GetFecBlockSize (WimaxPhy::ModulationType modulationType) const
{
uint32_t blockSize = 0;
switch (modulationType)
{
case MODULATION_TYPE_BPSK_12:
blockSize = 12;
break;
case MODULATION_TYPE_QPSK_12:
blockSize = 24;
break;
case MODULATION_TYPE_QPSK_34:
blockSize = 36;
break;
case MODULATION_TYPE_QAM16_12:
blockSize = 48;
break;
case MODULATION_TYPE_QAM16_34:
blockSize = 72;
break;
case MODULATION_TYPE_QAM64_23:
blockSize = 96;
break;
case MODULATION_TYPE_QAM64_34:
blockSize = 108;
break;
default:
NS_FATAL_ERROR ("Invalid modulation type");
break;
}
return blockSize * 8; // in bits
}
// Channel coding block size, Table 215, page 434
uint32_t
SimpleOfdmWimaxPhy::GetCodedFecBlockSize (WimaxPhy::ModulationType modulationType) const
{
uint32_t blockSize = 0;
switch (modulationType)
{
case MODULATION_TYPE_BPSK_12:
blockSize = 24;
break;
case MODULATION_TYPE_QPSK_12:
blockSize = 48;
break;
case MODULATION_TYPE_QPSK_34:
blockSize = 48;
break;
case MODULATION_TYPE_QAM16_12:
blockSize = 96;
break;
case MODULATION_TYPE_QAM16_34:
blockSize = 96;
break;
case MODULATION_TYPE_QAM64_23:
blockSize = 144;
break;
case MODULATION_TYPE_QAM64_34:
blockSize = 144;
break;
default:
NS_FATAL_ERROR ("Invalid modulation type");
break;
}
return blockSize * 8; // in bits
}
void
SimpleOfdmWimaxPhy::SetBlockParameters (uint32_t burstSize, WimaxPhy::ModulationType modulationType)
{
m_blockSize = GetFecBlockSize (modulationType);
m_nrBlocks = GetNrBlocks (burstSize, modulationType);
m_paddingBits = (m_nrBlocks * m_blockSize) - (burstSize * 8);
m_nrRemainingBlocksToSend = m_nrBlocks;
NS_ASSERT_MSG (static_cast<uint32_t> (m_nrBlocks * m_blockSize) >= (burstSize * 8), "Size of padding bytes < 0");
}
uint16_t
SimpleOfdmWimaxPhy::DoGetTtg (void) const
{
// assumed equal to 2 symbols
return 2 * GetPsPerSymbol ();
}
uint16_t
SimpleOfdmWimaxPhy::DoGetRtg (void) const
{
// assumed equal to 2 symbols
return 2 * GetPsPerSymbol ();
}
uint8_t
SimpleOfdmWimaxPhy::DoGetFrameDurationCode (void) const
{
uint16_t duration = 0;
duration = (uint16_t)(GetFrameDuration ().GetSeconds () * 10000);
switch (duration)
{
case 25:
{
return FRAME_DURATION_2_POINT_5_MS;
break;
}
case 40:
{
return FRAME_DURATION_4_MS;
break;
}
case 50:
{
return FRAME_DURATION_5_MS;
break;
}
case 80:
{
return FRAME_DURATION_8_MS;
break;
}
case 100:
{
return FRAME_DURATION_10_MS;
break;
}
case 125:
{
return FRAME_DURATION_12_POINT_5_MS;
break;
}
case 200:
{
return FRAME_DURATION_20_MS;
break;
}
default:
{
NS_FATAL_ERROR ("Invalid frame duration = " << duration);
return 0;
}
}
NS_FATAL_ERROR ("Invalid frame duration = " << duration);
return 0;
}
Time
SimpleOfdmWimaxPhy::DoGetFrameDuration (uint8_t frameDurationCode) const
{
switch (frameDurationCode)
{
case FRAME_DURATION_2_POINT_5_MS:
return Seconds (2.5);
break;
case FRAME_DURATION_4_MS:
return Seconds (4);
break;
case FRAME_DURATION_5_MS:
return Seconds (5);
break;
case FRAME_DURATION_8_MS:
return Seconds (8);
break;
case FRAME_DURATION_10_MS:
return Seconds (10);
break;
case FRAME_DURATION_12_POINT_5_MS:
return Seconds (12.5);
break;
case FRAME_DURATION_20_MS:
return Seconds (20);
break;
default:
NS_FATAL_ERROR ("Invalid modulation type");
}
return Seconds (0);
}
/*
Retruns number of blocks (FEC blocks) the burst will be splitted in.
The size of the block is specific for each modulation type.
*/
uint16_t
SimpleOfdmWimaxPhy::GetNrBlocks (uint32_t burstSize, WimaxPhy::ModulationType modulationType) const
{
uint32_t blockSize = GetFecBlockSize (modulationType);
uint16_t nrBlocks = (burstSize * 8) / blockSize;
if ((burstSize * 8) % blockSize > 0)
{
nrBlocks += 1;
}
return nrBlocks;
}
/*---------------------PHY parameters functions-----------------------*/
void
SimpleOfdmWimaxPhy::DoSetPhyParameters (void)
{
/*Calculations as per section 8.3.2.
Currently assuming license-exempt 5 GHz band. For channel bandwidth 20 MHz (Table B.28, page 812) and frame duration 10 ms
(Table 232, page 460) i.e, 100 frames per second, sampling frequency is 23040000, symbol (OFDM symbol) duration is
1.388888888888889e-05 seconds, PS duration is 1.7361111111111112e-07 seconds. Hence PSs per frame is 57600, symbols per frame
is 720 and PSs per symbol is 80. Note that defining these parameters (symbol and PS duration) as Time may not result in exaclty
these values therefore lrint has been used (otherwise should be defined as double).
For licensed bands set channel bandwidth according to Table B.26, page 810.*/
double samplingFrequency = DoGetSamplingFrequency ();
Time psDuration = Seconds ((double) 4 / samplingFrequency);
SetPsDuration (psDuration);
uint16_t psPerFrame = (uint16_t)(GetFrameDuration ().GetSeconds () / psDuration.GetSeconds ());
SetPsPerFrame (psPerFrame);
double subcarrierSpacing = samplingFrequency / DoGetNfft ();
double tb = (double) 1 / subcarrierSpacing; // Tb (useful symbol time)
double tg = DoGetGValue () * tb; // Tg (cyclic prefix time)
Time symbolDuration = Seconds (tb + tg); // OFDM Symbol Time
SetSymbolDuration (symbolDuration);
uint16_t psPerSymbol = lrint (symbolDuration.GetSeconds () / psDuration.GetSeconds ());
SetPsPerSymbol (psPerSymbol);
uint32_t symbolsPerFrame = lrint (GetFrameDuration ().GetSeconds () / symbolDuration.GetSeconds ());
SetSymbolsPerFrame (symbolsPerFrame);
}
void
SimpleOfdmWimaxPhy::DoSetNfft (uint16_t nfft)
{
m_nfft = nfft;
}
uint16_t
SimpleOfdmWimaxPhy::DoGetNfft (void) const
{
return m_nfft;
}
double
SimpleOfdmWimaxPhy::DoGetSamplingFactor (void) const
{
// sampling factor (n), see Table 213, page 429
uint32_t channelBandwidth = GetChannelBandwidth ();
if (channelBandwidth % 1750000 == 0)
{
return (double) 8 / 7;
}
else if (channelBandwidth % 1500000 == 0)
{
return (double) 86 / 75;
}
else if (channelBandwidth % 1250000 == 0)
{
return (double) 144 / 125;
}
else if (channelBandwidth % 2750000 == 0)
{
return (double) 316 / 275;
}
else if (channelBandwidth % 2000000 == 0)
{
return (double) 57 / 50;
}
else
{
NS_LOG_DEBUG ("Oops may be wrong channel bandwidth for OFDM PHY!");
NS_FATAL_ERROR ("wrong channel bandwidth for OFDM PHY");
}
return (double) 8 / 7;
}
double
SimpleOfdmWimaxPhy::DoGetSamplingFrequency (void) const
{
// sampling frequency (Fs), see 8.3.2.2
return (DoGetSamplingFactor () * GetChannelBandwidth () / 8000) * 8000;
}
double
SimpleOfdmWimaxPhy::DoGetGValue (void) const
{
return m_g;
}
void
SimpleOfdmWimaxPhy::DoSetGValue (double g)
{
m_g = g;
}
void
SimpleOfdmWimaxPhy::SetTxGain (double txGain)
{
m_txGain = txGain;
}
void
SimpleOfdmWimaxPhy::SetRxGain (double txRain)
{
m_rxGain = txRain;
}
double
SimpleOfdmWimaxPhy::GetTxGain (void) const
{
return m_txGain;
}
double
SimpleOfdmWimaxPhy::GetRxGain (void) const
{
return m_rxGain;
}
std::string
SimpleOfdmWimaxPhy::GetTraceFilePath (void) const
{
return (m_snrToBlockErrorRateManager->GetTraceFilePath ());
}
void
SimpleOfdmWimaxPhy::SetTraceFilePath (std::string path)
{
m_snrToBlockErrorRateManager->SetTraceFilePath ((char*) path.c_str ());
m_snrToBlockErrorRateManager->LoadTraces ();
}
void
SimpleOfdmWimaxPhy::NotifyTxBegin (Ptr<PacketBurst> burst)
{
m_phyTxBeginTrace (burst);
}
void
SimpleOfdmWimaxPhy::NotifyTxEnd (Ptr<PacketBurst> burst)
{
m_phyTxEndTrace (burst);
}
void
SimpleOfdmWimaxPhy::NotifyTxDrop (Ptr<PacketBurst> burst)
{
m_phyTxDropTrace (burst);
}
void
SimpleOfdmWimaxPhy::NotifyRxBegin (Ptr<PacketBurst> burst)
{
m_phyRxBeginTrace (burst);
}
void
SimpleOfdmWimaxPhy::NotifyRxEnd (Ptr<PacketBurst> burst)
{
m_phyRxEndTrace (burst);
}
void
SimpleOfdmWimaxPhy::NotifyRxDrop (Ptr<PacketBurst> burst)
{
m_phyRxDropTrace (burst);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/simple-ofdm-wimax-phy.cc | C++ | gpl2 | 30,274 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "bs-scheduler.h"
#include "ns3/simulator.h"
#include "bs-net-device.h"
#include "ns3/packet-burst.h"
#include "cid.h"
#include "wimax-mac-header.h"
#include "ss-record.h"
#include "wimax-mac-queue.h"
#include "ns3/log.h"
#include "burst-profile-manager.h"
#include "wimax-connection.h"
#include "connection-manager.h"
#include "ss-manager.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
NS_LOG_COMPONENT_DEFINE ("BSScheduler");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BSScheduler);
TypeId
BSScheduler::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BSScheduler").SetParent<Object> ();
return tid;
}
BSScheduler::BSScheduler ()
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
// m_downlinkBursts is filled by AddDownlinkBurst and emptied by
// wimax-bs-net-device::sendBurst and wimax-ss-net-device::sendBurst
}
BSScheduler::BSScheduler (Ptr<BaseStationNetDevice> bs)
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
}
BSScheduler::~BSScheduler (void)
{
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *downlinkBursts = m_downlinkBursts;
std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > pair;
while (downlinkBursts->size ())
{
pair = downlinkBursts->front ();
pair.second = 0;
delete pair.first;
}
SetBs (0);
delete m_downlinkBursts;
m_downlinkBursts = 0;
}
void
BSScheduler::SetBs (Ptr<BaseStationNetDevice> bs)
{
m_bs = bs;
}
Ptr<BaseStationNetDevice> BSScheduler::GetBs (void)
{
return m_bs;
}
bool
BSScheduler::CheckForFragmentation (Ptr<WimaxConnection> connection,
int availableSymbols,
WimaxPhy::ModulationType modulationType)
{
NS_LOG_INFO ("BS Scheduler, CheckForFragmentation");
if (connection->GetType () != Cid::TRANSPORT)
{
NS_LOG_INFO ("\t No Transport connction, Fragmentation IS NOT possible");
return false;
}
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
uint32_t headerSize = connection->GetQueue ()->GetFirstPacketHdrSize (
MacHeaderType::HEADER_TYPE_GENERIC);
NS_LOG_INFO ("\t availableByte = " << availableByte <<
" headerSize = " << headerSize);
if (availableByte > headerSize)
{
NS_LOG_INFO ("\t Fragmentation IS possible");
return true;
}
else
{
NS_LOG_INFO ("\t Fragmentation IS NOT possible");
return false;
}
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-scheduler.cc | C++ | gpl2 | 3,406 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef SEND_PARAMS_H
#define SEND_PARAMS_H
#include <stdint.h>
namespace ns3 {
class WimaxPhy;
/**
* \ingroup wimax
* \brief The SendParams class defines the parameters with which Send() function of
* a particular PHY is called. The sole purpose of this class is to allow
* defining the pure virtual Send() function in the PHY base-class (WimaxPhy).
* This class shall be sub-classed every time a new PHY is integrated (i.e.,
* a new sub-class of WimaxPhy is created) which requires different or
* additional parameters to call its Send() function. For example as it is
* seen here, it has been sub-classed for the OFDM PHY layer since its Send()
* function requires two additional parameters.
*/
class SendParams
{
public:
SendParams ();
virtual ~SendParams ();
private:
};
} // namespace ns3
#endif /* SEND_PARAMS_H */
#ifndef OFDM_SEND_PARAMS_H
#define OFDM_SEND_PARAMS_H
#include <stdint.h>
#include "ns3/packet-burst.h"
namespace ns3 {
class OfdmSendParams : public SendParams
{
/**
* \see SendParams
*/
public:
OfdmSendParams (Ptr<PacketBurst> burst, uint8_t modulationType,
uint8_t direction);
~OfdmSendParams ();
Ptr<PacketBurst> GetBurst () const
{
return m_burst;
}
uint8_t GetModulationType () const
{
return m_modulationType;
}
uint8_t GetDirection () const
{
return m_direction;
}
private:
Ptr<PacketBurst> m_burst;
uint8_t m_modulationType;
uint8_t m_direction;
};
} // namespace ns3
#endif /* OFDM_SEND_PARAMS_H */
| zy901002-gpsr | src/wimax/model/send-params.h | C++ | gpl2 | 2,358 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#ifndef CONNECTION_MANAGER_H
#define CONNECTION_MANAGER_H
#include <stdint.h>
#include "cid.h"
#include "wimax-connection.h"
#include "ns3/mac48-address.h"
namespace ns3 {
class CidFactory;
class SSRecord;
class RngRsp;
class WimaxNetDevice;
class SubscriberStationNetDevice;
/**
* \ingroup wimax
* The same connection manager class serves both for BS and SS though some functions are exclusive to only one of them.
*/
class ConnectionManager : public Object
{
public:
static TypeId GetTypeId (void);
ConnectionManager (void);
~ConnectionManager (void);
void DoDispose (void);
void SetCidFactory (CidFactory *cidFactory);
/**
* \brief allocates the management connection for an ss record. This method is only used by BS
* \param ssRecord the ss record to wich the management connection will be allocated
* \param rngrsp the ranging response message
*/
void AllocateManagementConnections (SSRecord *ssRecord, RngRsp *rngrsp);
/**
* \brief create a connection of type type
* \param type type of the connection to create
*/
Ptr<WimaxConnection> CreateConnection (Cid::Type type);
/**
* \brief add a connection to the list of managed connections
* \param connection the connection to add
* \param type the type of connection to add
*/
void AddConnection (Ptr<WimaxConnection> connection, Cid::Type type);
/**
* \return the connection which has as identifier cid
*/
Ptr<WimaxConnection> GetConnection (Cid cid);
/**
* \return a listy of all connection which have as type type
*/
std::vector<Ptr<WimaxConnection> > GetConnections (Cid::Type type) const;
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<Ptr<WimaxConnection> > m_basicConnections;
std::vector<Ptr<WimaxConnection> > m_primaryConnections;
std::vector<Ptr<WimaxConnection> > m_transportConnections;
std::vector<Ptr<WimaxConnection> > m_multicastConnections;
// only for BS
CidFactory *m_cidFactory;
};
} // namespace ns3
#endif /* CONNECTION_MANAGER_H */
| zy901002-gpsr | src/wimax/model/connection-manager.h | C++ | gpl2 | 3,176 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include "ss-record.h"
#include "service-flow.h"
#include <stdint.h>
namespace ns3 {
SSRecord::SSRecord (void)
{
Initialize ();
}
SSRecord::SSRecord (Mac48Address macAddress)
{
m_macAddress = macAddress;
Initialize ();
}
SSRecord::SSRecord (Mac48Address macAddress, Ipv4Address IPaddress)
{
m_macAddress = macAddress;
m_IPAddress = IPaddress;
Initialize ();
}
void
SSRecord::Initialize (void)
{
m_basicCid = Cid ();
m_primaryCid = Cid ();
m_rangingCorrectionRetries = 0;
m_invitedRangingRetries = 0;
m_modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
m_rangingStatus = WimaxNetDevice::RANGING_STATUS_EXPIRED;
m_pollForRanging = false;
m_areServiceFlowsAllocated = false;
m_pollMeBit = false;
m_sfTransactionId = 0;
m_dsaRspRetries = 0;
m_serviceFlows = new std::vector<ServiceFlow*> ();
m_dsaRsp = DsaRsp ();
m_broadcast = 0;
}
SSRecord::~SSRecord (void)
{
delete m_serviceFlows;
m_serviceFlows = 0;
}
void
SSRecord::SetIPAddress (Ipv4Address IPAddress)
{
m_IPAddress = IPAddress;
}
Ipv4Address SSRecord::GetIPAddress (void)
{
return m_IPAddress;
}
void
SSRecord::SetBasicCid (Cid basicCid)
{
m_basicCid = basicCid;
}
Cid
SSRecord::GetBasicCid (void) const
{
return m_basicCid;
}
void
SSRecord::SetPrimaryCid (Cid primaryCid)
{
m_primaryCid = primaryCid;
}
Cid
SSRecord::GetPrimaryCid (void) const
{
return m_primaryCid;
}
void
SSRecord::SetMacAddress (Mac48Address macAddress)
{
m_macAddress = macAddress;
}
Mac48Address
SSRecord::GetMacAddress (void) const
{
return m_macAddress;
}
uint8_t
SSRecord::GetRangingCorrectionRetries (void) const
{
return m_rangingCorrectionRetries;
}
void
SSRecord::ResetRangingCorrectionRetries (void)
{
m_rangingCorrectionRetries = 0;
}
void
SSRecord::IncrementRangingCorrectionRetries (void)
{
m_rangingCorrectionRetries++;
}
uint8_t
SSRecord::GetInvitedRangRetries (void) const
{
return m_invitedRangingRetries;
}
void
SSRecord::ResetInvitedRangingRetries (void)
{
m_invitedRangingRetries = 0;
}
void
SSRecord::IncrementInvitedRangingRetries (void)
{
m_invitedRangingRetries++;
}
void
SSRecord::SetModulationType (WimaxPhy::ModulationType modulationType)
{
m_modulationType = modulationType;
}
WimaxPhy::ModulationType
SSRecord::GetModulationType (void) const
{
return m_modulationType;
}
void
SSRecord::SetRangingStatus (WimaxNetDevice::RangingStatus rangingStatus)
{
m_rangingStatus = rangingStatus;
}
WimaxNetDevice::RangingStatus
SSRecord::GetRangingStatus (void) const
{
return m_rangingStatus;
}
void
SSRecord::EnablePollForRanging (void)
{
m_pollForRanging = true;
}
void
SSRecord::DisablePollForRanging (void)
{
m_pollForRanging = false;
}
bool
SSRecord::GetPollForRanging (void) const
{
return m_pollForRanging;
}
void
SSRecord::SetAreServiceFlowsAllocated (bool val)
{
m_areServiceFlowsAllocated = val;
}
bool
SSRecord::GetAreServiceFlowsAllocated (void) const
{
return m_areServiceFlowsAllocated;
}
void
SSRecord::SetPollMeBit (bool pollMeBit)
{
m_pollMeBit = pollMeBit;
}
bool
SSRecord::GetPollMeBit (void) const
{
return m_pollMeBit;
}
void
SSRecord::AddServiceFlow (ServiceFlow *serviceFlow)
{
m_serviceFlows->push_back (serviceFlow);
}
std::vector<ServiceFlow*> SSRecord::GetServiceFlows (enum ServiceFlow::SchedulingType schedulingType) const
{
std::vector<ServiceFlow*> tmpServiceFlows;
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if (((*iter)->GetSchedulingType () == schedulingType) || (schedulingType == ServiceFlow::SF_TYPE_ALL))
{
tmpServiceFlows.push_back ((*iter));
}
}
return tmpServiceFlows;
}
void
SSRecord::SetIsBroadcastSS (bool broadcast_enable)
{
m_broadcast = broadcast_enable;
}
bool
SSRecord::GetIsBroadcastSS (void)
{
return m_broadcast;
}
bool
SSRecord::GetHasServiceFlowUgs (void) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetSchedulingType () == ServiceFlow::SF_TYPE_UGS)
{
return true;
}
}
return false;
}
bool
SSRecord::GetHasServiceFlowRtps (void) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetSchedulingType () == ServiceFlow::SF_TYPE_RTPS)
{
return true;
}
}
return false;
}
bool
SSRecord::GetHasServiceFlowNrtps (void) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetSchedulingType () == ServiceFlow::SF_TYPE_NRTPS)
{
return true;
}
}
return false;
}
bool
SSRecord::GetHasServiceFlowBe (void) const
{
for (std::vector<ServiceFlow*>::iterator iter = m_serviceFlows->begin (); iter != m_serviceFlows->end (); ++iter)
{
if ((*iter)->GetSchedulingType () == ServiceFlow::SF_TYPE_BE)
{
return true;
}
}
return false;
}
void
SSRecord::SetSfTransactionId (uint16_t sfTransactionId)
{
m_sfTransactionId = sfTransactionId;
}
uint16_t SSRecord::GetSfTransactionId (void) const
{
return m_sfTransactionId;
}
void
SSRecord::SetDsaRspRetries (uint8_t dsaRspRetries)
{
m_dsaRspRetries = dsaRspRetries;
}
void
SSRecord::IncrementDsaRspRetries (void)
{
m_dsaRspRetries++;
}
uint8_t
SSRecord::GetDsaRspRetries (void) const
{
return m_dsaRspRetries;
}
void
SSRecord::SetDsaRsp (DsaRsp dsaRsp)
{
m_dsaRsp = dsaRsp;
}
DsaRsp
SSRecord::GetDsaRsp (void) const
{
return m_dsaRsp;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ss-record.cc | C++ | gpl2 | 6,598 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef BURST_PROFILE_MANAGER_H
#define BURST_PROFILE_MANAGER_H
#include <stdint.h>
#include "cid.h"
#include "wimax-phy.h"
#include "wimax-net-device.h"
namespace ns3 {
class SSRecord;
class RngReq;
/**
* \ingroup wimax
*/
class BurstProfileManager : public Object
{
public:
static TypeId GetTypeId (void);
BurstProfileManager (Ptr<WimaxNetDevice> 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
* \returns the modulation type of the selected iuc
*/
WimaxPhy::ModulationType GetModulationType (uint8_t iuc,
WimaxNetDevice::Direction direction) const;
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
*
*/
uint8_t GetBurstProfileForSS (const SSRecord *ssRecord, const RngReq *rngreq,
WimaxPhy::ModulationType &modulationType);
WimaxPhy::ModulationType GetModulationTypeForSS (const SSRecord *ssRecord,
const RngReq *rngreq);
uint8_t GetBurstProfileToRequest (void);
private:
BurstProfileManager (const BurstProfileManager &);
BurstProfileManager& operator= (const BurstProfileManager &);
Ptr<WimaxNetDevice> m_device;
};
} // namespace ns3
#endif /* BURST_PROFILE_MANAGER_H */
| zy901002-gpsr | src/wimax/model/burst-profile-manager.h | C++ | gpl2 | 2,626 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c)
*
* 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: Juliana Freitag Borin, Flavio Kubota and Nelson L.
* S. da Fonseca - wimaxgroup@lrc.ic.unicamp.br
*/
#include <stdint.h>
#include "ul-job.h"
namespace ns3 {
UlJob::UlJob (void) : m_deadline (Seconds (0)), m_size (0)
{
}
UlJob::~UlJob (void)
{
}
SSRecord*
UlJob::GetSsRecord (void)
{
return m_ssRecord;
}
void
UlJob::SetSsRecord (SSRecord* ssRecord)
{
m_ssRecord = ssRecord;
}
enum
ServiceFlow::SchedulingType UlJob::GetSchedulingType (void)
{
return m_schedulingType;
}
void
UlJob::SetSchedulingType (ServiceFlow::SchedulingType schedulingType)
{
m_schedulingType = schedulingType;
}
ReqType
UlJob::GetType (void)
{
return m_type;
}
void
UlJob::SetType (ReqType type)
{
m_type = type;
}
ServiceFlow *
UlJob::GetServiceFlow (void)
{
return m_serviceFlow;
}
void
UlJob::SetServiceFlow (ServiceFlow *serviceFlow)
{
m_serviceFlow = serviceFlow;
}
Time
UlJob::GetReleaseTime (void)
{
return m_releaseTime;
}
void
UlJob::SetReleaseTime (Time releaseTime)
{
m_releaseTime = releaseTime;
}
Time
UlJob::GetPeriod (void)
{
return m_period;
}
void
UlJob::SetPeriod (Time period)
{
m_period = period;
}
Time
UlJob::GetDeadline (void)
{
return m_deadline;
}
void
UlJob::SetDeadline (Time deadline)
{
m_deadline = deadline;
}
uint32_t
UlJob::GetSize (void)
{
return m_size;
}
void
UlJob::SetSize (uint32_t size)
{
m_size = size;
}
bool operator == (const UlJob &a, const UlJob &b)
{
UlJob A = a;
UlJob B = b;
if ((A.GetServiceFlow () == B.GetServiceFlow ()) && (A.GetSsRecord () == B.GetSsRecord ()))
{
return true;
}
return false;
}
PriorityUlJob::PriorityUlJob (void)
{
}
int
PriorityUlJob::GetPriority (void)
{
return m_priority;
}
void
PriorityUlJob::SetPriority (int priority)
{
m_priority = priority;
}
Ptr<UlJob>
PriorityUlJob::GetUlJob (void)
{
return m_job;
}
void
PriorityUlJob::SetUlJob (Ptr<UlJob> job)
{
m_job = job;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ul-job.cc | C++ | gpl2 | 2,677 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef UPLINK_SCHEDULER_SIMPLE_H
#define UPLINK_SCHEDULER_SIMPLE_H
#include <stdint.h>
#include "ul-mac-messages.h"
#include "ns3/nstime.h"
#include "wimax-phy.h"
#include "bs-uplink-scheduler.h"
#include "service-flow.h"
namespace ns3 {
class BaseStationNetDevice;
class SSRecord;
class ServiceFlow;
/**
* \ingroup wimax
*/
class UplinkSchedulerSimple : public UplinkScheduler
{
public:
UplinkSchedulerSimple (void);
UplinkSchedulerSimple (Ptr<BaseStationNetDevice> bs);
~UplinkSchedulerSimple (void);
static TypeId GetTypeId (void);
std::list<OfdmUlMapIe> GetUplinkAllocations (void) const;
/**
* \brief Determines if channel descriptors sent in the current frame are
* required to be updated
*/
void GetChannelDescriptorsToUpdate (bool&, bool&, bool&, bool&);
uint32_t CalculateAllocationStartTime (void);
void AddUplinkAllocation (OfdmUlMapIe &ulMapIe,
const uint32_t &allocationSize,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
void Schedule (void);
void ServiceUnsolicitedGrants (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
void ServiceBandwidthRequests (const SSRecord *ssRecord,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
bool ServiceBandwidthRequests (ServiceFlow *serviceFlow,
enum ServiceFlow::SchedulingType schedulingType,
OfdmUlMapIe &ulMapIe,
const WimaxPhy::ModulationType modulationType,
uint32_t &symbolsToAllocation,
uint32_t &availableSymbols);
void AllocateInitialRangingInterval (uint32_t &symbolsToAllocation, uint32_t &availableSymbols);
void SetupServiceFlow (SSRecord *ssRecord, ServiceFlow *serviceFlow);
void ProcessBandwidthRequest (const BandwidthRequestHeader &bwRequestHdr);
void InitOnce (void);
void OnSetRequestedBandwidth (ServiceFlowRecord *sfr);
private:
std::list<OfdmUlMapIe> m_uplinkAllocations;
};
} // namespace ns3
#endif /* UPLINK_SCHEDULER_SIMPLE_H */
| zy901002-gpsr | src/wimax/model/bs-uplink-scheduler-simple.h | C++ | gpl2 | 3,574 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "ns3/simulator.h"
#include "ns3/drop-tail-queue.h"
#include "ns3/node.h"
#include "bs-uplink-scheduler.h"
#include "bs-net-device.h"
#include "wimax-phy.h"
#include "ns3/packet-burst.h"
#include "ss-record.h"
#include "bs-scheduler.h"
#include "wimax-mac-queue.h"
#include "burst-profile-manager.h"
#include "ss-manager.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "ns3/uinteger.h"
#include "service-flow.h"
#include "service-flow-manager.h"
#include "connection-manager.h"
#include "bs-link-manager.h"
#include "bandwidth-manager.h"
#include "ns3/ipv4-address.h"
#include "ns3/llc-snap-header.h"
NS_LOG_COMPONENT_DEFINE ("BaseStationNetDevice");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BaseStationNetDevice);
TypeId BaseStationNetDevice::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BaseStationNetDevice")
.SetParent<WimaxNetDevice> ()
.AddConstructor<BaseStationNetDevice> ()
.AddAttribute ("BSScheduler",
"Downlink Scheduler for BS",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::m_scheduler),
MakePointerChecker<BSScheduler> ())
.AddAttribute ("InitialRangInterval",
"Time between Initial Ranging regions assigned by the BS. Maximum is 2s",
TimeValue (Seconds (0.05)),
MakeTimeAccessor (&BaseStationNetDevice::GetInitialRangingInterval,
&BaseStationNetDevice::SetInitialRangingInterval),
MakeTimeChecker ())
.AddAttribute ("DcdInterval",
"Time between transmission of DCD messages. Maximum value is 10s.",
TimeValue (Seconds (3)),
MakeTimeAccessor (&BaseStationNetDevice::GetDcdInterval, &BaseStationNetDevice::SetDcdInterval),
MakeTimeChecker ())
.AddAttribute ("UcdInterval",
"Time between transmission of UCD messages. Maximum value is 10s.",
TimeValue (Seconds (3)),
MakeTimeAccessor (&BaseStationNetDevice::GetUcdInterval, &BaseStationNetDevice::SetUcdInterval),
MakeTimeChecker ())
.AddAttribute ("IntervalT8",
"Wait for DSA/DSC Acknowledge timeout. Maximum 300ms.",
TimeValue (Seconds (0.05)),
MakeTimeAccessor (&BaseStationNetDevice::GetIntervalT8, &BaseStationNetDevice::SetIntervalT8),
MakeTimeChecker ())
.AddAttribute ("RangReqOppSize",
"The ranging opportunity size in symbols",
UintegerValue (8),
MakeUintegerAccessor (&BaseStationNetDevice::GetRangReqOppSize,
&BaseStationNetDevice::SetRangReqOppSize),
MakeUintegerChecker<uint8_t> (1, 256))
.AddAttribute ("BwReqOppSize",
"The bandwidth request opportunity size in symbols",
UintegerValue (2),
MakeUintegerAccessor (&BaseStationNetDevice::GetBwReqOppSize, &BaseStationNetDevice::SetBwReqOppSize),
MakeUintegerChecker<uint8_t> (1, 256))
.AddAttribute ("MaxRangCorrectionRetries",
"Number of retries on contention Ranging Requests",
UintegerValue (16),
MakeUintegerAccessor (&BaseStationNetDevice::GetMaxRangingCorrectionRetries,
&BaseStationNetDevice::SetMaxRangingCorrectionRetries),
MakeUintegerChecker<uint8_t> (1, 16))
.AddAttribute ("SSManager",
"The ss manager attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetSSManager, &BaseStationNetDevice::SetSSManager),
MakePointerChecker<SSManager> ())
.AddAttribute ("Scheduler",
"The BS scheduler attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetBSScheduler, &BaseStationNetDevice::SetBSScheduler),
MakePointerChecker<BSScheduler> ())
.AddAttribute ("LinkManager",
"The link manager attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetLinkManager, &BaseStationNetDevice::SetLinkManager),
MakePointerChecker<BSLinkManager> ())
.AddAttribute ("UplinkScheduler",
"The uplink scheduler attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetUplinkScheduler,
&BaseStationNetDevice::SetUplinkScheduler),
MakePointerChecker<UplinkScheduler> ())
.AddAttribute ("BsIpcsPacketClassifier",
"The uplink IP packet classifier attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetBsClassifier, &BaseStationNetDevice::SetBsClassifier),
MakePointerChecker<IpcsClassifier> ())
.AddAttribute ("ServiceFlowManager",
"The service flow manager attached to this device.",
PointerValue (),
MakePointerAccessor (&BaseStationNetDevice::GetServiceFlowManager,
&BaseStationNetDevice::SetServiceFlowManager),
MakePointerChecker<ServiceFlowManager> ())
.AddTraceSource ("BSTx", "A packet has been received from higher layers and is being processed in preparation for "
"queueing for transmission.", MakeTraceSourceAccessor (&BaseStationNetDevice::m_bsTxTrace))
.AddTraceSource ("BSTxDrop",
"A packet has been dropped in the MAC layer before being queued for transmission.",
MakeTraceSourceAccessor (&BaseStationNetDevice::m_bsTxDropTrace))
.AddTraceSource ("BSPromiscRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a promiscuous trace,",
MakeTraceSourceAccessor (&BaseStationNetDevice::m_bsPromiscRxTrace))
.AddTraceSource ("BSRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a non-promiscuous trace,",
MakeTraceSourceAccessor (&BaseStationNetDevice::m_bsRxTrace))
.AddTraceSource ("BSRxDrop",
"A packet has been dropped in the MAC layer after it has been passed up from the physical "
"layer.",
MakeTraceSourceAccessor (&BaseStationNetDevice::m_bsRxDropTrace));
return tid;
}
BaseStationNetDevice::BaseStationNetDevice (void)
{
InitBaseStationNetDevice ();
}
void
BaseStationNetDevice::InitBaseStationNetDevice ()
{
m_initialRangInterval = Seconds (0.05); // maximum is 2
m_dcdInterval = Seconds (3); // maximum is 10
m_ucdInterval = Seconds (3); // maximum is 10
m_intervalT8 = MilliSeconds (50); // maximum is 300 milliseconds
m_maxRangCorrectionRetries = 16;
m_maxInvitedRangRetries = 16;
m_rangReqOppSize = 8; // 8 symbols = 2 (preamble) + 2 (RNG-REQ) + 4 (round-trip propagation time)
m_bwReqOppSize = 2; // 2 symbols = 1 (preamble) + 1 (bandwidth request header)
m_nrDlSymbols = 0;
m_nrUlSymbols = 0;
m_nrDlMapSent = 0;
m_nrUlMapSent = 0;
m_nrDcdSent = 0;
m_nrUcdSent = 0;
m_dcdConfigChangeCount = 0;
m_ucdConfigChangeCount = 0;
m_framesSinceLastDcd = 0;
m_framesSinceLastUcd = 0;
m_nrDlFrames = 0;
m_nrUlFrames = 0;
m_nrSsRegistered = 0;
m_nrDlAllocations = 0;
m_nrUlAllocations = 0;
m_dlSubframeStartTime = Seconds (0);
m_ulSubframeStartTime = Seconds (0);
m_ulAllocationNumber = 0;
m_rangingOppNumber = 0;
m_allocationStartTime = 0;
m_psDuration = Seconds (0);
m_symbolDuration = Seconds (0);
m_linkManager = CreateObject<BSLinkManager> (this);
m_cidFactory = new CidFactory ();
m_ssManager = CreateObject<SSManager> ();
m_bsClassifier = CreateObject<IpcsClassifier> ();
m_serviceFlowManager = CreateObject<BsServiceFlowManager> (this);
}
BaseStationNetDevice::BaseStationNetDevice (Ptr<Node> node, Ptr<WimaxPhy> phy)
{
InitBaseStationNetDevice ();
this->SetNode (node);
this->SetPhy (phy);
}
BaseStationNetDevice::BaseStationNetDevice (Ptr<Node> node,
Ptr<WimaxPhy> phy,
Ptr<UplinkScheduler> uplinkScheduler,
Ptr<BSScheduler> bsScheduler)
{
InitBaseStationNetDevice ();
this->SetNode (node);
this->SetPhy (phy);
m_uplinkScheduler = uplinkScheduler;
m_scheduler = bsScheduler;
}
BaseStationNetDevice::~BaseStationNetDevice (void)
{
}
void
BaseStationNetDevice::DoDispose (void)
{
delete m_cidFactory;
m_linkManager = 0;
m_ssManager = 0;
m_bsClassifier = 0;
m_serviceFlowManager = 0;
m_uplinkScheduler = 0;
m_cidFactory = 0;
m_ssManager = 0;
m_uplinkScheduler = 0;
m_scheduler = 0;
WimaxNetDevice::DoDispose ();
}
void
BaseStationNetDevice::SetBsClassifier (Ptr<IpcsClassifier> bsc)
{
m_bsClassifier = bsc;
}
Ptr<IpcsClassifier>
BaseStationNetDevice::GetBsClassifier (void) const
{
return m_bsClassifier;
}
void
BaseStationNetDevice::SetInitialRangingInterval (Time initialRangInterval)
{
m_initialRangInterval = initialRangInterval;
}
Time
BaseStationNetDevice::GetInitialRangingInterval (void) const
{
return m_initialRangInterval;
}
void
BaseStationNetDevice::SetDcdInterval (Time dcdInterval)
{
m_dcdInterval = dcdInterval;
}
Time
BaseStationNetDevice::GetDcdInterval (void) const
{
return m_dcdInterval;
}
void
BaseStationNetDevice::SetUcdInterval (Time ucdInterval)
{
m_ucdInterval = ucdInterval;
}
Time
BaseStationNetDevice::GetUcdInterval (void) const
{
return m_ucdInterval;
}
void
BaseStationNetDevice::SetIntervalT8 (Time interval)
{
m_intervalT8 = interval;
}
Time
BaseStationNetDevice::GetIntervalT8 (void) const
{
return m_intervalT8;
}
void
BaseStationNetDevice::SetMaxRangingCorrectionRetries (uint8_t maxRangCorrectionRetries)
{
m_maxRangCorrectionRetries = maxRangCorrectionRetries;
}
uint8_t
BaseStationNetDevice::GetMaxRangingCorrectionRetries (void) const
{
return m_maxRangCorrectionRetries;
}
void
BaseStationNetDevice::SetMaxInvitedRangRetries (uint8_t maxInvitedRangRetries)
{
m_maxInvitedRangRetries = maxInvitedRangRetries;
}
uint8_t
BaseStationNetDevice::GetMaxInvitedRangRetries (void) const
{
return m_maxInvitedRangRetries;
}
void
BaseStationNetDevice::SetRangReqOppSize (uint8_t rangReqOppSize)
{
m_rangReqOppSize = rangReqOppSize;
}
uint8_t
BaseStationNetDevice::GetRangReqOppSize (void) const
{
return m_rangReqOppSize;
}
void
BaseStationNetDevice::SetBwReqOppSize (uint8_t bwReqOppSize)
{
m_bwReqOppSize = bwReqOppSize;
}
uint8_t
BaseStationNetDevice::GetBwReqOppSize (void) const
{
return m_bwReqOppSize;
}
void
BaseStationNetDevice::SetNrDlSymbols (uint32_t nrDlSymbols)
{
m_nrDlSymbols = nrDlSymbols;
}
uint32_t
BaseStationNetDevice::GetNrDlSymbols (void) const
{
return m_nrDlSymbols;
}
void
BaseStationNetDevice::SetNrUlSymbols (uint32_t nrUlSymbols)
{
m_nrUlSymbols = nrUlSymbols;
}
uint32_t
BaseStationNetDevice::GetNrUlSymbols (void) const
{
return m_nrUlSymbols;
}
uint32_t
BaseStationNetDevice::GetNrDcdSent (void) const
{
return m_nrDcdSent;
}
uint32_t
BaseStationNetDevice::GetNrUcdSent (void) const
{
return m_nrUcdSent;
}
Time
BaseStationNetDevice::GetDlSubframeStartTime (void) const
{
return m_dlSubframeStartTime;
}
Time
BaseStationNetDevice::GetUlSubframeStartTime (void) const
{
return m_ulSubframeStartTime;
}
uint8_t
BaseStationNetDevice::GetRangingOppNumber (void) const
{
return m_rangingOppNumber;
}
Ptr<SSManager>
BaseStationNetDevice::GetSSManager (void) const
{
return m_ssManager;
}
void
BaseStationNetDevice::SetSSManager (Ptr<SSManager> ssm)
{
m_ssManager = ssm;
}
Ptr<BsServiceFlowManager>
BaseStationNetDevice::GetServiceFlowManager (void) const
{
return m_serviceFlowManager;
}
void
BaseStationNetDevice::SetServiceFlowManager (Ptr<BsServiceFlowManager> sfm)
{
m_serviceFlowManager = sfm;
}
Ptr<UplinkScheduler>
BaseStationNetDevice::GetUplinkScheduler (void) const
{
return m_uplinkScheduler;
}
void
BaseStationNetDevice::SetUplinkScheduler (Ptr<UplinkScheduler> uls)
{
m_uplinkScheduler = uls;
}
Ptr<BSLinkManager>
BaseStationNetDevice::GetLinkManager (void) const
{
return m_linkManager;
}
void
BaseStationNetDevice::SetLinkManager (Ptr<BSLinkManager> lm)
{
m_linkManager = lm;
}
void
BaseStationNetDevice::SetBSScheduler (Ptr<BSScheduler> bss)
{
m_scheduler = bss;
}
Ptr<BSScheduler>
BaseStationNetDevice::GetBSScheduler (void) const
{
return m_scheduler;
}
Time
BaseStationNetDevice::GetPsDuration (void) const
{
return m_psDuration;
}
Time
BaseStationNetDevice::GetSymbolDuration (void) const
{
return m_symbolDuration;
}
void
BaseStationNetDevice::Start (void)
{
SetReceiveCallback ();
GetConnectionManager ()->SetCidFactory (m_cidFactory);
GetPhy ()->SetPhyParameters ();
GetPhy ()->SetDataRates ();
SetTtg (GetPhy ()->GetTtg ());
SetRtg (GetPhy ()->GetRtg ());
m_psDuration = GetPhy ()->GetPsDuration ();
m_symbolDuration = GetPhy ()->GetSymbolDuration ();
GetBandwidthManager ()->SetSubframeRatio ();
CreateDefaultConnections ();
GetPhy ()->SetSimplex (m_linkManager->SelectDlChannel ());
Simulator::ScheduleNow (&BaseStationNetDevice::StartFrame, this);
/* shall actually be 2 symbols = 1 (preamble) + 1 (bandwidth request header)*/
m_bwReqOppSize = 6;
m_uplinkScheduler->InitOnce ();
}
void
BaseStationNetDevice::Stop (void)
{
}
void
BaseStationNetDevice::StartFrame (void)
{
//setting DL/UL subframe allocation for this frame
uint32_t symbolsPerFrame = GetPhy ()->GetSymbolsPerFrame ();
SetNrDlSymbols ((symbolsPerFrame / 2) - static_cast<uint32_t> (ceil (GetTtg ()*m_psDuration.GetSeconds ()/m_symbolDuration.GetSeconds ())));
SetNrUlSymbols ((symbolsPerFrame / 2) - static_cast<uint32_t> (ceil (GetRtg ()*m_psDuration.GetSeconds ()/m_symbolDuration.GetSeconds ())));
m_frameStartTime = Simulator::Now ();
NS_LOG_INFO ("----------------------frame" << GetNrFrames () + 1 << "----------------------");
StartDlSubFrame ();
}
void
BaseStationNetDevice::StartDlSubFrame (void)
{
m_dlSubframeStartTime = Simulator::Now (); // same as m_frameStartTime
NS_LOG_DEBUG ("DL frame started : " << m_frameStartTime.GetSeconds ());
SetNrFrames (GetNrFrames () + 1);
SetState (BS_STATE_DL_SUB_FRAME);
m_direction = DIRECTION_DOWNLINK;
m_uplinkScheduler->Schedule ();
CreateMapMessages ();
m_scheduler->Schedule ();
SendBursts ();
Simulator::Schedule (Seconds (m_nrDlSymbols * m_symbolDuration.GetSeconds ()),
&BaseStationNetDevice::EndDlSubFrame,
this);
}
void
BaseStationNetDevice::EndDlSubFrame (void)
{
m_nrDlFrames++;
SetState (BS_STATE_TTG);
Simulator::Schedule (Seconds (GetTtg () * m_psDuration.GetSeconds ()), &BaseStationNetDevice::StartUlSubFrame, this);
}
void
BaseStationNetDevice::StartUlSubFrame (void)
{
m_ulSubframeStartTime = Simulator::Now ();
NS_LOG_INFO ("UL frame started : " << m_ulSubframeStartTime.GetSeconds ());
SetState (BS_STATE_UL_SUB_FRAME);
m_direction = DIRECTION_UPLINK;
MarkUplinkAllocations ();
Simulator::Schedule (Seconds (m_nrUlSymbols * m_symbolDuration.GetSeconds ()),
&BaseStationNetDevice::EndUlSubFrame,
this);
}
void
BaseStationNetDevice::EndUlSubFrame (void)
{
m_nrUlFrames++;
SetState (BS_STATE_RTG);
Simulator::Schedule (Seconds (GetRtg () * m_psDuration.GetSeconds ()), &BaseStationNetDevice::EndFrame, this);
}
void
BaseStationNetDevice::EndFrame (void)
{
StartFrame ();
}
bool
BaseStationNetDevice::DoSend (Ptr<Packet> packet,
const Mac48Address &source,
const Mac48Address &dest,
uint16_t protocolNumber)
{
Ptr<PacketBurst> burst = Create<PacketBurst> ();
ServiceFlow *serviceFlow = 0;
NS_LOG_INFO ("BS (" << source << "):");
NS_LOG_INFO ("\tSending packet...");
NS_LOG_INFO ("\t\tDestination: " << dest);
NS_LOG_INFO ("\t\tPaket Size: " << packet->GetSize ());
NS_LOG_INFO ("\t\tProtocol: " << protocolNumber);
if (protocolNumber == 2048)
{
serviceFlow = m_bsClassifier->Classify (packet, GetServiceFlowManager (), ServiceFlow::SF_DIRECTION_DOWN);
}
if (protocolNumber != 2048 || serviceFlow == 0)
{
serviceFlow = *GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).begin ();
}
if (serviceFlow == 0)
{
NS_LOG_INFO ("No Service Flow!!");
m_bsTxDropTrace (packet);
return false;
}
if (serviceFlow->GetIsEnabled ())
{
if (!Enqueue (packet, MacHeaderType (), serviceFlow->GetConnection ()))
{
NS_LOG_INFO ("Enqueue Error!!");
m_bsTxDropTrace (packet);
return false;
}
}
else
{
m_bsTxDropTrace (packet);
NS_LOG_INFO ("Service Flow is not enabled");
return false;
}
m_bsTxTrace (packet);
return true;
}
bool
BaseStationNetDevice::Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType, Ptr<WimaxConnection> connection)
{
NS_ASSERT_MSG (connection != 0,
"BS: Can not enqueue packet on the selected connection: the connection is not initialized");
GenericMacHeader hdr;
hdr.SetLen (packet->GetSize () + hdr.GetSerializedSize ());
hdr.SetCid (connection->GetCid ());
return connection->Enqueue (packet, hdrType, hdr);
}
void
BaseStationNetDevice::DoReceive (Ptr<Packet> packet)
{
GenericMacHeader gnrcMacHdr;
BandwidthRequestHeader bwRequestHdr;
ManagementMessageType msgType;
RngReq rngReq;
Cid cid;
uint8_t type = 0;
GrantManagementSubheader grantMgmntSubhdr;
Mac48Address source;
LlcSnapHeader llc;
Ptr<WimaxConnection> connection = 0;
FragmentationSubheader fragSubhdr;
bool fragmentation = false; // it becames true when there is a fragmentation subheader
packet->RemoveHeader (gnrcMacHdr);
if (gnrcMacHdr.GetHt () == MacHeaderType::HEADER_TYPE_GENERIC)
{
if (gnrcMacHdr.check_hcs () == false)
{
// The header is noisy
m_bsRxDropTrace (packet);
NS_LOG_INFO ("Header HCS ERROR");
return;
}
cid = gnrcMacHdr.GetCid ();
// checking for subheaders (only grant management subheader is implemented)
type = gnrcMacHdr.GetType ();
if (type)
{
// checking 1st bit, see Table 6
if (type & 1)
{
packet->RemoveHeader (grantMgmntSubhdr);
}
// Check if there is a fragmentation Subheader
uint8_t tmpType = type;
if (((tmpType >> 2) & 1) == 1)
{
// a TRANSPORT packet with fragmentation subheader has been received!
NS_LOG_INFO ("FRAG_DEBUG: DoReceive -> the packet is a fragment" << std::endl);
fragmentation = true;
}
}
if (cid.IsInitialRanging ()) // initial ranging connection
{
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_RNG_REQ:
{
packet->RemoveHeader (rngReq);
m_linkManager->ProcessRangingRequest (cid, rngReq);
break;
}
case ManagementMessageType::MESSAGE_TYPE_RNG_RSP:
// from other base station, ignore
break;
default:
NS_FATAL_ERROR ("Invalid message type");
}
}
else if (m_cidFactory->IsBasic (cid)) // basic management connection
{
source = m_ssManager->GetMacAddress (cid);
m_traceBSRx (packet, source, cid);
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_RNG_REQ:
{
packet->RemoveHeader (rngReq);
m_linkManager->ProcessRangingRequest (cid, rngReq);
break;
}
case ManagementMessageType::MESSAGE_TYPE_RNG_RSP:
// from other base station, ignore
break;
default:
NS_FATAL_ERROR ("Invalid message type");
}
}
else if (m_cidFactory->IsPrimary (cid)) // primary management connection
{
source = m_ssManager->GetMacAddress (cid);
m_traceBSRx (packet, source, cid);
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_REG_REQ:
// not yet implemented
break;
case ManagementMessageType::MESSAGE_TYPE_REG_RSP:
// from other base station, ignore
break;
case ManagementMessageType::MESSAGE_TYPE_DSA_REQ:
{
DsaReq dsaReq;
packet->RemoveHeader (dsaReq);
GetServiceFlowManager ()->AllocateServiceFlows (dsaReq, cid);
break;
}
case ManagementMessageType::MESSAGE_TYPE_DSA_RSP:
/*from other base station, as DSA initiated
from BS is not supported, ignore*/
break;
case ManagementMessageType::MESSAGE_TYPE_DSA_ACK:
{
Simulator::Cancel (GetServiceFlowManager ()->GetDsaAckTimeoutEvent ());
DsaAck dsaAck;
packet->RemoveHeader (dsaAck);
GetServiceFlowManager ()->ProcessDsaAck (dsaAck, cid);
break;
}
default:
NS_FATAL_ERROR ("Invalid message type");
}
}
else if (cid.IsBroadcast ()) // broadcast connection
{
// from other base station, ignore
// or perhaps data packet (using other protocol) for BS, handle later
return;
}
else // transport connection
{
// If fragmentation is true, the packet is a fragment.
Ptr<Packet> C_Packet = packet->Copy ();
if (!fragmentation)
{
C_Packet->RemoveHeader (llc);
source = m_ssManager->GetMacAddress (cid);
m_bsRxTrace (packet);
ForwardUp (packet->Copy (), source, Mac48Address ("ff:ff:ff:ff:ff:ff"));
}
else
{
NS_LOG_INFO ( "FRAG_DEBUG: BS DoReceive, the Packet is a fragment" << std::endl);
packet->RemoveHeader (fragSubhdr);
uint32_t fc = fragSubhdr.GetFc ();
NS_LOG_INFO ("\t fragment size = " << packet->GetSize () << std::endl);
if (fc == 2)
{
// This is the latest fragment.
// Take the fragment queue, defragment a packet and send it to the upper layer
NS_LOG_INFO ("\t Received the latest fragment" << std::endl);
GetConnectionManager ()->GetConnection (cid)
->FragmentEnqueue (packet);
WimaxConnection::FragmentsQueue fragmentsQueue = GetConnectionManager ()->
GetConnection (cid)->GetFragmentsQueue ();
Ptr<Packet> fullPacket = Create<Packet> ();
// DEFRAGMENTATION
NS_LOG_INFO ("\t BS PACKET DEFRAGMENTATION" << std::endl);
for (std::list<Ptr<const Packet> >::const_iterator iter = fragmentsQueue.begin ();
iter != fragmentsQueue.end (); ++iter)
{
// Create the whole Packet
fullPacket->AddAtEnd (*iter);
}
GetConnectionManager ()->GetConnection (cid)
->ClearFragmentsQueue ();
NS_LOG_INFO ("\t fullPacket size = " << fullPacket->GetSize () << std::endl);
source = m_ssManager->GetMacAddress (cid);
m_bsRxTrace (fullPacket);
ForwardUp (fullPacket->Copy (), source, Mac48Address ("ff:ff:ff:ff:ff:ff"));
}
else
{
// This is the first or middle fragment.
// Take the fragment queue, store the fragment into the queue
NS_LOG_INFO ("\t Received the first or the middle fragment" << std::endl);
GetConnectionManager ()->GetConnection (cid)
->FragmentEnqueue (packet);
}
}
}
}
else
{
// bandwidth request header
packet->AddHeader (gnrcMacHdr);
packet->RemoveHeader (bwRequestHdr);
NS_ASSERT_MSG (bwRequestHdr.GetHt () == MacHeaderType::HEADER_TYPE_BANDWIDTH,
"A bandwidth request should be carried by a bandwidth header type");
if (bwRequestHdr.check_hcs () == false)
{
// The header is noisy
NS_LOG_INFO ("BS:Header HCS ERROR");
return;
}
cid = bwRequestHdr.GetCid ();
source = m_ssManager->GetMacAddress (cid);
m_traceBSRx (packet, source, cid);
GetBandwidthManager ()->ProcessBandwidthRequest (bwRequestHdr);
}
}
void
BaseStationNetDevice::CreateMapMessages (void)
{
Ptr<Packet> dlmap, ulmap;
bool sendDcd = false, sendUcd = false, updateDcd = false, updateUcd = false;
uint16_t currentNrSsRegistered = m_ssManager->GetNRegisteredSSs ();
if (m_nrSsRegistered == currentNrSsRegistered)
{
m_uplinkScheduler->GetChannelDescriptorsToUpdate (updateDcd, updateUcd, sendDcd, sendUcd);
}
else
{
sendDcd = sendUcd = true;
}
m_nrSsRegistered = currentNrSsRegistered;
/*either DCD and UCD must be created first because CCC is set during their
creation, or CCC must be calculated first so that it could be set during
creation of DL-MAP and UL-MAP and then set duirng creation of DCD and UCD*/
if (sendDcd)
{
m_dcdConfigChangeCount += 1 % 256;
}
if (sendUcd)
{
m_ucdConfigChangeCount += 1 % 256;
}
dlmap = CreateDlMap ();
Enqueue (dlmap, MacHeaderType (), GetBroadcastConnection ());
m_nrDlMapSent++;
ulmap = CreateUlMap ();
Enqueue (ulmap, MacHeaderType (), GetBroadcastConnection ());
m_nrUlMapSent++;
CreateDescriptorMessages (sendDcd, sendUcd);
}
void
BaseStationNetDevice::CreateDescriptorMessages (bool sendDcd, bool sendUcd)
{
Ptr<Packet> dcd, ucd;
if (sendDcd)
{
dcd = CreateDcd ();
Enqueue (dcd, MacHeaderType (), GetBroadcastConnection ());
m_nrDcdSent++;
m_framesSinceLastDcd = 0;
}
else
{
m_framesSinceLastDcd++;
}
if (sendUcd)
{
ucd = CreateUcd ();
Enqueue (ucd, MacHeaderType (), GetBroadcastConnection ());
m_nrUcdSent++;
m_framesSinceLastUcd = 0;
}
else
{
m_framesSinceLastUcd++;
}
}
/*
Sends bursts in the downlink subframe. i.e., creates the downlink subframe. The first burst
is broadcast burst with MAC management messages. The rest of the bursts contain data packets.
*/
void
BaseStationNetDevice::SendBursts (void)
{
Time txTime = Seconds (0);
std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > pair;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *downlinkBursts = m_scheduler->GetDownlinkBursts ();
Ptr<PacketBurst> burst;
OfdmDlMapIe *dlMapIe;
Cid cid;
while (downlinkBursts->size ())
{
pair = downlinkBursts->front ();
burst = pair.second;
dlMapIe = pair.first;
cid = dlMapIe->GetCid ();
uint8_t diuc = dlMapIe->GetDiuc ();
if (cid != GetInitialRangingConnection ()->GetCid () && cid != GetBroadcastConnection ()->GetCid ())
{
if (m_serviceFlowManager->GetServiceFlow (cid) != 0)
{
modulationType = GetBurstProfileManager ()->GetModulationType (diuc, WimaxNetDevice::DIRECTION_DOWNLINK);
}
else
{
modulationType = GetBurstProfileManager ()->GetModulationType (diuc, WimaxNetDevice::DIRECTION_DOWNLINK);
}
}
else
{
modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
}
Simulator::Schedule (txTime, &WimaxNetDevice::ForwardDown, this, burst, modulationType);
txTime += GetPhy ()->GetTransmissionTime (burst->GetSize (), modulationType);
downlinkBursts->pop_front ();
delete dlMapIe;
}
}
Ptr<Packet>
BaseStationNetDevice::CreateDlMap (void)
{
m_nrDlAllocations = 0;
DlMap dlmap;
dlmap.SetDcdCount (m_dcdConfigChangeCount);
dlmap.SetBaseStationId (GetMacAddress ());
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *downlinkBursts = m_scheduler->GetDownlinkBursts ();
for (std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > >::iterator iter = downlinkBursts->begin (); iter
!= downlinkBursts->end (); ++iter)
{
iter->first->SetPreamblePresent (0);
iter->first->SetStartTime (0);
dlmap.AddDlMapElement (*(iter->first));
}
OfdmDlMapIe dlMapIeEnd;
dlMapIeEnd.SetCid (Cid::InitialRanging ());
dlMapIeEnd.SetDiuc (OfdmDlBurstProfile::DIUC_END_OF_MAP);
dlMapIeEnd.SetPreamblePresent (0);
dlMapIeEnd.SetStartTime (0);
dlmap.AddDlMapElement (dlMapIeEnd);
m_nrDlAllocations = downlinkBursts->size ();
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (dlmap);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_DL_MAP));
return p;
}
Ptr<Packet>
BaseStationNetDevice::CreateDcd (void)
{
Dcd dcd;
OfdmDcdChannelEncodings chnlEncodings;
chnlEncodings.SetBsEirp (0);
chnlEncodings.SetEirxPIrMax (0);
chnlEncodings.SetFrequency (GetPhy ()->GetFrequency ());
chnlEncodings.SetChannelNr (0);
chnlEncodings.SetTtg (GetTtg ());
chnlEncodings.SetRtg (GetRtg ());
chnlEncodings.SetBaseStationId (GetMacAddress ());
chnlEncodings.SetFrameDurationCode (GetPhy ()->GetFrameDurationCode ());
chnlEncodings.SetFrameNumber (GetNrFrames ());
dcd.SetConfigurationChangeCount (m_dcdConfigChangeCount);
dcd.SetChannelEncodings (chnlEncodings);
SetDlBurstProfiles (&dcd);
SetCurrentDcd (dcd);
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (dcd);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_DCD));
return p;
}
Ptr<Packet>
BaseStationNetDevice::CreateUlMap (void)
{
m_ulAllocationNumber = 0;
m_rangingOppNumber = 0;
m_nrUlAllocations = 0;
UlMap ulmap;
ulmap.SetUcdCount (m_ucdConfigChangeCount);
ulmap.SetAllocationStartTime (m_uplinkScheduler->CalculateAllocationStartTime ());
std::list<OfdmUlMapIe> uplinkAllocations = m_uplinkScheduler->GetUplinkAllocations ();
for (std::list<OfdmUlMapIe>::iterator iter = uplinkAllocations.begin (); iter != uplinkAllocations.end (); ++iter)
{
ulmap.AddUlMapElement (*iter);
}
m_nrUlAllocations = uplinkAllocations.size ();
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (ulmap);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_UL_MAP));
return p;
}
Ptr<Packet>
BaseStationNetDevice::CreateUcd (void)
{
Ucd ucd;
ucd.SetConfigurationChangeCount (m_ucdConfigChangeCount);
ucd.SetRangingBackoffStart (3); // setting to 7. i.e., 2^3 = 8 -> 0-7
ucd.SetRangingBackoffEnd (6); // setting to 63. i.e., 2^6 = 64 -> 0-63
ucd.SetRequestBackoffStart (3);
ucd.SetRequestBackoffEnd (6);
OfdmUcdChannelEncodings chnlEncodings;
chnlEncodings.SetBwReqOppSize (m_bwReqOppSize * GetPhy ()->GetPsPerSymbol ());
chnlEncodings.SetRangReqOppSize (m_rangReqOppSize * GetPhy ()->GetPsPerSymbol ());
chnlEncodings.SetFrequency (GetPhy ()->GetFrequency ());
chnlEncodings.SetSbchnlReqRegionFullParams (0);
chnlEncodings.SetSbchnlFocContCodes (0);
ucd.SetChannelEncodings (chnlEncodings);
SetUlBurstProfiles (&ucd);
SetCurrentUcd (ucd);
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (ucd);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_UCD));
return p;
}
void
BaseStationNetDevice::SetDlBurstProfiles (Dcd *dcd)
{
for (int i = 0; i < GetBurstProfileManager ()->GetNrBurstProfilesToDefine (); ++i)
{
OfdmDlBurstProfile brstProfile;
brstProfile.SetType (0);
brstProfile.SetLength (0);
brstProfile.SetDiuc (i + 1); // DIUC will be between 1-11, see Table 237
brstProfile.SetFecCodeType (i);
dcd->AddDlBurstProfile (brstProfile);
}
}
void
BaseStationNetDevice::SetUlBurstProfiles (Ucd *ucd)
{
for (int i = 0; i < GetBurstProfileManager ()->GetNrBurstProfilesToDefine (); ++i)
{
OfdmUlBurstProfile brstProfile;
brstProfile.SetType (0);
brstProfile.SetLength (0);
// UIUC will be between 5-12, see Table 246. UIUC 1 (initial ranging) is not included
brstProfile.SetUiuc (i + 5);
brstProfile.SetFecCodeType (i);
ucd->AddUlBurstProfile (brstProfile);
}
}
Ptr<WimaxConnection>
BaseStationNetDevice::GetConnection (Cid cid)
{
Ptr<WimaxConnection> connection = 0;
if (cid.IsInitialRanging ())
{
return GetInitialRangingConnection ();
}
else if (cid.IsBroadcast ())
{
connection = GetBroadcastConnection ();
}
else
{
connection = GetConnectionManager ()->GetConnection (cid);
}
NS_ASSERT_MSG (connection != 0, "BS: Invalid connection=0");
return connection;
}
void
BaseStationNetDevice::MarkUplinkAllocations (void)
{
uint16_t symbolsToAllocation = 0;
std::list<OfdmUlMapIe> uplinkAllocations = m_uplinkScheduler->GetUplinkAllocations ();
for (std::list<OfdmUlMapIe>::iterator iter = uplinkAllocations.begin (); iter != uplinkAllocations.end (); ++iter)
{
OfdmUlMapIe uplinkAllocation = *iter;
if (uplinkAllocation.GetUiuc () == OfdmUlBurstProfile::UIUC_END_OF_MAP)
{
break;
}
symbolsToAllocation = uplinkAllocation.GetStartTime ();
MarkUplinkAllocationStart (Seconds (symbolsToAllocation * m_symbolDuration.GetSeconds ()));
MarkUplinkAllocationEnd (Seconds ((symbolsToAllocation + uplinkAllocation.GetDuration ())
* m_symbolDuration.GetSeconds ()), uplinkAllocation.GetCid (), uplinkAllocation.GetUiuc ());
}
}
void
BaseStationNetDevice::MarkUplinkAllocationStart (Time allocationStartTime)
{
Simulator::Schedule (allocationStartTime, &BaseStationNetDevice::UplinkAllocationStart, this);
}
void
BaseStationNetDevice::MarkUplinkAllocationEnd (Time allocationEndTime, Cid cid, uint8_t uiuc)
{
Simulator::Schedule (allocationEndTime, &BaseStationNetDevice::UplinkAllocationEnd, this, cid, uiuc);
}
void
BaseStationNetDevice::UplinkAllocationStart (void)
{
m_ulAllocationNumber++;
NS_LOG_DEBUG ("--UL allocation " << (uint32_t) m_ulAllocationNumber << " started : "
<< Simulator::Now ().GetSeconds ());
}
void
BaseStationNetDevice::UplinkAllocationEnd (Cid cid, uint8_t uiuc)
{
NS_LOG_DEBUG ("--UL allocation " << (uint32_t) m_ulAllocationNumber << " ended : " << Simulator::Now ().GetSeconds ());
if (m_cidFactory->IsBasic (cid))
{
m_linkManager->VerifyInvitedRanging (cid, uiuc);
}
}
void
BaseStationNetDevice::MarkRangingOppStart (Time rangingOppStartTime)
{
Simulator::Schedule (rangingOppStartTime, &BaseStationNetDevice::RangingOppStart, this);
}
void
BaseStationNetDevice::RangingOppStart (void)
{
m_rangingOppNumber++;
NS_LOG_DEBUG ("Ranging TO " << (uint32_t) m_rangingOppNumber << ": " << Simulator::Now ().GetSeconds ());
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-net-device.cc | C++ | gpl2 | 37,335 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "ns3/simulator.h"
#include "ns3/node.h"
#include "ns3/log.h"
#include "ss-scheduler.h"
#include "ss-net-device.h"
#include "wimax-phy.h"
#include "wimax-mac-queue.h"
#include "wimax-connection.h"
#include "connection-manager.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
NS_LOG_COMPONENT_DEFINE ("SSScheduler");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (SSScheduler);
TypeId SSScheduler::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::SSScheduler")
.SetParent<Object> ();
return tid;
}
SSScheduler::SSScheduler (Ptr<SubscriberStationNetDevice> ss)
: m_ss (ss),
m_pollMe (false)
{
}
SSScheduler::~SSScheduler (void)
{
}
void
SSScheduler::DoDispose (void)
{
m_ss = 0;
}
void
SSScheduler::SetPollMe (bool pollMe)
{
m_pollMe = pollMe;
}
bool
SSScheduler::GetPollMe (void) const
{
return m_pollMe;
}
Ptr<PacketBurst>
SSScheduler::Schedule (uint16_t availableSymbols,
WimaxPhy::ModulationType modulationType,
MacHeaderType::HeaderType packetType,
Ptr<WimaxConnection> &connection)
{
Time timeStamp;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
uint16_t nrSymbolsRequired = 0;
if (!connection)
{
connection = SelectConnection ();
}
else
{
NS_ASSERT_MSG (connection->HasPackets (),
"SS: Error while scheduling packets: The selected connection has no packets");
}
Ptr<Packet> packet;
while (connection && connection->HasPackets (packetType))
{
NS_LOG_INFO ("FRAG_DEBUG: SS Scheduler" << std::endl);
uint32_t availableByte = m_ss->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
uint32_t requiredByte = connection->GetQueue ()->GetFirstPacketRequiredByte (packetType);
NS_LOG_INFO ("\t availableByte = " << availableByte <<
", requiredByte = " << requiredByte);
if (availableByte >= requiredByte)
{
// The SS could sent a packet without a other fragmentation
NS_LOG_INFO ("\t availableByte >= requiredByte"
"\n\t Send packet without other fragmentation" << std::endl);
packet = connection->Dequeue (packetType);
burst->AddPacket (packet);
nrSymbolsRequired = m_ss->GetPhy ()->
GetNrSymbols (packet->GetSize (), modulationType);
availableSymbols -= nrSymbolsRequired;
}
else
{
if (connection->GetType () == Cid::TRANSPORT)
{
NS_LOG_INFO ("\t availableByte < requiredByte"
"\n\t Check if the fragmentation is possible");
uint32_t headerSize = connection->GetQueue ()->GetFirstPacketHdrSize (packetType);
if (!connection->GetQueue ()->CheckForFragmentation (packetType))
{
NS_LOG_INFO ("\t Add fragmentSubhdrSize = 2");
headerSize += 2;
}
NS_LOG_INFO ("\t availableByte = " << availableByte <<
" headerSize = " << headerSize);
if (availableByte > headerSize)
{
NS_LOG_INFO ("\t Fragmentation IS possible");
packet = connection->Dequeue (packetType, availableByte);
burst->AddPacket (packet);
nrSymbolsRequired = m_ss->GetPhy ()->
GetNrSymbols (packet->GetSize (), modulationType);
availableSymbols -= nrSymbolsRequired;
}
else
{
NS_LOG_INFO ("\t Fragmentation IS NOT possible" << std::endl);
break;
}
}
else
{
NS_LOG_INFO ("\t no Transport Connection "
"\n\t Fragmentation IS NOT possible, " << std::endl);
break;
}
}
}
return burst;
}
Ptr<WimaxConnection>
SSScheduler::SelectConnection (void)
{
Time currentTime = Simulator::Now ();
std::vector<ServiceFlow*>::const_iterator iter;
std::vector<ServiceFlow*> serviceFlows;
NS_LOG_INFO ("SS Scheduler: Selecting connection...");
if (m_ss->GetInitialRangingConnection ()->HasPackets ())
{
NS_LOG_INFO ("Return GetInitialRangingConnection");
return m_ss->GetInitialRangingConnection ();
}
if (m_ss->GetBasicConnection ()->HasPackets ())
{
NS_LOG_INFO ("Return GetBasicConnection");
return m_ss->GetBasicConnection ();
}
if (m_ss->GetPrimaryConnection ()->HasPackets ())
{
NS_LOG_INFO ("Return GetPrimaryConnection");
return m_ss->GetPrimaryConnection ();
}
serviceFlows = m_ss->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_UGS);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
// making sure that this grant was actually intended for this UGS
if ((*iter)->HasPackets () && (currentTime
+ m_ss->GetPhy ()->GetFrameDuration () > MilliSeconds (
(*iter)->GetUnsolicitedGrantInterval ())))
{
NS_LOG_INFO ("Return UGS SF: CID = " << (*iter)->GetCid () << "SFID = "
<< (*iter)->GetSfid ());
return (*iter)->GetConnection ();
}
}
/* In the following cases (rtPS, nrtPS and BE flows) connection is seletected only for data packets, for bandwidth
request packets connection will itself be passed to Schedule () and hence this function will never be called. */
serviceFlows = m_ss->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_RTPS);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
if ((*iter)->HasPackets (MacHeaderType::HEADER_TYPE_GENERIC)
&& (currentTime + m_ss->GetPhy ()->GetFrameDuration ()
> MilliSeconds (
(*iter)->GetUnsolicitedPollingInterval ())))
{
NS_LOG_INFO ("Return RTPS SF: CID = " << (*iter)->GetCid () << "SFID = "
<< (*iter)->GetSfid ());
return (*iter)->GetConnection ();
}
}
serviceFlows = m_ss->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_NRTPS);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
if ((*iter)->HasPackets (MacHeaderType::HEADER_TYPE_GENERIC))
{
NS_LOG_INFO ("Return NRTPS SF: CID = " << (*iter)->GetCid () << "SFID = "
<< (*iter)->GetSfid ());
return (*iter)->GetConnection ();
}
}
serviceFlows = m_ss->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_BE);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
if ((*iter)->HasPackets (MacHeaderType::HEADER_TYPE_GENERIC))
{
NS_LOG_INFO ("Return BE SF: CID = " << (*iter)->GetCid () << "SFID = "
<< (*iter)->GetSfid ());
return (*iter)->GetConnection ();
}
}
if (m_ss->GetBroadcastConnection ()->HasPackets ())
{
return m_ss->GetBroadcastConnection ();
}
NS_LOG_INFO ("NO connection is selected!");
return 0;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ss-scheduler.cc | C++ | gpl2 | 8,265 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include <stdint.h>
#include "ns3/node.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "service-flow.h"
#include "service-flow-manager.h"
#include "ns3/log.h"
#include "bs-net-device.h"
#include "ss-record.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "wimax-connection.h"
#include "ss-manager.h"
#include "connection-manager.h"
#include "bs-uplink-scheduler.h"
#include "ss-scheduler.h"
#include "ns3/buffer.h"
#include "service-flow-record.h"
NS_LOG_COMPONENT_DEFINE ("BsServiceFlowManager");
namespace ns3 {
BsServiceFlowManager::BsServiceFlowManager (Ptr<BaseStationNetDevice> device)
: m_device (device),
m_sfidIndex (100),
m_maxDsaRspRetries (100) // default value
{
m_inuseScheduleDsaRspCid = Cid::InitialRanging ();
}
BsServiceFlowManager::~BsServiceFlowManager (void)
{
}
void
BsServiceFlowManager::DoDispose (void)
{
ServiceFlowManager::DoDispose ();
}
void
BsServiceFlowManager::SetMaxDsaRspRetries (uint8_t maxDsaRspRetries)
{
m_maxDsaRspRetries = maxDsaRspRetries;
}
uint8_t
BsServiceFlowManager::GetMaxDsaRspRetries (void) const
{
return m_maxDsaRspRetries;
}
EventId
BsServiceFlowManager::GetDsaAckTimeoutEvent (void) const
{
return m_dsaAckTimeoutEvent;
}
void
BsServiceFlowManager::AddServiceFlow (ServiceFlow *serviceFlow)
{
ServiceFlowManager::AddServiceFlow (serviceFlow);
}
ServiceFlow*
BsServiceFlowManager::GetServiceFlow (uint32_t sfid) const
{
return ServiceFlowManager::GetServiceFlow (sfid);
}
ServiceFlow*
BsServiceFlowManager::GetServiceFlow (Cid cid) const
{
return ServiceFlowManager::GetServiceFlow (cid);
}
std::vector<ServiceFlow*>
BsServiceFlowManager::GetServiceFlows (ServiceFlow::SchedulingType schedulingType) const
{
return ServiceFlowManager::GetServiceFlows (schedulingType);
}
DsaRsp
BsServiceFlowManager::CreateDsaRsp (const ServiceFlow *serviceFlow, uint16_t transactionId)
{
DsaRsp dsaRsp;
dsaRsp.SetTransactionId (transactionId);
dsaRsp.SetServiceFlow (*serviceFlow);
// assuming SS can supports all of the service flow parameters
dsaRsp.SetConfirmationCode (CONFIRMATION_CODE_SUCCESS);
return dsaRsp;
}
void
BsServiceFlowManager::ScheduleDsaRsp (ServiceFlow *serviceFlow, Cid cid)
{
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
SSRecord *ssRecord = bs->GetSSManager ()->GetSSRecord (cid);
if (ssRecord == 0)
{
NS_LOG_INFO ("SS not registered with the BS CID:" << cid);
return;
}
serviceFlow->SetIsEnabled (true);
serviceFlow->SetType (ServiceFlow::SF_TYPE_ACTIVE);
ssRecord->AddServiceFlow (serviceFlow);
bs->GetUplinkScheduler ()->SetupServiceFlow (ssRecord, serviceFlow);
Ptr<Packet> p = Create<Packet> ();
DsaRsp dsaRsp;
if (ssRecord->GetDsaRspRetries () == 0)
{
dsaRsp = CreateDsaRsp (serviceFlow, ssRecord->GetSfTransactionId ());
p->AddHeader (dsaRsp);
ssRecord->SetDsaRsp (dsaRsp);
}
else
{
if (ssRecord->GetDsaRspRetries () < m_maxDsaRspRetries)
{
p->AddHeader (ssRecord->GetDsaRsp ());
}
else
{
NS_LOG_DEBUG ("Service flows could not be initialized!");
}
}
ssRecord->IncrementDsaRspRetries ();
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_DSA_RSP));
if (m_dsaAckTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_dsaAckTimeoutEvent);
}
m_inuseScheduleDsaRspCid = cid;
m_dsaAckTimeoutEvent = Simulator::Schedule (bs->GetIntervalT8 (),
&BsServiceFlowManager::ScheduleDsaRsp,
this,
serviceFlow,
cid);
m_device->Enqueue (p, MacHeaderType (), bs->GetConnection (ssRecord->GetPrimaryCid ()));
}
ServiceFlow*
BsServiceFlowManager::ProcessDsaReq (const DsaReq &dsaReq, Cid cid)
{
ServiceFlow * serviceFlow;
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
SSRecord *ssRecord = bs->GetSSManager ()->GetSSRecord (cid);
NS_LOG_INFO ("BsServiceFlowManager: Processing DSA-REQ...");
if (ssRecord->GetSfTransactionId () != 0)
{
// had already received DSA-REQ. DSA-RSP was lost
NS_ASSERT_MSG (dsaReq.GetTransactionId () == ssRecord->GetSfTransactionId (),
"Error while processing DSA request:the received transaction ID is not expected");
serviceFlow = GetServiceFlow (ssRecord->GetDsaRsp ().GetSfid ());
}
else
{
ServiceFlow sf = dsaReq.GetServiceFlow ();
Ptr<WimaxConnection> transportConnection;
Ptr<ConnectionManager> BsConManager = bs->GetConnectionManager ();
transportConnection = BsConManager->CreateConnection (Cid::TRANSPORT);
serviceFlow = new ServiceFlow (m_sfidIndex++, sf.GetDirection (), transportConnection);
transportConnection->SetServiceFlow (serviceFlow);
serviceFlow->CopyParametersFrom (sf);
serviceFlow->SetUnsolicitedGrantInterval (1);
serviceFlow->SetUnsolicitedPollingInterval (1);
serviceFlow->SetConvergenceSublayerParam (sf.GetConvergenceSublayerParam ());
AddServiceFlow (serviceFlow);
ssRecord->SetSfTransactionId (dsaReq.GetTransactionId ());
NS_LOG_INFO ("BsServiceFlowManager: Creating a new Service flow: SFID = " << serviceFlow->GetSfid () << " CID = "
<< serviceFlow->GetCid ());
}
return serviceFlow;
}
void
BsServiceFlowManager::AddMulticastServiceFlow (ServiceFlow sf, enum WimaxPhy::ModulationType modulation)
{
ServiceFlow * serviceFlow = new ServiceFlow ();
serviceFlow->CopyParametersFrom (sf);
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
Ptr<WimaxConnection> multicastConnection = bs->GetConnectionManager ()->CreateConnection (Cid::MULTICAST);
serviceFlow->SetConnection (multicastConnection);
AddServiceFlow (serviceFlow);
serviceFlow->SetIsEnabled (true);
serviceFlow->SetType (ServiceFlow::SF_TYPE_ACTIVE);
serviceFlow->SetIsMulticast (true);
serviceFlow->SetModulation (modulation);
bs->GetUplinkScheduler ()->SetupServiceFlow (0, serviceFlow);
}
void
BsServiceFlowManager::AllocateServiceFlows (const DsaReq &dsaReq, Cid cid)
{
ServiceFlow *serviceFlow = ProcessDsaReq (dsaReq, cid);
if (serviceFlow) {
ScheduleDsaRsp (serviceFlow, cid);
} else {
NS_LOG_INFO ("No service Flow. Could not connect.");
}
}
void
BsServiceFlowManager::ProcessDsaAck (const DsaAck &dsaAck, Cid cid)
{
Ptr<BaseStationNetDevice> bs = m_device->GetObject<BaseStationNetDevice> ();
SSRecord *ssRecord = bs->GetSSManager ()->GetSSRecord (cid);
if (dsaAck.GetTransactionId () != ssRecord->GetSfTransactionId ())
{
return;
}
ssRecord->SetDsaRspRetries (0);
ssRecord->SetSfTransactionId (0);
// check if all service flow have been initiated
if (AreServiceFlowsAllocated (ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_ALL)))
{
ssRecord->SetAreServiceFlowsAllocated (true);
}
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-service-flow-manager.cc | C++ | gpl2 | 8,084 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*/
#include "ipcs-classifier-record.h"
#include <stdint.h>
#include "ns3/ipv4-address.h"
#include "wimax-tlv.h"
NS_LOG_COMPONENT_DEFINE ("IpcsClassifierRecord");
namespace ns3 {
IpcsClassifierRecord::IpcsClassifierRecord (void)
{
m_priority = 255;
m_priority = 0;
m_index = 0;
m_tosLow = 0;
m_tosHigh = 0;
m_tosMask = 0;
m_cid = 0;
m_protocol.push_back (6); // tcp
m_protocol.push_back (17); // udp
AddSrcAddr (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"));
AddDstAddr (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"));
AddSrcPortRange (0, 65535);
AddDstPortRange (0, 65535);
}
IpcsClassifierRecord::~IpcsClassifierRecord (void)
{
}
IpcsClassifierRecord::IpcsClassifierRecord (Tlv tlv)
{
NS_ASSERT_MSG (tlv.GetType () == CsParamVectorTlvValue::Packet_Classification_Rule, "Invalid TLV");
ClassificationRuleVectorTlvValue* rules = ((ClassificationRuleVectorTlvValue*)(tlv.PeekValue ()));
m_priority = 0;
m_index = 0;
m_tosLow = 0;
m_tosHigh = 0;
m_tosMask = 0;
m_cid = 0;
for (std::vector<Tlv*>::const_iterator iter = rules->Begin (); iter != rules->End (); ++iter)
{
switch ((*iter)->GetType ())
{
case ClassificationRuleVectorTlvValue::Priority:
{
m_priority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case ClassificationRuleVectorTlvValue::ToS:
{
NS_FATAL_ERROR ("ToS Not implemented-- please implement and contribute a patch");
break;
}
case ClassificationRuleVectorTlvValue::Protocol:
{
ProtocolTlvValue * list = (ProtocolTlvValue *)(*iter)->PeekValue ();
for (std::vector<uint8_t>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddProtocol (*iter2);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_src:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_dst:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_src:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_dst:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Index:
{
m_index = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
}
}
}
IpcsClassifierRecord::IpcsClassifierRecord (Ipv4Address SrcAddress,
Ipv4Mask SrcMask,
Ipv4Address DstAddress,
Ipv4Mask DstMask,
uint16_t SrcPortLow,
uint16_t SrcPortHigh,
uint16_t DstPortLow,
uint16_t DstPortHigh,
uint8_t protocol,
uint8_t priority)
{
m_priority = priority;
m_protocol.push_back (protocol);
AddSrcAddr (SrcAddress, SrcMask);
AddDstAddr (DstAddress, DstMask);
AddSrcPortRange (SrcPortLow, SrcPortHigh);
AddDstPortRange (DstPortLow, DstPortHigh);
m_index = 0;
m_tosLow = 0;
m_tosHigh = 0;
m_tosMask = 0;
m_cid = 0;
}
void
IpcsClassifierRecord::AddSrcAddr (Ipv4Address srcAddress, Ipv4Mask srcMask)
{
struct ipv4Addr tmp;
tmp.Address = srcAddress;
tmp.Mask = srcMask;
m_srcAddr.push_back (tmp);
}
void
IpcsClassifierRecord::AddDstAddr (Ipv4Address dstAddress, Ipv4Mask dstMask)
{
struct ipv4Addr tmp;
tmp.Address = dstAddress;
tmp.Mask = dstMask;
m_dstAddr.push_back (tmp);
}
void
IpcsClassifierRecord::AddSrcPortRange (uint16_t srcPortLow, uint16_t srcPortHigh)
{
struct PortRange tmp;
tmp.PortLow = srcPortLow;
tmp.PortHigh = srcPortHigh;
m_srcPortRange.push_back (tmp);
}
void
IpcsClassifierRecord::AddDstPortRange (uint16_t dstPortLow, uint16_t dstPortHigh)
{
struct PortRange tmp;
tmp.PortLow = dstPortLow;
tmp.PortHigh = dstPortHigh;
m_dstPortRange.push_back (tmp);
}
void
IpcsClassifierRecord::AddProtocol (uint8_t proto)
{
m_protocol.push_back (proto);
}
void
IpcsClassifierRecord::SetPriority (uint8_t prio)
{
m_priority = prio;
}
void
IpcsClassifierRecord::SetCid (uint16_t cid)
{
m_cid = cid;
}
void
IpcsClassifierRecord::SetIndex (uint16_t index)
{
m_index = index;
}
uint16_t
IpcsClassifierRecord::GetIndex (void) const
{
return m_index;
}
uint16_t
IpcsClassifierRecord::GetCid (void) const
{
return m_cid;
}
uint8_t
IpcsClassifierRecord::GetPriority (void) const
{
return m_priority;
}
bool
IpcsClassifierRecord::CheckMatchSrcAddr (Ipv4Address srcAddress) const
{
for (std::vector<struct ipv4Addr>::const_iterator iter = m_srcAddr.begin (); iter != m_srcAddr.end (); ++iter)
{
NS_LOG_INFO ("src addr check match: pkt=" << srcAddress << " cls=" << (*iter).Address << "/" << (*iter).Mask);
if (srcAddress.CombineMask ((*iter).Mask) == (*iter).Address)
{
return true;
}
}
NS_LOG_INFO ("NOT OK!");
return false;
}
bool
IpcsClassifierRecord::CheckMatchDstAddr (Ipv4Address dstAddress) const
{
for (std::vector<struct ipv4Addr>::const_iterator iter = m_dstAddr.begin (); iter != m_dstAddr.end (); ++iter)
{
NS_LOG_INFO ("dst addr check match: pkt=" << dstAddress << " cls=" << (*iter).Address << "/" << (*iter).Mask);
if (dstAddress.CombineMask ((*iter).Mask) == (*iter).Address)
{
return true;
}
}
NS_LOG_INFO ("NOT OK!");
return false;
}
bool
IpcsClassifierRecord::CheckMatchSrcPort (uint16_t port) const
{
for (std::vector<struct PortRange>::const_iterator iter = m_srcPortRange.begin (); iter != m_srcPortRange.end (); ++iter)
{
NS_LOG_INFO ("src port check match: pkt=" << port << " cls= [" << (*iter).PortLow << " TO " << (*iter).PortHigh
<< "]");
if (port >= (*iter).PortLow && port <= (*iter).PortHigh)
{
return true;
}
}
NS_LOG_INFO ("NOT OK!");
return false;
}
bool
IpcsClassifierRecord::CheckMatchDstPort (uint16_t port) const
{
for (std::vector<struct PortRange>::const_iterator iter = m_dstPortRange.begin (); iter != m_dstPortRange.end (); ++iter)
{
NS_LOG_INFO ("dst port check match: pkt=" << port << " cls= [" << (*iter).PortLow << " TO " << (*iter).PortHigh
<< "]");
if (port >= (*iter).PortLow && port <= (*iter).PortHigh)
{
return true;
}
}
NS_LOG_INFO ("NOT OK!");
return false;
}
bool
IpcsClassifierRecord::CheckMatchProtocol (uint8_t proto) const
{
for (std::vector<uint8_t>::const_iterator iter = m_protocol.begin (); iter != m_protocol.end (); ++iter)
{
NS_LOG_INFO ("proto check match: pkt=" << (uint16_t) proto << " cls=" << (uint16_t) proto);
if (proto == (*iter))
{
return true;
}
}
NS_LOG_INFO ("NOT OK!");
return false;
}
bool
IpcsClassifierRecord::CheckMatch (Ipv4Address srcAddress,
Ipv4Address dstAddress,
uint16_t srcPort,
uint16_t dstPort,
uint8_t proto) const
{
return (CheckMatchProtocol (proto) && CheckMatchDstPort (dstPort) && CheckMatchSrcPort (srcPort)
&& CheckMatchDstAddr (dstAddress) && CheckMatchSrcAddr (srcAddress));
}
Tlv
IpcsClassifierRecord::ToTlv (void) const
{
Ipv4AddressTlvValue ipv4AddrValSrc;
for (std::vector<struct ipv4Addr>::const_iterator iter = m_srcAddr.begin (); iter != m_srcAddr.end (); ++iter)
{
ipv4AddrValSrc.Add ((*iter).Address, (*iter).Mask);
}
Ipv4AddressTlvValue ipv4AddrValDst;
for (std::vector<struct ipv4Addr>::const_iterator iter = m_dstAddr.begin (); iter != m_dstAddr.end (); ++iter)
{
ipv4AddrValDst.Add ((*iter).Address, (*iter).Mask);
}
ProtocolTlvValue protoVal;
for (std::vector<uint8_t>::const_iterator iter = m_protocol.begin (); iter != m_protocol.end (); ++iter)
{
protoVal.Add ((*iter));
}
PortRangeTlvValue portValueSrc;
for (std::vector<struct PortRange>::const_iterator iter = m_srcPortRange.begin (); iter != m_srcPortRange.end (); ++iter)
{
portValueSrc.Add ((*iter).PortLow, (*iter).PortHigh);
}
PortRangeTlvValue portValueDst;
for (std::vector<struct PortRange>::const_iterator iter = m_dstPortRange.begin (); iter != m_dstPortRange.end (); ++iter)
{
portValueDst.Add ((*iter).PortLow, (*iter).PortHigh);
}
ClassificationRuleVectorTlvValue ClassVectVal;
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::Priority, 1, U8TlvValue (m_priority)));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::Protocol, protoVal.GetSerializedSize (), protoVal));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::IP_src, ipv4AddrValSrc.GetSerializedSize (), ipv4AddrValSrc));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::IP_dst, ipv4AddrValDst.GetSerializedSize (), ipv4AddrValDst));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::Port_src, portValueSrc.GetSerializedSize (), portValueSrc));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::Port_dst, portValueDst.GetSerializedSize (), portValueDst));
ClassVectVal.Add (Tlv (ClassificationRuleVectorTlvValue::Index, 2, U16TlvValue (1)));
Tlv tmp_tlv (CsParamVectorTlvValue::Packet_Classification_Rule, ClassVectVal.GetSerializedSize (), ClassVectVal);
return tmp_tlv;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ipcs-classifier-record.cc | C++ | gpl2 | 11,860 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <Amine.Ismail@sophia.inria.fr>
* <Amine.Ismail@UDcast.com>
*/
#include "wimax-mac-queue.h"
#include "ns3/packet.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/uinteger.h"
#include "ns3/simulator.h"
#include "ns3/log.h"
NS_LOG_COMPONENT_DEFINE ("WimaxMacQueue");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxMacQueue);
WimaxMacQueue::QueueElement::QueueElement (void)
: m_packet (Create<Packet> ()),
m_hdrType (MacHeaderType ()),
m_hdr (
GenericMacHeader ()),
m_timeStamp (Seconds (0)),
m_fragmentation (false),
m_fragmentNumber (0),
m_fragmentOffset (0)
{
}
WimaxMacQueue::QueueElement::QueueElement (Ptr<Packet> packet,
const MacHeaderType &hdrType,
const GenericMacHeader &hdr, Time timeStamp)
: m_packet (packet),
m_hdrType (hdrType),
m_hdr (hdr),
m_timeStamp (timeStamp),
m_fragmentation (false),
m_fragmentNumber (0),
m_fragmentOffset (0)
{
}
uint32_t
WimaxMacQueue::QueueElement::GetSize (void) const
{
uint32_t size = m_packet->GetSize () + m_hdrType.GetSerializedSize ();
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
size += m_hdr.GetSerializedSize ();
}
return size;
}
TypeId
WimaxMacQueue::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxMacQueue")
.SetParent<Object> ()
.AddAttribute (
"MaxSize",
"Maximum size",
UintegerValue (1024),
MakeUintegerAccessor (&WimaxMacQueue::GetMaxSize,
&WimaxMacQueue::SetMaxSize),
MakeUintegerChecker<uint32_t> ())
.AddTraceSource ("Enqueue",
"Enqueue trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceEnqueue))
.AddTraceSource ("Dequeue",
"Dequeue trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceDequeue))
.AddTraceSource ("Drop",
"Drop trace",
MakeTraceSourceAccessor (&WimaxMacQueue::m_traceDrop))
;
return tid;
}
WimaxMacQueue::WimaxMacQueue (void)
: m_maxSize (0),
m_bytes (0),
m_nrDataPackets (0),
m_nrRequestPackets (0)
{
}
WimaxMacQueue::WimaxMacQueue (uint32_t maxSize)
: m_maxSize (maxSize),
m_bytes (0),
m_nrDataPackets (0),
m_nrRequestPackets (0)
{
}
WimaxMacQueue::~WimaxMacQueue (void)
{
}
void
WimaxMacQueue::SetMaxSize (uint32_t maxSize)
{
m_maxSize = maxSize;
}
uint32_t
WimaxMacQueue::GetMaxSize (void) const
{
return m_maxSize;
}
bool
WimaxMacQueue::Enqueue (Ptr<Packet> packet, const MacHeaderType &hdrType,
const GenericMacHeader &hdr)
{
if (m_queue.size () == m_maxSize)
{
m_traceDrop (packet);
return false;
}
m_traceEnqueue (packet);
QueueElement element (packet, hdrType, hdr, Simulator::Now ());
m_queue.push_back (element);
if (hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
m_nrDataPackets++;
}
else
{
m_nrRequestPackets++;
}
m_bytes += element.GetSize ();
return true;
}
Ptr<Packet>
WimaxMacQueue::Dequeue (MacHeaderType::HeaderType packetType)
{
if (!IsEmpty ())
{
QueueElement element = Front (packetType);
Pop (packetType);
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
NS_LOG_INFO ("Enqueued Packet IS A data packet");
NS_ASSERT_MSG (m_nrDataPackets >= 1,
"Can not enqueue more packets: no space left in the queue");
m_nrDataPackets--;
}
else
{
NS_LOG_INFO ("Enqueued Packet IS A Request BW packet");
NS_ASSERT_MSG (m_nrRequestPackets >= 1,
"Can not enqueue more packets: no space left in the queue");
m_nrRequestPackets--;
}
Ptr<Packet> packet = element.m_packet;
if (!element.m_fragmentation)
{
NS_LOG_INFO ("FRAG_DEBUG: Enqueued Packet IS NOT a fragment" << std::endl);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
m_bytes -= element.GetSize ();
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
packet->AddHeader (element.m_hdr);
}
packet->AddHeader (element.m_hdrType);
m_traceDequeue (packet);
return packet;
}
else
{
/*
The enqueued packet is a fragment (the latest fragment)
We must modify type field of the m_hdr and add a fragmentation Subhdr
*/
NS_LOG_INFO ("\t Enqueued Packet IS a fragment, add subhdr" << std::endl);
// Create a fragment
uint32_t fragmentOffset = element.m_fragmentOffset;
uint32_t fragmentSize = element.m_packet->GetSize () - fragmentOffset;
NS_LOG_INFO ("\t Create a fragment"
"\n\t\t fragmentOffset=" << fragmentOffset <<
"\n\t\t packetSize=" << element.m_packet->GetSize () <<
"\n\t\t fragmentSize=" << fragmentSize << std::endl);
Ptr<Packet> fragment = packet->CreateFragment (fragmentOffset,fragmentSize);
FragmentationSubheader fragmentSubhdr;
NS_LOG_INFO ("\t Latest Fragment" << std::endl);
fragmentSubhdr.SetFc (2); // This is the latest fragment
fragmentSubhdr.SetFsn (element.m_fragmentNumber);
NS_LOG_INFO ("\t FragmentSize=" << fragment->GetSize () << std::endl);
fragment->AddHeader (fragmentSubhdr);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
uint8_t tmpType = element.m_hdr.GetType ();
tmpType |= 4;
element.m_hdr.SetType (tmpType);
uint32_t length = fragmentSize + element.m_hdr.GetSerializedSize ()
+ fragmentSubhdr.GetSerializedSize ();
element.m_hdr.SetLen ((uint16_t)length);
fragment->AddHeader (element.m_hdr);
}
fragment->AddHeader (element.m_hdrType);
m_bytes -= fragmentSize;
m_traceDequeue (fragment);
return fragment;
}
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte)
{
if (!IsEmpty ())
{
NS_LOG_INFO ("FRAG_DEBUG: Dequeue function" << std::endl);
QueueElement element = Front (packetType);
uint32_t headerSize = 2 + element.m_hdr.GetSerializedSize () +
element.m_hdrType.GetSerializedSize ();
// Create a fragment
uint32_t maxFragmentSize = availableByte - headerSize;
uint32_t fragmentOffset = element.m_fragmentOffset; // It is the latest byte sent.
Ptr<Packet> packet = element.m_packet->Copy ();
NS_LOG_INFO ("\t Create a fragment"
"\n\t\t availableByte=" << availableByte <<
"\n\t\t headerSize=" << headerSize <<
"\n\t\t maxFragmentSize=" << maxFragmentSize << ""
"\n\t\t fragmentOffset=" << fragmentOffset <<
"\n\t\t payloadSize=" << packet->GetSize ()
<< std::endl);
Ptr<Packet> fragment = packet->CreateFragment (fragmentOffset,
maxFragmentSize);
m_bytes -= maxFragmentSize;
FragmentationSubheader fragmentSubhdr;
if (!element.m_fragmentation)
{
NS_LOG_INFO ("\t First Fragment" << std::endl);
SetFragmentation (packetType);
fragmentSubhdr.SetFc (1);
}
else
{
NS_LOG_INFO ("\t Middle Fragment" << std::endl);
fragmentSubhdr.SetFc (3);
}
fragmentSubhdr.SetFsn (element.m_fragmentNumber);
NS_LOG_INFO ("\t FragmentSize=" << fragment->GetSize () << std::endl);
fragment->AddHeader (fragmentSubhdr);
SetFragmentNumber (packetType);
SetFragmentOffset (packetType, maxFragmentSize);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
uint8_t tmpType = element.m_hdr.GetType ();
tmpType |= 4;
element.m_hdr.SetType (tmpType);
uint32_t length = maxFragmentSize + element.m_hdr.GetSerializedSize ()
+ fragmentSubhdr.GetSerializedSize ();
element.m_hdr.SetLen ((uint16_t)length);
fragment->AddHeader (element.m_hdr);
}
fragment->AddHeader (element.m_hdrType);
m_traceDequeue (fragment);
return fragment;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Peek (GenericMacHeader &hdr) const
{
if (!IsEmpty ())
{
QueueElement element = m_queue.front ();
hdr = element.m_hdr;
Ptr<Packet> packet = element.m_packet->Copy ();
// this function must not be used by SS as it may be then a bandwidth request header
packet->AddHeader (element.m_hdr);
return packet;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Peek (GenericMacHeader &hdr, Time &timeStamp) const
{
if (!IsEmpty ())
{
QueueElement element = m_queue.front ();
hdr = element.m_hdr;
timeStamp = element.m_timeStamp;
Ptr<Packet> packet = element.m_packet->Copy ();
// this function must not be used for by SS as it may be then a bandwidth request header
packet->AddHeader (element.m_hdr);
return packet;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Peek (MacHeaderType::HeaderType packetType) const
{
if (!IsEmpty ())
{
QueueElement element = Front (packetType);
Ptr<Packet> packet = element.m_packet->Copy ();
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
packet->AddHeader (element.m_hdr);
}
return packet;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Peek (MacHeaderType::HeaderType packetType,
Time &timeStamp) const
{
if (!IsEmpty ())
{
QueueElement element = Front (packetType);
timeStamp = element.m_timeStamp;
Ptr<Packet> packet = element.m_packet->Copy ();
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
packet->AddHeader (element.m_hdr);
}
return packet;
}
return 0;
}
uint32_t
WimaxMacQueue::GetSize (void) const
{
return m_queue.size ();
}
uint32_t
WimaxMacQueue::GetNBytes (void) const
{
return m_bytes;
}
uint32_t WimaxMacQueue::GetQueueLengthWithMACOverhead (void)
{
uint32_t queueSize = GetNBytes ();
// Add MAC Overhead
queueSize += GetSize () * 6;
MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC;
if (CheckForFragmentation (packetType))
{
queueSize += 2;
}
return queueSize;
}
WimaxMacQueue::QueueElement
WimaxMacQueue::Front (MacHeaderType::HeaderType packetType) const
{
QueueElement element;
for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
element = *iter;
if (element.m_hdrType.GetType () == packetType)
{
break;
}
}
return element;
}
void
WimaxMacQueue::Pop (MacHeaderType::HeaderType packetType)
{
QueueElement element;
for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
element = *iter;
if (element.m_hdrType.GetType () == packetType)
{
m_queue.erase (iter);
break;
}
}
}
bool
WimaxMacQueue::IsEmpty (void) const
{
return m_queue.empty ();
}
bool
WimaxMacQueue::IsEmpty (MacHeaderType::HeaderType packetType) const
{
if (packetType == MacHeaderType::HEADER_TYPE_GENERIC)
{
return m_nrDataPackets == 0;
}
else
{
return m_nrRequestPackets == 0;
}
return true;
}
const WimaxMacQueue::PacketQueue &
WimaxMacQueue::GetPacketQueue (void) const
{
return m_queue;
}
bool
WimaxMacQueue::CheckForFragmentation (MacHeaderType::HeaderType packetType)
{
QueueElement element;
for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
element = *iter;
if (element.m_hdrType.GetType () == packetType)
{
break;
}
}
if (element.m_fragmentation)
{
NS_LOG_INFO ("FRAG_DEBUG: CheckForFragmentation"
"\n\t\t m_fragmentation is true " << std::endl);
}
return element.m_fragmentation;
}
uint32_t
WimaxMacQueue::GetFirstPacketHdrSize (MacHeaderType::HeaderType packetType)
{
QueueElement element;
for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
element = *iter;
if (element.m_hdrType.GetType () == packetType)
{
break;
}
}
NS_LOG_INFO ("\t\t GetFirstPacketHdrSize ()");
uint32_t hdrSize = 0;
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
hdrSize += element.m_hdr.GetSerializedSize ();
NS_LOG_INFO ("\t\t\t m_hdr.GetSerializedSize=" <<
element.m_hdr.GetSerializedSize ());
}
hdrSize += element.m_hdrType.GetSerializedSize ();
NS_LOG_INFO ("\t\t\t m_hdrType.GetSerializedSize=" <<
element.m_hdrType.GetSerializedSize ());
if (CheckForFragmentation (packetType))
{
NS_LOG_INFO ("\t\t\t fragSubhdrSize=2");
hdrSize += 2;
}
NS_LOG_INFO ("\t\t hdrSize=" << hdrSize);
return hdrSize;
}
uint32_t
WimaxMacQueue::GetFirstPacketPayloadSize (MacHeaderType::HeaderType packetType)
{
QueueElement element;
for (std::deque<QueueElement>::const_iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
element = *iter;
if (element.m_hdrType.GetType () == packetType)
{
break;
}
}
NS_LOG_INFO ("\t\t GetFirstPacketPayloadSize ()");
if (CheckForFragmentation (packetType))
{
NS_LOG_INFO ("\t\t\t fullPayloadSize=" << element.m_packet->GetSize ()
<< "\n\t\t\t fragmentOffset=" << element.m_fragmentOffset
<< "\n\t\t\t (fragment)payloadSize=" <<
element.m_packet->GetSize () - element.m_fragmentOffset);
return element.m_packet->GetSize () - element.m_fragmentOffset;
}
NS_LOG_INFO ("\t\t payloadSize=" <<
element.m_packet->GetSize ());
return element.m_packet->GetSize ();
}
uint32_t
WimaxMacQueue::GetFirstPacketRequiredByte (MacHeaderType::HeaderType packetType)
{
NS_LOG_INFO ("\t GetFirstPacketRequiredByte ()");
uint32_t requiredByte = GetFirstPacketPayloadSize (packetType) +
GetFirstPacketHdrSize (packetType);
NS_LOG_INFO ("\t Required Bytes = " << requiredByte << std::endl);
return requiredByte;
}
void
WimaxMacQueue::SetFragmentation (MacHeaderType::HeaderType packetType)
{
for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
if (iter->m_hdrType.GetType () == packetType)
{
iter->SetFragmentation ();
break;
}
}
}
void
WimaxMacQueue::SetFragmentNumber (MacHeaderType::HeaderType packetType)
{
for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
if (iter->m_hdrType.GetType () == packetType)
{
iter->SetFragmentNumber ();
break;
}
}
}
void
WimaxMacQueue::SetFragmentOffset (MacHeaderType::HeaderType packetType, uint32_t offset)
{
for (std::deque<QueueElement>::iterator iter = m_queue.begin (); iter
!= m_queue.end (); ++iter)
{
if (iter->m_hdrType.GetType () == packetType)
{
iter->SetFragmentOffset (offset);
break;
}
}
}
void
WimaxMacQueue::QueueElement::SetFragmentation ()
{
m_fragmentation = true;
}
void
WimaxMacQueue::QueueElement::SetFragmentNumber ()
{
m_fragmentNumber++;
}
void
WimaxMacQueue::QueueElement::SetFragmentOffset (uint32_t offset)
{
m_fragmentOffset += offset;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-mac-queue.cc | C++ | gpl2 | 18,945 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include <stdint.h>
#include "ss-manager.h"
#include "ns3/log.h"
#include "service-flow.h"
NS_LOG_COMPONENT_DEFINE ("SSManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (SSManager);
TypeId SSManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::SSManager")
.SetParent<Object> ();
return tid;
}
SSManager::SSManager (void)
{
m_ssRecords = new std::vector<SSRecord*> ();
}
SSManager::~SSManager (void)
{
for (std::vector<SSRecord*>::iterator iter = m_ssRecords->begin (); iter != m_ssRecords->end (); ++iter)
{
delete *iter;
}
delete m_ssRecords;
m_ssRecords = 0;
}
SSRecord*
SSManager::CreateSSRecord (const Mac48Address &macAddress)
{
SSRecord *ssRecord = new SSRecord (macAddress);
m_ssRecords->push_back (ssRecord);
return ssRecord;
}
SSRecord*
SSManager::GetSSRecord (const Mac48Address &macAddress) const
{
for (std::vector<SSRecord*>::iterator iter = m_ssRecords->begin (); iter != m_ssRecords->end (); ++iter)
{
if ((*iter)->GetMacAddress () == macAddress)
{
return *iter;
}
}
NS_LOG_DEBUG ("GetSSRecord: SSRecord not found!");
return 0;
}
SSRecord*
SSManager::GetSSRecord (Cid cid) const
{
for (std::vector<SSRecord*>::iterator iter1 = m_ssRecords->begin (); iter1 != m_ssRecords->end (); ++iter1)
{
SSRecord *ssRecord = *iter1;
if (ssRecord->GetBasicCid () == cid || ssRecord->GetPrimaryCid () == cid)
{
return ssRecord;
}
else
{
std::vector<ServiceFlow*> sf = ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_ALL);
for (std::vector<ServiceFlow*>::iterator iter2 = sf.begin (); iter2 != sf.end (); ++iter2)
{
if ((*iter2)->GetConnection ()->GetCid () == cid)
{
return ssRecord;
}
}
}
}
NS_LOG_DEBUG ("GetSSRecord: SSRecord not found!");
return 0;
}
std::vector<SSRecord*>*
SSManager::GetSSRecords (void) const
{
return m_ssRecords;
}
bool
SSManager::IsInRecord (const Mac48Address &macAddress) const
{
for (std::vector<SSRecord*>::iterator iter = m_ssRecords->begin (); iter != m_ssRecords->end (); ++iter)
{
if ((*iter)->GetMacAddress () == macAddress)
{
return true;
}
}
return false;
}
bool
SSManager::IsRegistered (const Mac48Address &macAddress) const
{
SSRecord *ssRecord = GetSSRecord (macAddress);
return ssRecord != 0 && ssRecord->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_SUCCESS;
}
void
SSManager::DeleteSSRecord (Cid cid)
{
for (std::vector<SSRecord*>::iterator iter1 = m_ssRecords->begin (); iter1 != m_ssRecords->end (); ++iter1)
{
SSRecord *ssRecord = *iter1;
if (ssRecord->GetBasicCid () == cid || ssRecord->GetPrimaryCid () == cid)
{
m_ssRecords->erase (iter1);
return;
}
else
{
std::vector<ServiceFlow*> sf = ssRecord->GetServiceFlows (ServiceFlow::SF_TYPE_ALL);
for (std::vector<ServiceFlow*>::const_iterator iter2 = sf.begin (); iter2 != sf.end (); ++iter2)
{
if ((*iter2)->GetConnection ()->GetCid () == cid)
{
m_ssRecords->erase (iter1);
return;
}
}
}
}
}
Mac48Address
SSManager::GetMacAddress (Cid cid) const
{
return GetSSRecord (cid)->GetMacAddress ();
}
uint32_t
SSManager::GetNSSs (void) const
{
return m_ssRecords->size ();
}
uint32_t
SSManager::GetNRegisteredSSs (void) const
{
uint32_t nrSS = 0;
for (std::vector<SSRecord*>::iterator iter = m_ssRecords->begin (); iter != m_ssRecords->end (); ++iter)
{
if ((*iter)->GetRangingStatus () == WimaxNetDevice::RANGING_STATUS_SUCCESS)
{
nrSS++;
}
}
return nrSS;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ss-manager.cc | C++ | gpl2 | 4,838 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "bs-link-manager.h"
#include <stdint.h>
#include "ns3/node.h"
#include "ns3/packet.h"
#include "ns3/simulator.h"
#include "ns3/log.h"
#include "burst-profile-manager.h"
#include "ss-record.h"
#include "ss-manager.h"
#include "bs-uplink-scheduler.h"
#include "connection-manager.h"
NS_LOG_COMPONENT_DEFINE ("BSLinkManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BSLinkManager);
TypeId BSLinkManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BSLinkManager")
.SetParent<Object> ();
return tid;
}
BSLinkManager::BSLinkManager (Ptr<BaseStationNetDevice> bs)
: m_bs (bs),
m_signalQuality (10),
m_signalQualityThreshold (10) // arbitrary value
{
tries = 0;
}
BSLinkManager::~BSLinkManager (void)
{
m_bs = 0;
}
uint8_t
BSLinkManager::CalculateRangingOppsToAllocate (void)
{
// randomly selecting TOs up to 10, shall actually be decided by scheduler
return rand () % 8 + 2;
}
/*
* Function mainly to avoid duplicate code in DoReceive ()
*/
void
BSLinkManager::ProcessRangingRequest (Cid cid, RngReq rngreq)
{
NS_ASSERT_MSG (m_bs->GetState () == BaseStationNetDevice::BS_STATE_UL_SUB_FRAME,
"Base station: Error while processing ranging request: !BS_STATE_UL_SUB_FRAME");
Time irIntervalBoundary = Seconds (0);
if (m_bs->GetUplinkScheduler ()->GetIsInvIrIntrvlAllocated ())
{
if (m_bs->GetUplinkScheduler ()->GetIsIrIntrvlAllocated ())
{
irIntervalBoundary = m_bs->GetUlSubframeStartTime ()
+ Seconds ((m_bs->GetUplinkScheduler ()->GetNrIrOppsAllocated () + 1) * m_bs->GetRangReqOppSize ()
* m_bs->GetSymbolDuration ().GetSeconds ());
}
else
{
irIntervalBoundary = m_bs->GetUlSubframeStartTime () + Seconds (m_bs->GetRangReqOppSize ()
* m_bs->GetSymbolDuration ().GetSeconds ());
}
}
else
{
NS_ASSERT_MSG (m_bs->GetUplinkScheduler ()->GetIsIrIntrvlAllocated (),
"Base station: Error while processing ranging request: IR interval not allocated");
irIntervalBoundary = m_bs->GetUlSubframeStartTime ()
+ Seconds (m_bs->GetUplinkScheduler ()->GetNrIrOppsAllocated () * m_bs->GetRangReqOppSize ()
* m_bs->GetSymbolDuration ().GetSeconds ());
}
tries++;
if (Simulator::Now () >= m_bs->GetUlSubframeStartTime () && Simulator::Now () < irIntervalBoundary)
{
PerformRanging (cid, rngreq);
}
}
void
BSLinkManager::PerformRanging (Cid cid, RngReq rngreq)
{
RngRsp rngrsp;
bool decodable = false;
// assuming low power, packet lost or undecodable first 2 times
if (tries < 2)
{
return;
}
if (tries >= 3)
{
decodable = true;
}
NS_LOG_DEBUG ("RNG-REQ:");
rngreq.PrintDebug ();
if (!decodable)
{
rngrsp.SetFrameNumber (m_bs->GetNrFrames ());
rngrsp.SetInitRangOppNumber (m_bs->GetRangingOppNumber ());
SetParametersToAdjust (&rngrsp);
rngrsp.SetRangStatus (WimaxNetDevice::RANGING_STATUS_CONTINUE); // see Figure 64
ScheduleRngRspMessage (cid, &rngrsp);
}
else
{
if (cid.IsInitialRanging ())
{
PerformInitialRanging (cid, &rngreq, &rngrsp);
}
else
{
// invited initial ranging or periodic ranging
PerformInvitedRanging (cid, &rngrsp);
}
}
}
void
BSLinkManager::PerformInitialRanging (Cid cid, RngReq *rngreq, RngRsp *rngrsp)
{
SSRecord *ssRecord = 0;
bool isOldSS = m_bs->GetSSManager ()->IsInRecord (rngreq->GetMacAddress ());
if (isOldSS)
{
ssRecord = m_bs->GetSSManager ()->GetSSRecord (rngreq->GetMacAddress ());
// if this fails it would mean the RNG-RSP with success status was not received by the SS
}
else
{
ssRecord = m_bs->GetSSManager ()->CreateSSRecord (rngreq->GetMacAddress ());
}
if (ChangeDlChannel ())
{
rngrsp->SetDlFreqOverride (GetNewDlChannel ());
AbortRanging (cid, rngrsp, ssRecord, isOldSS);
return;
}
if (isOldSS)
{
// CIDs already assigned, e.g., RNG-REQ was lost and resent after timeout. reusing old CIDs
ssRecord->ResetRangingCorrectionRetries ();
ssRecord->ResetInvitedRangingRetries ();
}
else
{
m_bs->GetConnectionManager ()->AllocateManagementConnections (ssRecord, rngrsp);
WimaxPhy::ModulationType modulationType;
uint8_t diuc = m_bs->GetBurstProfileManager ()->GetBurstProfileForSS (ssRecord, rngreq, modulationType);
ssRecord->SetModulationType (modulationType);
// specify in RNG-RSP only if different than what SS requested
if (rngreq->GetReqDlBurstProfile () != diuc)
{
rngrsp->SetDlOperBurstProfile (diuc);
}
// add SS (Basic CID) to poll list for invited ranging intervals, see Table 115
ssRecord->EnablePollForRanging ();
}
rngrsp->SetMacAddress (rngreq->GetMacAddress ());
if (isOldSS) // CIDs had already been allocated
{
cid = ssRecord->GetBasicCid ();
}
if (IsRangingAcceptable ())
{
AcceptRanging (cid, rngrsp, ssRecord);
}
else
{
ContinueRanging (cid, rngrsp, ssRecord);
}
}
void
BSLinkManager::PerformInvitedRanging (Cid cid, RngRsp *rngrsp)
{
SSRecord *ssRecord = m_bs->GetSSManager ()->GetSSRecord (cid);
ssRecord->IncrementRangingCorrectionRetries ();
ssRecord->ResetInvitedRangingRetries ();
if (IsRangingAcceptable ())
{
AcceptRanging (cid, rngrsp, ssRecord);
}
else
{
if (ssRecord->GetRangingCorrectionRetries () == m_bs->GetMaxRangingCorrectionRetries ())
{
AbortRanging (cid, rngrsp, ssRecord, true);
}
else
{
ContinueRanging (cid, rngrsp, ssRecord);
}
}
}
void
BSLinkManager::VerifyInvitedRanging (Cid cid, uint8_t uiuc)
{
if (uiuc == OfdmUlBurstProfile::UIUC_INITIAL_RANGING)
{
SSRecord *ssRecord = m_bs->GetSSManager ()->GetSSRecord (cid);
if (ssRecord->GetInvitedRangRetries () > 0)
{
ssRecord->IncrementInvitedRangingRetries ();
if (ssRecord->GetInvitedRangRetries () == m_bs->GetMaxInvitedRangRetries ())
{
RngRsp *rngrsp = new RngRsp ();
AbortRanging (ssRecord->GetBasicCid (), rngrsp, ssRecord, true);
} // else keep polling
}
}
}
void
BSLinkManager::SetParametersToAdjust (RngRsp *rngrsp)
{
// code to calculate parameter adjustment values goes here
rngrsp->SetTimingAdjust (40);
rngrsp->SetPowerLevelAdjust (8);
rngrsp->SetOffsetFreqAdjust (30);
}
void
BSLinkManager::AbortRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord, bool isOldSS)
{
rngrsp->SetRangStatus (WimaxNetDevice::RANGING_STATUS_ABORT);
ScheduleRngRspMessage (cid, rngrsp);
if (isOldSS)
{
ssRecord->SetRangingStatus (WimaxNetDevice::RANGING_STATUS_ABORT);
}
ssRecord->DisablePollForRanging ();
DeallocateCids (cid);
}
void
BSLinkManager::AcceptRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord)
{
rngrsp->SetRangStatus (WimaxNetDevice::RANGING_STATUS_SUCCESS);
ScheduleRngRspMessage (cid, rngrsp);
/*Shall not be set until the SS receives the RNG-RSP, as it may be lost etc. may be state field
is also added to SSRecord which then set to SS_STATE_REGISTERED once confirmed that SS has received
this RNG-RSP, but how to determine that, may be as a data packet is received by the SS*/
ssRecord->SetRangingStatus (WimaxNetDevice::RANGING_STATUS_SUCCESS);
ssRecord->DisablePollForRanging ();
}
void
BSLinkManager::ContinueRanging (Cid cid, RngRsp *rngrsp, SSRecord *ssRecord)
{
rngrsp->SetRangStatus (WimaxNetDevice::RANGING_STATUS_CONTINUE);
ScheduleRngRspMessage (cid, rngrsp);
ssRecord->SetRangingStatus (WimaxNetDevice::RANGING_STATUS_CONTINUE);
}
void
BSLinkManager::ScheduleRngRspMessage (Cid cid, RngRsp *rngrsp)
{
if (rngrsp->GetRangStatus () == WimaxNetDevice::RANGING_STATUS_SUCCESS || rngrsp->GetRangStatus ()
== WimaxNetDevice::RANGING_STATUS_CONTINUE)
{
SetParametersToAdjust (rngrsp);
}
Ptr<Packet> p = Create<Packet> ();
p->AddHeader (*rngrsp);
p->AddHeader (ManagementMessageType (ManagementMessageType::MESSAGE_TYPE_RNG_RSP));
m_bs->Enqueue (p, MacHeaderType (), m_bs->GetConnection (cid));
}
void
BSLinkManager::DeallocateCids (Cid cid)
{
// if necessary, delete entire connections or simply set CIDs to 0
}
uint64_t
BSLinkManager::SelectDlChannel (void)
{
// Values according to WirelessMAN-OFDM RF profile for 10 MHz channelization
// Section 12.3.3.1 from IEEE 802.16-2004 standard
// profR10_3 :
// channels: 5000 + n ⋅ 5 MHz, ∀n ∈ { 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167 }
// temporarily set to 1 for quick scanning. To be standard compliant, use a value in the list above
return m_bs->GetChannel (1);
}
bool
BSLinkManager::ChangeDlChannel (void)
{
// code to decide if SS shall move to a new channel/frequency goes here
return false;
}
uint32_t
BSLinkManager::GetNewDlChannel (void)
{
// code to determine suggested new frequency goes here
return 100;
}
uint8_t
BSLinkManager::GetSignalQuality (void)
{
// code to measure signal quality goes here
uint8_t signalQuality = m_signalQuality;
m_signalQuality++;
return signalQuality;
}
bool
BSLinkManager::IsRangingAcceptable (void)
{
return GetSignalQuality () > m_signalQualityThreshold;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-link-manager.cc | C++ | gpl2 | 10,535 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 INRIA
* 2009 TELEMATICS LAB, Politecnico di Bari
*
* 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: Giuseppe Piro <g.piro@poliba.it>
*/
#include "bs-scheduler-rtps.h"
#include "ns3/simulator.h"
#include "bs-net-device.h"
#include "ns3/packet-burst.h"
#include "cid.h"
#include "wimax-mac-header.h"
#include "ss-record.h"
#include "wimax-mac-queue.h"
#include "ns3/log.h"
#include "burst-profile-manager.h"
#include "wimax-connection.h"
#include "connection-manager.h"
#include "ss-manager.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
#include "wimax-mac-queue.h"
NS_LOG_COMPONENT_DEFINE ("BSSchedulerRtps");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (BSSchedulerRtps);
TypeId
BSSchedulerRtps::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::BSSchedulerRtps").SetParent<Object> ().AddConstructor<BSSchedulerRtps> ();
return tid;
}
BSSchedulerRtps::BSSchedulerRtps ()
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
SetBs (0);
}
BSSchedulerRtps::BSSchedulerRtps (Ptr<BaseStationNetDevice> bs)
: m_downlinkBursts (new std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > ())
{
// m_downlinkBursts is filled by AddDownlinkBurst and emptied by
// wimax-bs-net-device::sendBurst and wimax-ss-net-device::sendBurst
SetBs (bs);
}
BSSchedulerRtps::~BSSchedulerRtps (void)
{
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > > *downlinkBursts = m_downlinkBursts;
std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > pair;
while (downlinkBursts->size ())
{
pair = downlinkBursts->front ();
pair.second = 0;
delete pair.first;
}
SetBs (0);
delete m_downlinkBursts;
m_downlinkBursts = 0;
}
std::list<std::pair<OfdmDlMapIe*, Ptr<PacketBurst> > >*
BSSchedulerRtps::GetDownlinkBursts (void) const
{
return m_downlinkBursts;
}
void
BSSchedulerRtps::AddDownlinkBurst (Ptr<const WimaxConnection> connection,
uint8_t diuc,
WimaxPhy::ModulationType modulationType,
Ptr<PacketBurst> burst)
{
OfdmDlMapIe *dlMapIe = new OfdmDlMapIe ();
dlMapIe->SetCid (connection->GetCid ());
dlMapIe->SetDiuc (diuc);
NS_LOG_INFO ("BS scheduler, burst size: " << burst->GetSize () << " bytes" << ", pkts: " << burst->GetNPackets ()
<< ", connection: " << connection->GetTypeStr () << ", CID: "
<< connection->GetCid ());
if (connection->GetType () == Cid::TRANSPORT)
{
NS_LOG_INFO (", SFID: " << connection->GetServiceFlow ()->GetSfid () << ", service: "
<< connection->GetServiceFlow ()->GetSchedulingTypeStr ());
}
NS_LOG_INFO (", modulation: " << modulationType << ", DIUC: " << (uint32_t) diuc);
m_downlinkBursts->push_back (std::make_pair (dlMapIe, burst));
}
void
BSSchedulerRtps::Schedule (void)
{
/**
* \brief A DownLink Scheduler for rtPS Flows
*
* The DL Scheduler assigns the available bandwidth in the following order:
* - IR Connections
* - Broadcast Connections
* - Basic and Primary Connections
* - UGS Connections
* - rtPS Connections
* - nrtPS Connections
* - BE Connections
* All rtPS flows that have packets in the queue can transmit at least one
* packet, according to the available bandwidth.
*/
uint32_t availableSymbols = GetBs ()->GetNrDlSymbols ();
BSSchedulerBroadcastConnection (availableSymbols);
BSSchedulerInitialRangingConnection (availableSymbols);
BSSchedulerBasicConnection (availableSymbols);
BSSchedulerPrimaryConnection (availableSymbols);
BSSchedulerUGSConnection (availableSymbols);
BSSchedulerRTPSConnection (availableSymbols);
BSSchedulerNRTPSConnection (availableSymbols);
BSSchedulerBEConnection (availableSymbols);
if (m_downlinkBursts->size ())
{
NS_LOG_DEBUG ("BS scheduler, number of bursts: " << m_downlinkBursts->size () << ", symbols left: "
<< availableSymbols << std::endl << "BS scheduler, queues:" << " IR "
<< GetBs ()->GetInitialRangingConnection ()->GetQueue ()->GetSize ()
<< " broadcast "
<< GetBs ()->GetBroadcastConnection ()->GetQueue ()->GetSize ()
<< " basic "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::BASIC, ServiceFlow::SF_TYPE_NONE)
<< " primary "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::PRIMARY, ServiceFlow::SF_TYPE_NONE)
<< " transport "
<< GetBs ()->GetConnectionManager ()->GetNPackets (Cid::TRANSPORT, ServiceFlow::SF_TYPE_ALL));
}
}
Ptr<PacketBurst> BSSchedulerRtps::CreateUgsBurst (ServiceFlow *serviceFlow,
WimaxPhy::ModulationType modulationType,
uint32_t availableSymbols)
{
Time timeStamp;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
uint32_t nrSymbolsRequired = 0;
// serviceFlow->CleanUpQueue ();
Ptr<WimaxConnection> connection = serviceFlow->GetConnection ();
while (serviceFlow->HasPackets ())
{
uint32_t FirstPacketSize = connection->GetQueue ()->GetFirstPacketRequiredByte (MacHeaderType::HEADER_TYPE_GENERIC);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (FirstPacketSize,modulationType);
if (availableSymbols < nrSymbolsRequired && CheckForFragmentation (connection,
availableSymbols,
modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
availableSymbols = 0;
}
else
{
packet = connection->Dequeue ();
availableSymbols -= nrSymbolsRequired;
}
burst->AddPacket (packet);
if (availableSymbols <= 0)
{
break;
}
}
return burst;
}
bool
BSSchedulerRtps::SelectConnection (Ptr<WimaxConnection> &connection)
{
return false;
}
void
BSSchedulerRtps::BSSchedulerBroadcastConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
while (GetBs ()->GetBroadcastConnection ()->HasPackets () && availableSymbols > 0)
{
connection = GetBs ()->GetBroadcastConnection ();
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
if (availableSymbols < nrSymbolsRequired
&& !CheckForFragmentation (connection, availableSymbols, modulationType))
{
break;
}
else if (availableSymbols < nrSymbolsRequired
&& CheckForFragmentation (connection, availableSymbols, modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC,
availableByte);
}
else
{
packet = connection->Dequeue ();
}
NS_ASSERT_MSG (hdr.GetCid ().GetIdentifier () == connection->GetCid (),
"Base station: Error while scheduling broadcast connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
}
}
void
BSSchedulerRtps::BSSchedulerInitialRangingConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
while (GetBs ()->GetInitialRangingConnection ()->HasPackets () && availableSymbols > 0)
{
connection = GetBs ()->GetInitialRangingConnection ();
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
// PIRO: check for fragmentation
if (availableSymbols < nrSymbolsRequired
&& !CheckForFragmentation (connection, availableSymbols, modulationType))
{
break;
}
else if (availableSymbols < nrSymbolsRequired
&& CheckForFragmentation (connection, availableSymbols, modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC,
availableByte);
}
else
{
packet = connection->Dequeue ();
}
NS_ASSERT_MSG (hdr.GetCid () == connection->GetCid (),
"Base station: Error while scheduling initial ranging connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets ())
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
}
}
void
BSSchedulerRtps::BSSchedulerBasicConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = OfdmDlBurstProfile::DIUC_BURST_PROFILE_1;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
std::vector<Ptr<WimaxConnection> >::const_iterator iter;
std::vector<Ptr<WimaxConnection> > connections;
connections = GetBs ()->GetConnectionManager ()->GetConnections (Cid::BASIC);
for (iter = connections.begin (); iter != connections.end (); ++iter)
{
while ((*iter)->HasPackets () && availableSymbols > 0)
{
connection = *iter;
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
// PIRO: check for fragmentation
if (availableSymbols < nrSymbolsRequired
&& !CheckForFragmentation (connection, availableSymbols, modulationType))
{
break;
}
else if (availableSymbols < nrSymbolsRequired
&& CheckForFragmentation (connection, availableSymbols, modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
}
else
{
packet = connection->Dequeue ();
}
NS_ASSERT_MSG (hdr.GetCid () == connection->GetCid (),
"Base station: Error while scheduling basic connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
burst = Create<PacketBurst> ();
}
}
}
void
BSSchedulerRtps::BSSchedulerPrimaryConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = 0;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
std::vector<Ptr<WimaxConnection> >::const_iterator iter;
std::vector<Ptr<WimaxConnection> > connections;
connections = GetBs ()->GetConnectionManager ()->GetConnections (Cid::PRIMARY);
for (iter = connections.begin (); iter != connections.end (); ++iter)
{
while ((*iter)->HasPackets () && availableSymbols > 0)
{
connection = *iter;
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
// PIRO: check for fragmentation
if (availableSymbols < nrSymbolsRequired
&& !CheckForFragmentation (connection, availableSymbols, modulationType))
{
break;
}
else if (availableSymbols < nrSymbolsRequired
&& CheckForFragmentation (connection, availableSymbols, modulationType))
{
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (availableSymbols, modulationType);
packet = connection->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
}
else
{
packet = connection->Dequeue ();
}
NS_ASSERT_MSG (hdr.GetCid () == connection->GetCid (),
"Base station: Error while scheduling primary connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
}
}
}
void
BSSchedulerRtps::BSSchedulerUGSConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
Time currentTime = Simulator::Now ();
std::vector<ServiceFlow*>::iterator iter;
ServiceFlowRecord *serviceFlowRecord;
std::vector<ServiceFlow*> serviceFlows;
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_UGS);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
serviceFlowRecord = (*iter)->GetRecord ();
// if latency would exceed in case grant is allocated in next frame then allocate in current frame
if ((*iter)->HasPackets () && ((currentTime - serviceFlowRecord->GetDlTimeStamp ())
+ GetBs ()->GetPhy ()->GetFrameDuration ()) > MilliSeconds ((*iter)->GetMaximumLatency ()))
{
connection = (*iter)->GetConnection ();
if (connection->GetType () == Cid::MULTICAST)
{
modulationType = connection->GetServiceFlow ()->GetModulation ();
}
else
{
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
}
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
nrSymbolsRequired = connection->GetServiceFlow ()->GetRecord ()->GetGrantSize ();
// Packet fragmentation for UGS connections has not been implemented yet!
if (availableSymbols > nrSymbolsRequired)
{
availableSymbols -= nrSymbolsRequired;
burst = CreateUgsBurst (connection->GetServiceFlow (), modulationType, nrSymbolsRequired);
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
currentTime = Simulator::Now ();
serviceFlowRecord->SetDlTimeStamp (currentTime);
burst = Create<PacketBurst> ();
}
}
}
}
}
void
BSSchedulerRtps::BSSchedulerRTPSConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
Time currentTime = Simulator::Now ();
std::vector<Ptr<WimaxConnection> >::const_iterator iter;
std::vector<Ptr<WimaxConnection> > connections;
std::vector<ServiceFlow*>::iterator iter2;
ServiceFlowRecord *serviceFlowRecord;
std::vector<ServiceFlow*> serviceFlows;
std::deque<WimaxMacQueue::QueueElement>::const_iterator iter3;
uint32_t symbolsRequired[100];
WimaxPhy::ModulationType modulationType_[100];
uint8_t diuc_[100];
Ptr<WimaxConnection> rtPSConnection[100];
uint32_t dataToSend;
uint32_t totSymbolsRequired = 0;
int nbConnection = 0;
NS_LOG_INFO ("\tDL Scheduler for rtPS flows \n" << "\t\tavailableSymbols = " << availableSymbols);
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_RTPS);
nbConnection = 0;
for (iter2 = serviceFlows.begin (); iter2 != serviceFlows.end (); ++iter2)
{
// DL RTPS Scheduler works for all rtPS connection that have packets to transmitt!!!
serviceFlowRecord = (*iter2)->GetRecord ();
if ((*iter2)->HasPackets ())
{
currentTime = Simulator::Now ();
serviceFlowRecord->SetDlTimeStamp (currentTime);
rtPSConnection[nbConnection] = (*iter2)->GetConnection ();
if (rtPSConnection[nbConnection]->GetType () == Cid::MULTICAST)
{
modulationType_[nbConnection] = rtPSConnection[nbConnection]->GetServiceFlow ()->GetModulation ();
}
else
{
modulationType_[nbConnection]
= GetBs ()->GetSSManager ()->GetSSRecord (rtPSConnection[nbConnection]->GetCid ())->GetModulationType ();
}
diuc_[nbConnection]
= GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType_[nbConnection],
WimaxNetDevice::DIRECTION_DOWNLINK);
dataToSend = rtPSConnection[nbConnection]->GetQueue ()->GetQueueLengthWithMACOverhead ();
NS_LOG_INFO ("\t\tRTPS DL Scheduler for CID = " << rtPSConnection[nbConnection]->GetCid ()
<< "\n\t\t\t dataToSend = " << dataToSend);
symbolsRequired[nbConnection] = GetBs ()->GetPhy ()->GetNrSymbols (dataToSend,
modulationType_[nbConnection]);
totSymbolsRequired += symbolsRequired[nbConnection];
nbConnection++;
}
}
NS_LOG_INFO ("\t\ttotSymbolsRequired = " << totSymbolsRequired);
// Channel Saturation
while (totSymbolsRequired > availableSymbols)
{
NS_LOG_INFO ("\tDL Channel Saturation: totSymbolsRequired > availableSymbols_rtPS");
double delta = double(availableSymbols) / double(totSymbolsRequired);
NS_LOG_INFO ("\t\tdelta = " << delta);
totSymbolsRequired = 0;
for (int i = 0; i < nbConnection; i++)
{
NS_LOG_INFO ("\t\tprevious symbolsRequired[" << i << "] = " << symbolsRequired[i]);
symbolsRequired[i] = (uint32_t) floor (symbolsRequired[i] * delta);
totSymbolsRequired += symbolsRequired[i];
NS_LOG_INFO ("\t\tnew symbolsRequired[" << i << "] = " << symbolsRequired[i]);
}
NS_LOG_INFO ("\t\ttotSymbolsRequired = " << totSymbolsRequired);
}
// Downlink Bandwidth Allocation
for (int i = 0; i < nbConnection; i++)
{
packet = rtPSConnection[i]->GetQueue ()->Peek (hdr);
uint32_t symbolsForPacketTransmission = 0;
burst = Create<PacketBurst> ();
NS_LOG_INFO ("\t\tCID = " << rtPSConnection[i]->GetCid () << " assignedSymbols = " << symbolsRequired[i]);
while (symbolsRequired[i] > 0)
{
symbolsForPacketTransmission = GetBs ()->GetPhy ()
->GetNrSymbols (rtPSConnection[i]->GetQueue ()
->GetFirstPacketRequiredByte (MacHeaderType::HEADER_TYPE_GENERIC),
modulationType_[i]);
// PIRO: check for fragmentation
if (symbolsForPacketTransmission > symbolsRequired[i]
&& !CheckForFragmentation (rtPSConnection[i],
symbolsRequired[i],
modulationType_[i]))
{
break;
}
else if (symbolsForPacketTransmission > symbolsRequired[i]
&& CheckForFragmentation (rtPSConnection[i],
symbolsRequired[i],
modulationType_[i]))
{
uint32_t availableByte = GetBs ()->GetPhy ()->
GetNrBytes (symbolsRequired[i], modulationType_[i]);
packet = rtPSConnection[i]->Dequeue (MacHeaderType::HEADER_TYPE_GENERIC, availableByte);
symbolsRequired[i] = 0;
}
else
{
packet = rtPSConnection[i]->Dequeue ();
symbolsRequired[i] -= symbolsForPacketTransmission;
}
NS_ASSERT_MSG (hdr.GetCid () == rtPSConnection[i]->GetCid (),
"Base station: Error while scheduling RTPs connection: header CID != connection CID");
burst->AddPacket (packet);
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (rtPSConnection[i], diuc_[i], modulationType_[i], burst);
}
}
availableSymbols -= totSymbolsRequired;
}
void
BSSchedulerRtps::BSSchedulerNRTPSConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = 0;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
std::vector<ServiceFlow*>::iterator iter;
std::vector<ServiceFlow*> serviceFlows;
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_NRTPS);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
connection = (*iter)->GetConnection ();
while ((*iter)->HasPackets () && availableSymbols > 0)
{
if (connection->GetType () == Cid::MULTICAST)
{
modulationType = connection->GetServiceFlow ()->GetModulation ();
}
else
{
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
}
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
if (availableSymbols < nrSymbolsRequired)
{
break;
}
packet = connection->Dequeue ();
NS_ASSERT_MSG (hdr.GetCid () == connection->GetCid (),
"Base station: Error while scheduling NRTPs connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
burst = Create<PacketBurst> ();
}
}
}
void
BSSchedulerRtps::BSSchedulerBEConnection (uint32_t &availableSymbols)
{
Ptr<WimaxConnection> connection;
WimaxPhy::ModulationType modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
uint8_t diuc = 0;
uint32_t nrSymbolsRequired = 0;
GenericMacHeader hdr;
Ptr<Packet> packet;
Ptr<PacketBurst> burst = Create<PacketBurst> ();
std::vector<ServiceFlow*>::iterator iter;
std::vector<ServiceFlow*> serviceFlows;
serviceFlows = GetBs ()->GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_BE);
for (iter = serviceFlows.begin (); iter != serviceFlows.end (); ++iter)
{
connection = (*iter)->GetConnection ();
while ((*iter)->HasPackets () && availableSymbols > 0)
{
if (connection->GetType () == Cid::MULTICAST)
{
modulationType = connection->GetServiceFlow ()->GetModulation ();
}
else
{
modulationType = GetBs ()->GetSSManager ()->GetSSRecord (connection->GetCid ())->GetModulationType ();
}
diuc = GetBs ()->GetBurstProfileManager ()->GetBurstProfile (modulationType,
WimaxNetDevice::DIRECTION_DOWNLINK);
packet = connection->GetQueue ()->Peek (hdr);
nrSymbolsRequired = GetBs ()->GetPhy ()->GetNrSymbols (packet->GetSize (), modulationType);
if (availableSymbols < nrSymbolsRequired)
{
break;
}
packet = connection->Dequeue ();
NS_ASSERT_MSG (hdr.GetCid () == connection->GetCid (),
"Base station: Error while scheduling BE connection: header CID != connection CID");
burst->AddPacket (packet);
availableSymbols -= nrSymbolsRequired;
}
if (burst->GetNPackets () != 0)
{
AddDownlinkBurst (connection, diuc, modulationType, burst);
burst = Create<PacketBurst> ();
}
}
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/bs-scheduler-rtps.cc | C++ | gpl2 | 27,884 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#include "wimax-tlv.h"
NS_LOG_COMPONENT_DEFINE ("Tlv");
namespace ns3 {
// NS_OBJECT_ENSURE_REGISTERED ("Tlv");
TypeId Tlv::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void Tlv::Print (std::ostream &os) const
{
os << "TLV type = " << (uint32_t) m_type << " TLV Length = " << (uint64_t) m_length;
}
Tlv::Tlv (uint8_t type, uint64_t length, const TlvValue & value)
{
m_type = type;
m_length = length;
m_value = value.Copy ();
}
Tlv::Tlv ()
{
m_type = 0;
m_length = 0;
m_value = 0;
}
Tlv::~Tlv ()
{
if (m_value != 0)
{
delete m_value;
m_value = 0;
}
}
TlvValue *
Tlv::CopyValue (void) const
{
return m_value->Copy ();
}
Tlv::Tlv (const Tlv & tlv)
{
m_type = tlv.GetType ();
m_length = tlv.GetLength ();
m_value = tlv.CopyValue ();
}
Tlv &
Tlv::operator = (Tlv const& o)
{
if (m_value != 0)
{
delete m_value;
}
m_type = o.GetType ();
m_length = o.GetLength ();
m_value = o.CopyValue ();
return *this;
}
uint32_t
Tlv::GetSerializedSize (void) const
{
return 1 + GetSizeOfLen () + m_value->GetSerializedSize ();
}
uint8_t
Tlv::GetSizeOfLen (void) const
{
uint8_t sizeOfLen = 1;
if (m_length > 127)
{
sizeOfLen = 2;
uint64_t testValue = 0xFF;
while (m_length > testValue)
{
sizeOfLen++;
testValue *= 0xFF;
}
}
return sizeOfLen;
}
void
Tlv::Serialize (Buffer::Iterator i) const
{
i.WriteU8 (m_type);
uint8_t lenSize = GetSizeOfLen ();
if (lenSize == 1)
{
i.WriteU8 (m_length);
}
else
{
i.WriteU8 ((lenSize-1) | WIMAX_TLV_EXTENDED_LENGTH_MASK);
for (int j = 0; j < lenSize - 1; j++)
{
i.WriteU8 ((uint8_t)(m_length >> ((lenSize - 1 - 1 - j) * 8)));
}
}
m_value->Serialize (i);
}
uint32_t
Tlv::Deserialize (Buffer::Iterator i)
{
// read the type of tlv
m_type = i.ReadU8 ();
// read the length
uint8_t lenSize = i.ReadU8 ();
uint32_t serializedSize = 2;
if (lenSize < 127)
{
m_length = lenSize;
}
else
{
lenSize &= ~WIMAX_TLV_EXTENDED_LENGTH_MASK;
for (int j = 0; j < lenSize; j++)
{
m_length <<= 8;
m_length |= i.ReadU8 ();
serializedSize++;
}
}
switch (m_type)
{
case HMAC_TUPLE:
// TODO: implement Deserialize HMAC_TUPLE
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
case MAC_VERSION_ENCODING:
// TODO: implement Deserialize MAC_VERSION_ENCODING
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
case CURRENT_TRANSMIT_POWER:
// TODO: implement Deserialize CURRENT_TRANSMIT_POWER
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
case DOWNLINK_SERVICE_FLOW:
{
SfVectorTlvValue val;
serializedSize += val.Deserialize (i, m_length);
m_value = val.Copy ();
break;
}
case UPLINK_SERVICE_FLOW:
{
SfVectorTlvValue val;
serializedSize += val.Deserialize (i, m_length);
m_value = val.Copy ();
break;
}
case VENDOR_ID_EMCODING:
// TODO: implement Deserialize VENDOR_ID_EMCODING
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
case VENDOR_SPECIFIC_INFORMATION:
// TODO: implement Deserialize VENDOR_SPECIFIC_INFORMATION
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
default:
NS_ASSERT_MSG (false, "Unknown tlv type.");
break;
}
return serializedSize;
}
uint8_t
Tlv::GetType (void) const
{
return m_type;
}
uint64_t
Tlv::GetLength (void) const
{
return m_length;
}
TlvValue*
Tlv::PeekValue (void)
{
return m_value;
}
Tlv *
Tlv::Copy (void) const
{
return new Tlv (m_type, m_length, *m_value);
}
// ==============================================================================
VectorTlvValue::VectorTlvValue ()
{
m_tlvList = new std::vector<Tlv*>;
}
VectorTlvValue::~VectorTlvValue ()
{
for (std::vector<Tlv*>::const_iterator iter = m_tlvList->begin (); iter != m_tlvList->end (); ++iter)
{
delete (*iter);
}
m_tlvList->clear ();
delete m_tlvList;
}
uint32_t
VectorTlvValue::GetSerializedSize (void) const
{
uint32_t size = 0;
for (std::vector<Tlv*>::const_iterator iter = m_tlvList->begin (); iter != m_tlvList->end (); ++iter)
{
size += (*iter)->GetSerializedSize ();
}
return size;
}
void
VectorTlvValue::Serialize (Buffer::Iterator i) const
{
for (std::vector<Tlv*>::const_iterator iter = m_tlvList->begin (); iter != m_tlvList->end (); ++iter)
{
(*iter)->Serialize (i);
i.Next ((*iter)->GetSerializedSize ());
}
}
VectorTlvValue::Iterator
VectorTlvValue::Begin () const
{
return m_tlvList->begin ();
}
VectorTlvValue::Iterator
VectorTlvValue::End () const
{
return m_tlvList->end ();
}
void
VectorTlvValue::Add (const Tlv & val)
{
m_tlvList->push_back (val.Copy ());
}
// ==============================================================================
SfVectorTlvValue::SfVectorTlvValue ()
{
}
SfVectorTlvValue *
SfVectorTlvValue::Copy (void) const
{
SfVectorTlvValue * tmp = new SfVectorTlvValue ();
for (std::vector<Tlv*>::const_iterator iter = Begin (); iter != End (); ++iter)
{
tmp->Add (Tlv ((*iter)->GetType (), (*iter)->GetLength (), *(*iter)->PeekValue ()));
}
return tmp;
}
uint32_t
SfVectorTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLen)
{
uint64_t serializedSize = 0;
while (serializedSize < valueLen)
{
uint8_t type = i.ReadU8 ();
// read the length
uint8_t lenSize = i.ReadU8 ();
serializedSize += 2;
uint64_t length = 0;
if (lenSize < 127)
{
length = lenSize;
}
else
{
lenSize &= ~WIMAX_TLV_EXTENDED_LENGTH_MASK;
for (int j = 0; j < lenSize; j++)
{
length <<= 8;
length |= i.ReadU8 ();
serializedSize++;
}
}
switch (type)
{
case SFID:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (SFID, 4, val));
break;
}
case CID:
{
U16TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (CID, 2, val));
break;
}
case Service_Class_Name:
NS_FATAL_ERROR ("Not implemented-- please implement and contribute a patch");
break;
case reserved1:
// NOTHING
break;
case QoS_Parameter_Set_Type:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (QoS_Parameter_Set_Type, 1, val));
break;
}
case Traffic_Priority:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Traffic_Priority, 1, val));
break;
}
case Maximum_Sustained_Traffic_Rate:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Maximum_Sustained_Traffic_Rate, 4, val));
break;
}
case Maximum_Traffic_Burst:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Maximum_Traffic_Burst, 4, val));
break;
}
case Minimum_Reserved_Traffic_Rate:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Minimum_Reserved_Traffic_Rate, 4, val));
break;
}
case Minimum_Tolerable_Traffic_Rate:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Minimum_Tolerable_Traffic_Rate, 4, val));
break;
}
case Service_Flow_Scheduling_Type:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Service_Flow_Scheduling_Type, 1, val));
break;
}
case Request_Transmission_Policy:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Request_Transmission_Policy, 4, val));
break;
}
case Tolerated_Jitter:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Tolerated_Jitter, 4, val));
break;
}
case Maximum_Latency:
{
U32TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Maximum_Latency, 4, val));
break;
}
case Fixed_length_versus_Variable_length_SDU_Indicator:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Fixed_length_versus_Variable_length_SDU_Indicator, 1, val));
break;
}
case SDU_Size:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (SDU_Size, 1, val));
break;
}
case Target_SAID:
{
U16TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Target_SAID, 2, val));
break;
}
case ARQ_Enable:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (ARQ_Enable, 1, val));
break;
}
case ARQ_WINDOW_SIZE:
{
U16TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (ARQ_WINDOW_SIZE, 2, val));
break;
}
case ARQ_RETRY_TIMEOUT_Transmitter_Delay:
break;
case ARQ_RETRY_TIMEOUT_Receiver_Delay:
break;
case ARQ_BLOCK_LIFETIME:
break;
case ARQ_SYNC_LOSS:
break;
case ARQ_DELIVER_IN_ORDER:
break;
case ARQ_PURGE_TIMEOUT:
break;
case ARQ_BLOCK_SIZE:
break;
case reserved2:
break;
case CS_Specification:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (CS_Specification, 1, val));
break;
}
case IPV4_CS_Parameters:
{
CsParamVectorTlvValue val;
uint32_t size = val.Deserialize (i, length);
serializedSize += size;
Add (Tlv (IPV4_CS_Parameters, size, val));
break;
}
default:
NS_ASSERT_MSG (false, "Unknown tlv type.");
break;
}
i.Next (length);
}
return serializedSize;
}
// ==============================================================================
U8TlvValue::U8TlvValue (uint8_t value)
{
m_value = value;
}
U8TlvValue::U8TlvValue ()
{
m_value = 0;
}
U8TlvValue::~U8TlvValue ()
{
}
uint32_t
U8TlvValue::GetSerializedSize (void) const
{
return 1;
}
void
U8TlvValue::Serialize (Buffer::Iterator i) const
{
i.WriteU8 (m_value);
}
uint32_t
U8TlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLen)
{
return Deserialize (i);
}
uint32_t
U8TlvValue::Deserialize (Buffer::Iterator i)
{
m_value = i.ReadU8 ();
return 1;
}
uint8_t
U8TlvValue::GetValue (void) const
{
return m_value;
}
U8TlvValue *
U8TlvValue::Copy (void) const
{
U8TlvValue * tmp = new U8TlvValue (m_value);
return tmp;
}
// ==============================================================================
U16TlvValue::U16TlvValue (uint16_t value)
{
m_value = value;
}
U16TlvValue::U16TlvValue ()
{
m_value = 0;
}
U16TlvValue::~U16TlvValue (void)
{
}
uint32_t
U16TlvValue::GetSerializedSize (void) const
{
return 2;
}
void
U16TlvValue::Serialize (Buffer::Iterator i) const
{
i.WriteHtonU16 (m_value);
}
uint32_t
U16TlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLen)
{
return Deserialize (i);
}
uint32_t
U16TlvValue::Deserialize (Buffer::Iterator i)
{
m_value = i.ReadNtohU16 ();
return 2;
}
uint16_t
U16TlvValue::GetValue (void) const
{
return m_value;
}
U16TlvValue *
U16TlvValue::Copy (void) const
{
U16TlvValue * tmp = new U16TlvValue (m_value);
return tmp;
}
// ==============================================================================
U32TlvValue::U32TlvValue (uint32_t value)
{
m_value = value;
}
U32TlvValue::U32TlvValue ()
{
m_value = 0;
}
U32TlvValue::~U32TlvValue (void)
{
}
uint32_t U32TlvValue::GetSerializedSize (void) const
{
return 4;
}
void
U32TlvValue::Serialize (Buffer::Iterator i) const
{
i.WriteHtonU32 (m_value);
}
uint32_t
U32TlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLen)
{
return Deserialize (i);
}
uint32_t
U32TlvValue::Deserialize (Buffer::Iterator i)
{
m_value = i.ReadNtohU32 ();
return 4;
}
uint32_t
U32TlvValue::GetValue (void) const
{
return m_value;
}
U32TlvValue *
U32TlvValue::Copy (void) const
{
U32TlvValue * tmp = new U32TlvValue (m_value);
return tmp;
}
// ==============================================================================
uint32_t
CsParamVectorTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
uint64_t serializedSize = 0;
uint8_t lenSize = 0;
uint8_t type = 0;
while (serializedSize < valueLength)
{
type = i.ReadU8 ();
// read the length
lenSize = i.ReadU8 ();
serializedSize += 2;
uint64_t length = 0;
if (lenSize < 127)
{
length = lenSize;
}
else
{
lenSize &= ~WIMAX_TLV_EXTENDED_LENGTH_MASK;
for (int j = 0; j < lenSize; j++)
{
length <<= 8;
length |= i.ReadU8 ();
serializedSize++;
}
}
switch (type)
{
case Classifier_DSC_Action:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Classifier_DSC_Action, 1, val));
break;
}
case Packet_Classification_Rule:
{
ClassificationRuleVectorTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (Packet_Classification_Rule, val.GetSerializedSize (), val));
break;
}
}
i.Next (length);
}
return serializedSize;
}
CsParamVectorTlvValue::CsParamVectorTlvValue ()
{
}
CsParamVectorTlvValue *
CsParamVectorTlvValue::Copy (void) const
{
CsParamVectorTlvValue * tmp = new CsParamVectorTlvValue ();
for (std::vector<Tlv*>::const_iterator iter = Begin (); iter != End (); ++iter)
{
tmp->Add (Tlv ((*iter)->GetType (), (*iter)->GetLength (), *(*iter)->PeekValue ()));
}
return tmp;
}
// ==============================================================================
ClassificationRuleVectorTlvValue::ClassificationRuleVectorTlvValue ()
{
}
ClassificationRuleVectorTlvValue *
ClassificationRuleVectorTlvValue::Copy (void) const
{
ClassificationRuleVectorTlvValue * tmp = new ClassificationRuleVectorTlvValue ();
for (std::vector<Tlv*>::const_iterator iter = Begin (); iter != End (); ++iter)
{
tmp->Add (Tlv ((*iter)->GetType (), (*iter)->GetLength (), *(*iter)->PeekValue ()));
}
return tmp;
}
uint32_t
ClassificationRuleVectorTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
uint64_t serializedSize = 0;
uint8_t lenSize = 0;
uint8_t type = 0;
while (serializedSize < valueLength)
{
type = i.ReadU8 ();
// read the length
lenSize = i.ReadU8 ();
serializedSize += 2;
uint64_t length = 0;
if (lenSize < 127)
{
length = lenSize;
}
else
{
lenSize &= ~WIMAX_TLV_EXTENDED_LENGTH_MASK;
for (int j = 0; j < lenSize; j++)
{
length <<= 8;
length |= i.ReadU8 ();
serializedSize++;
}
}
switch (type)
{
case Priority:
{
U8TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Priority, 1, val));
break;
}
case ToS:
{
TosTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (ToS, val.GetSerializedSize (), val));
break;
}
case Protocol:
{
ProtocolTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (Protocol, val.GetSerializedSize (), val));
break;
}
case IP_src:
{
Ipv4AddressTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (IP_src, val.GetSerializedSize (), val));
break;
}
case IP_dst:
{
Ipv4AddressTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (IP_dst, val.GetSerializedSize (), val));
break;
}
case Port_src:
{
PortRangeTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (Port_src, val.GetSerializedSize (), val));
break;
}
case Port_dst:
{
PortRangeTlvValue val;
serializedSize += val.Deserialize (i, length);
Add (Tlv (Port_dst, val.GetSerializedSize (), val));
break;
}
case Index:
{
U16TlvValue val;
serializedSize += val.Deserialize (i);
Add (Tlv (Index, 2, val));
break;
}
}
i.Next (length);
}
return serializedSize;
}
// ==============================================================================
TosTlvValue::TosTlvValue ()
{
m_low = 0;
m_high = 0;
m_mask = 0;
}
TosTlvValue::TosTlvValue (uint8_t low, uint8_t high, uint8_t mask)
{
m_low = low;
m_high = high;
m_mask = mask;
}
TosTlvValue::~TosTlvValue ()
{
}
uint32_t
TosTlvValue::GetSerializedSize (void) const
{
return 3;
}
void
TosTlvValue::Serialize (Buffer::Iterator i) const
{
i.WriteU8 (m_low);
i.WriteU8 (m_high);
i.WriteU8 (m_mask);
}
uint32_t
TosTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
m_low = i.ReadU8 ();
m_high = i.ReadU8 ();
m_mask = i.ReadU8 ();
return 3;
}
uint8_t
TosTlvValue::GetLow (void) const
{
return m_low;
}
uint8_t
TosTlvValue::GetHigh (void) const
{
return m_high;
}
uint8_t
TosTlvValue::GetMask (void) const
{
return m_mask;
}
TosTlvValue *
TosTlvValue::Copy (void) const
{
return new TosTlvValue (m_low, m_high, m_mask);
}
// ==============================================================================
PortRangeTlvValue::PortRangeTlvValue ()
{
m_portRange = new std::vector<struct PortRange>;
}
PortRangeTlvValue::~PortRangeTlvValue ()
{
m_portRange->clear ();
delete m_portRange;
}
uint32_t
PortRangeTlvValue::GetSerializedSize (void) const
{
return m_portRange->size () * sizeof(struct PortRange);
}
void
PortRangeTlvValue::Serialize (Buffer::Iterator i) const
{
for (std::vector<struct PortRange>::const_iterator iter = m_portRange->begin (); iter != m_portRange->end (); ++iter)
{
i.WriteHtonU16 ((*iter).PortLow);
i.WriteHtonU16 ((*iter).PortHigh);
}
}
uint32_t
PortRangeTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
uint64_t len = 0;
while (len < valueLength)
{
uint16_t low = i.ReadNtohU16 ();
uint16_t high = i.ReadNtohU16 ();
Add (low, high);
len += 4;
}
return len;
}
void
PortRangeTlvValue::Add (uint16_t portLow, uint16_t portHigh)
{
struct PortRange tmp;
tmp.PortLow = portLow;
tmp.PortHigh = portHigh;
m_portRange->push_back (tmp);
}
PortRangeTlvValue::Iterator
PortRangeTlvValue::Begin (void) const
{
return m_portRange->begin ();
}
PortRangeTlvValue::Iterator
PortRangeTlvValue::End (void) const
{
return m_portRange->end ();
}
PortRangeTlvValue *
PortRangeTlvValue::Copy (void) const
{
PortRangeTlvValue * tmp = new PortRangeTlvValue ();
for (std::vector<struct PortRange>::const_iterator iter = m_portRange->begin (); iter != m_portRange->end (); ++iter)
{
tmp->Add ((*iter).PortLow, (*iter).PortHigh);
}
return tmp;
}
// ==============================================================================
ProtocolTlvValue::ProtocolTlvValue ()
{
m_protocol = new std::vector<uint8_t>;
}
ProtocolTlvValue::~ProtocolTlvValue ()
{
m_protocol->clear ();
if (m_protocol != 0)
{
delete m_protocol;
m_protocol = 0;
}
}
uint32_t
ProtocolTlvValue::GetSerializedSize (void) const
{
return m_protocol->size ();
}
void
ProtocolTlvValue::Serialize (Buffer::Iterator i) const
{
for (std::vector<uint8_t>::const_iterator iter = m_protocol->begin (); iter != m_protocol->end (); ++iter)
{
i.WriteU8 ((*iter));
}
}
uint32_t
ProtocolTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
uint64_t len = 0;
while (len < valueLength)
{
Add (i.ReadU8 ());
len++;
}
return len;
}
void
ProtocolTlvValue::Add (uint8_t protocol)
{
m_protocol->push_back (protocol);
}
ProtocolTlvValue::Iterator
ProtocolTlvValue::Begin (void) const
{
return m_protocol->begin ();
}
ProtocolTlvValue::Iterator
ProtocolTlvValue::End (void) const
{
return m_protocol->end ();
}
ProtocolTlvValue*
ProtocolTlvValue::Copy (void) const
{
ProtocolTlvValue* tmp = new ProtocolTlvValue ();
for (std::vector<uint8_t>::const_iterator iter = m_protocol->begin (); iter != m_protocol->end (); ++iter)
{
tmp->Add ((*iter));
}
return tmp;
}
// ==============================================================================
Ipv4AddressTlvValue::Ipv4AddressTlvValue ()
{
m_ipv4Addr = new std::vector<struct ipv4Addr>;
}
Ipv4AddressTlvValue::~Ipv4AddressTlvValue ()
{
m_ipv4Addr->clear ();
if (m_ipv4Addr != 0)
{
delete m_ipv4Addr;
m_ipv4Addr = 0;
}
}
uint32_t
Ipv4AddressTlvValue::GetSerializedSize (void) const
{
return m_ipv4Addr->size () * sizeof(struct ipv4Addr);
}
void
Ipv4AddressTlvValue::Serialize (Buffer::Iterator i) const
{
for (std::vector<struct ipv4Addr>::const_iterator iter = m_ipv4Addr->begin (); iter != m_ipv4Addr->end (); ++iter)
{
i.WriteHtonU32 ((*iter).Address.Get ());
i.WriteHtonU32 ((*iter).Mask.Get ());
}
}
uint32_t
Ipv4AddressTlvValue::Deserialize (Buffer::Iterator i, uint64_t valueLength)
{
uint64_t len = 0;
while (len < valueLength)
{
uint32_t addr = i.ReadNtohU32 ();
uint32_t mask = i.ReadNtohU32 ();
Add (Ipv4Address (addr), Ipv4Mask (mask));
len += 8;
}
return len;
}
void
Ipv4AddressTlvValue::Add (Ipv4Address address, Ipv4Mask Mask)
{
struct ipv4Addr tmp;
tmp.Address = address;
tmp.Mask = Mask;
m_ipv4Addr->push_back (tmp);
}
Ipv4AddressTlvValue::Iterator
Ipv4AddressTlvValue::Begin () const
{
return m_ipv4Addr->begin ();
}
Ipv4AddressTlvValue::Iterator
Ipv4AddressTlvValue::End () const
{
return m_ipv4Addr->end ();
}
Ipv4AddressTlvValue *
Ipv4AddressTlvValue::Copy (void) const
{
Ipv4AddressTlvValue * tmp = new Ipv4AddressTlvValue ();
for (std::vector<struct ipv4Addr>::const_iterator iter = m_ipv4Addr->begin (); iter != m_ipv4Addr->end (); ++iter)
{
tmp->Add ((*iter).Address, (*iter).Mask);
}
return tmp;
}
}
| zy901002-gpsr | src/wimax/model/wimax-tlv.cc | C++ | gpl2 | 24,586 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "ns3/assert.h"
#include "ns3/net-device.h"
#include "wimax-channel.h"
#include "wimax-phy.h"
NS_LOG_COMPONENT_DEFINE ("WimaxChannel");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxChannel);
TypeId WimaxChannel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::WimaxChannel")
.SetParent<Channel> ();
return tid;
}
WimaxChannel::WimaxChannel (void)
{
}
WimaxChannel::~WimaxChannel (void)
{
}
void
WimaxChannel::Attach (Ptr<WimaxPhy> phy)
{
DoAttach (phy);
}
uint32_t
WimaxChannel::GetNDevices (void) const
{
return DoGetNDevices ();
}
Ptr<NetDevice>
WimaxChannel::GetDevice (uint32_t index) const
{
return DoGetDevice (index);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/wimax-channel.cc | C++ | gpl2 | 1,510 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "service-flow-record.h"
namespace ns3 {
ServiceFlowRecord::ServiceFlowRecord (void)
: m_grantSize (0),
m_grantTimeStamp (Seconds (0)),
m_dlTimeStamp (Seconds (0)),
m_pktsSent (0),
m_pktsRcvd (0),
m_bytesSent (0),
m_bytesRcvd (0),
m_requestedBandwidth (0),
m_grantedBandwidth (0),
m_bwSinceLastExpiry (0)
{
m_lastGrantTime = Seconds (0);
m_backlogged = 0;
m_backloggedTemp = 0;
m_grantedBandwidthTemp = 0;
}
ServiceFlowRecord::~ServiceFlowRecord (void)
{
}
void
ServiceFlowRecord::SetGrantSize (uint32_t grantSize)
{
m_grantSize = grantSize;
}
uint32_t
ServiceFlowRecord::GetGrantSize (void) const
{
return m_grantSize;
}
void
ServiceFlowRecord::SetGrantTimeStamp (Time grantTimeStamp)
{
m_grantTimeStamp = grantTimeStamp;
}
Time
ServiceFlowRecord::GetGrantTimeStamp (void) const
{
return m_grantTimeStamp;
}
void
ServiceFlowRecord::SetDlTimeStamp (Time dlTimeStamp)
{
m_dlTimeStamp = dlTimeStamp;
}
Time
ServiceFlowRecord::GetDlTimeStamp (void) const
{
return m_dlTimeStamp;
}
void
ServiceFlowRecord::SetPktsSent (uint32_t pktsSent)
{
m_pktsSent = pktsSent;
}
void
ServiceFlowRecord::UpdatePktsSent (uint32_t pktsSent)
{
m_pktsSent += pktsSent;
}
uint32_t
ServiceFlowRecord::GetPktsSent (void) const
{
return m_pktsSent;
}
void
ServiceFlowRecord::SetPktsRcvd (uint32_t pktsRcvd)
{
m_pktsRcvd = pktsRcvd;
}
void
ServiceFlowRecord::UpdatePktsRcvd (uint32_t pktsRcvd)
{
m_pktsRcvd += pktsRcvd;
}
uint32_t
ServiceFlowRecord::GetPktsRcvd (void) const
{
return m_pktsRcvd;
}
void
ServiceFlowRecord::SetBytesSent (uint32_t bytesSent)
{
m_bytesSent = bytesSent;
}
void
ServiceFlowRecord::UpdateBytesSent (uint32_t bytesSent)
{
m_bytesSent += bytesSent;
}
uint32_t
ServiceFlowRecord::GetBytesSent (void) const
{
return m_bytesSent;
}
void
ServiceFlowRecord::SetBytesRcvd (uint32_t bytesRcvd)
{
m_bytesRcvd = bytesRcvd;
}
void
ServiceFlowRecord::UpdateBytesRcvd (uint32_t bytesRcvd)
{
m_bytesRcvd += bytesRcvd;
}
uint32_t
ServiceFlowRecord::GetBytesRcvd (void) const
{
return m_bytesRcvd;
}
void
ServiceFlowRecord::SetRequestedBandwidth (uint32_t requestedBandwidth)
{
m_requestedBandwidth = requestedBandwidth;
}
void
ServiceFlowRecord::UpdateRequestedBandwidth (uint32_t requestedBandwidth)
{
m_requestedBandwidth += requestedBandwidth;
}
uint32_t
ServiceFlowRecord::GetRequestedBandwidth (void)
{
return m_requestedBandwidth;
}
void
ServiceFlowRecord::SetGrantedBandwidth (uint32_t grantedBandwidth)
{
m_grantedBandwidth = grantedBandwidth;
}
void
ServiceFlowRecord::UpdateGrantedBandwidth (uint32_t grantedBandwidth)
{
m_grantedBandwidth += grantedBandwidth;
}
uint32_t
ServiceFlowRecord::GetGrantedBandwidth (void)
{
return m_grantedBandwidth;
}
void
ServiceFlowRecord::SetGrantedBandwidthTemp (uint32_t grantedBandwidthTemp)
{
m_grantedBandwidthTemp = grantedBandwidthTemp;
}
void
ServiceFlowRecord::UpdateGrantedBandwidthTemp (
uint32_t grantedBandwidthTemp)
{
m_grantedBandwidthTemp += grantedBandwidthTemp;
}
uint32_t
ServiceFlowRecord::GetGrantedBandwidthTemp (void)
{
return m_grantedBandwidthTemp;
}
void
ServiceFlowRecord::SetLastGrantTime (Time grantTime)
{
m_lastGrantTime = grantTime;
}
Time
ServiceFlowRecord::GetLastGrantTime (void) const
{
return m_lastGrantTime;
}
void
ServiceFlowRecord::SetBacklogged (uint32_t backlogged)
{
m_backlogged = backlogged;
}
void
ServiceFlowRecord::IncreaseBacklogged (uint32_t backlogged)
{
m_backlogged += backlogged;
}
uint32_t
ServiceFlowRecord::GetBacklogged (void) const
{
return m_backlogged;
}
void
ServiceFlowRecord::SetBackloggedTemp (uint32_t backloggedTemp)
{
m_backloggedTemp = backloggedTemp;
}
void
ServiceFlowRecord::IncreaseBackloggedTemp (uint32_t backloggedTemp)
{
m_backloggedTemp += backloggedTemp;
}
uint32_t
ServiceFlowRecord::GetBackloggedTemp (void) const
{
return m_backloggedTemp;
}
void
ServiceFlowRecord::SetBwSinceLastExpiry (uint32_t bwSinceLastExpiry)
{
m_bwSinceLastExpiry = bwSinceLastExpiry;
}
void
ServiceFlowRecord::UpdateBwSinceLastExpiry (uint32_t bwSinceLastExpiry)
{
m_bwSinceLastExpiry += bwSinceLastExpiry;
}
uint32_t
ServiceFlowRecord::GetBwSinceLastExpiry (void)
{
return m_bwSinceLastExpiry;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/service-flow-record.cc | C++ | gpl2 | 5,102 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "cid.h"
// 0 will match IR CID, -1 will match broadcast CID 0xFFFF, hence 60000
#define CID_UNINITIALIZED 60000
namespace ns3 {
Cid::Cid (void)
{
m_identifier = CID_UNINITIALIZED;
}
Cid::Cid (uint16_t identifier)
{
m_identifier = identifier;
}
Cid::~Cid (void)
{
}
uint16_t
Cid::GetIdentifier (void) const
{
return m_identifier;
}
bool
Cid::IsMulticast (void) const
{
return m_identifier >= 0xff00 && m_identifier <= 0xfffd;
}
bool
Cid::IsBroadcast (void) const
{
return *this == Broadcast ();
}
bool
Cid::IsPadding (void) const
{
return *this == Padding ();
}
bool
Cid::IsInitialRanging (void) const
{
return *this == InitialRanging ();
}
Cid
Cid::Broadcast (void)
{
return 0xffff;
}
Cid
Cid::Padding (void)
{
return 0xfffe;
}
Cid
Cid::InitialRanging (void)
{
return 0;
}
bool operator == (const Cid &lhs,
const Cid &rhs)
{
return lhs.m_identifier == rhs.m_identifier;
}
bool operator != (const Cid &lhs,
const Cid &rhs)
{
return !(lhs == rhs);
}
std::ostream & operator << (std::ostream &os, const Cid &cid)
{
os << cid.GetIdentifier ();
return os;
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/cid.cc | C++ | gpl2 | 2,116 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#include "ns3/packet.h"
#include "send-params.h"
namespace ns3 {
SendParams::SendParams (void)
{
}
SendParams::~SendParams (void)
{
}
// -----------------------------------------
OfdmSendParams::OfdmSendParams (Ptr<PacketBurst> burst, uint8_t modulationType,
uint8_t direction)
: SendParams (),
m_burst (burst),
m_modulationType (modulationType),
m_direction (direction)
{
}
OfdmSendParams::~OfdmSendParams ()
{
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/send-params.cc | C++ | gpl2 | 1,308 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "ss-link-manager.h"
#include <stdint.h>
#include "ns3/node.h"
#include "ns3/packet.h"
#include "ns3/simulator.h"
#include "ns3/log.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "burst-profile-manager.h"
#include "service-flow-manager.h"
NS_LOG_COMPONENT_DEFINE ("SSLinkManager");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (SSLinkManager);
TypeId SSLinkManager::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::SSLinkManager")
.SetParent<Object> ();
return tid;
}
SSLinkManager::SSLinkManager (Ptr<SubscriberStationNetDevice> ss)
: m_ss (ss),
m_rangingStatus (WimaxNetDevice::RANGING_STATUS_EXPIRED),
m_bsEirp (65535),
m_eirXPIrMax (65535),
m_pTxIrMax (0),
m_initRangOppNumber (0),
m_contentionRangingRetries (0),
m_rngReqFrameNumber (0),
m_dlChnlNr (0),
m_frequency (0),
m_rangingIntervalFound (false),
m_nrRngReqsSent (0),
m_nrRngRspsRecvd (0),
m_nrInvitedPollsRecvd (0),
m_rangingCW (0),
m_rangingBO (0),
m_nrRangingTransOpps (0),
m_isBackoffSet (false),
m_rangingAnomalies (0)
{
}
SSLinkManager::~SSLinkManager (void)
{
m_ss = 0;
}
void
SSLinkManager::DoDispose (void)
{
m_ss = 0;
}
void
SSLinkManager::SetBsEirp (uint16_t bs_eirp)
{
m_bsEirp = bs_eirp;
}
void
SSLinkManager::SetEirXPIrMax (uint16_t eir_x_p_ir_max)
{
m_eirXPIrMax = eir_x_p_ir_max;
}
void
SSLinkManager::SetRangingIntervalFound (bool rangingIntervalFound)
{
m_rangingIntervalFound = rangingIntervalFound;
}
bool
SSLinkManager::GetRangingIntervalFound (void) const
{
return m_rangingIntervalFound;
}
void
SSLinkManager::SetNrRangingTransOpps (uint8_t nrRangingTransOpps)
{
m_nrRangingTransOpps = nrRangingTransOpps;
}
void
SSLinkManager::SetRangingCW (uint8_t rangingCW)
{
m_rangingCW = rangingCW;
}
void
SSLinkManager::IncrementNrInvitedPollsRecvd (void)
{
m_nrInvitedPollsRecvd++;
}
EventId
SSLinkManager::GetDlMapSyncTimeoutEvent (void)
{
return m_dlMapSyncTimeoutEvent;
}
void
SSLinkManager::StartScanning (
SubscriberStationNetDevice::EventType type, bool deleteParameters)
{
// temp parameter "type" just to check on expiry of which event the function was called
if (deleteParameters)
{
DeleteUplinkParameters ();
}
NS_ASSERT_MSG (!m_ss->IsRegistered (),
"Subscriber Station: Error while scanning: Already registered with a BS");
if (m_ss->GetState () != SubscriberStationNetDevice::SS_STATE_IDLE)
{
m_dlChnlNr++;
}
// using max number of channel according to according to Section 8.5.1 of IEEE 802.16-2004 standard.
if (m_dlChnlNr >= 200)
{
m_dlChnlNr = 0;
}
uint64_t dlChannel = m_ss->GetChannel (m_dlChnlNr);
m_ss->SetState (SubscriberStationNetDevice::SS_STATE_SCANNING);
m_ss->GetPhy ()->StartScanning (dlChannel, m_ss->GetIntervalT20 (),
MakeCallback (&SSLinkManager::EndScanning, this));
}
void
SSLinkManager::EndScanning (bool status, uint64_t frequency)
{
if (status)
{
StartSynchronizing ();
m_frequency = frequency;
}
else
{
StartScanning (SubscriberStationNetDevice::EVENT_NONE, false);
}
}
void
SSLinkManager::StartSynchronizing (void)
{
m_ss->SetState (SubscriberStationNetDevice::SS_STATE_SYNCHRONIZING);
m_ss->SetTimer (Simulator::Schedule (m_ss->GetIntervalT21 (),
&SSLinkManager::StartScanning, this,
SubscriberStationNetDevice::EVENT_DL_MAP_SYNC_TIMEOUT, false),
m_dlMapSyncTimeoutEvent);
}
void
SSLinkManager::SendRangingRequest (uint8_t uiuc, uint16_t allocationSize)
{
NS_ASSERT_MSG (
m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_REG_RANG_INTRVL
|| m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_INV_RANG_INTRVL,
"SS: Error while sending a ranging request: the ss state should be SS_STATE_WAITING_REG_RANG_INTRVL or SS_STATE_WAITING_INV_RANG_INTRVL");
if (m_nrRngReqsSent == 0) // sending the first time
{
m_pTxIrMax = CalculateMaxIRSignalStrength ();
m_rngreq.SetReqDlBurstProfile (
m_ss->GetBurstProfileManager ()->GetBurstProfileToRequest ());
m_rngreq.SetMacAddress (m_ss->GetMacAddress ());
}
else
{
m_pTxIrMax++;
if (m_nrRngRspsRecvd > 0)
{
m_rngreq.SetRangingAnomalies (m_rangingAnomalies);
}
}
Ptr<Packet> packet = Create<Packet> ();
Ptr<PacketBurst> burst = Create<PacketBurst> ();
packet->AddHeader (m_rngreq);
packet->AddHeader (ManagementMessageType (
ManagementMessageType::MESSAGE_TYPE_RNG_REQ));
Ptr<WimaxConnection> connection;
if (m_rangingStatus == WimaxNetDevice::RANGING_STATUS_CONTINUE)
{
connection = m_ss->GetBasicConnection ();
}
else // have been assigned BCID, means currently adjusting parameters
{
connection = m_ss->GetInitialRangingConnection ();
}
m_ss->Enqueue (packet, MacHeaderType (), connection);
m_ss->SetState (SubscriberStationNetDevice::SS_STATE_WAITING_RNG_RSP);
m_ss->SetTimer (Simulator::Schedule (m_ss->GetIntervalT3 (),
&SSLinkManager::StartContentionResolution, this), m_waitForRngRspEvent);
m_nrRngReqsSent++;
NS_ASSERT_MSG (allocationSize
== m_ss->GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize ()
/ m_ss->GetPhy ()->GetPsPerSymbol (),
"SS: Error while sending a ranging request: the allocation size is not correct");
// will work even if connection is not passed (i.e. null is passed) as scheduler will automatically select the same connection
m_ss->SendBurst (uiuc, allocationSize, connection);
}
void
SSLinkManager::StartContentionResolution (void)
{
NS_ASSERT_MSG (
m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_RNG_RSP
|| m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_REG_RANG_INTRVL
|| m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_ADJUSTING_PARAMETERS,
"SS: Can not start connection resolution: The SS state should be SS_STATE_WAITING_RNG_RSP or SS_STATE_WAITING_REG_RANG_INTRVL or SS_STATE_ADJUSTING_PARAMETERS");
if (m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_RNG_RSP)
{
m_ss->SetState (
SubscriberStationNetDevice::SS_STATE_WAITING_REG_RANG_INTRVL);
IncreaseRangingRequestCW ();
m_contentionRangingRetries++;
}
else if (m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_ADJUSTING_PARAMETERS)
{
m_ss->SetState (
SubscriberStationNetDevice::SS_STATE_WAITING_REG_RANG_INTRVL);
}
if (m_contentionRangingRetries == m_ss->GetMaxContentionRangingRetries ())
{
StartScanning (SubscriberStationNetDevice::EVENT_NONE, false);
}
else
{
if (!m_isBackoffSet)
{
SelectRandomBackoff ();
}
}
}
void
SSLinkManager::PerformBackoff (void)
{
Time defferTime = Seconds (0);
Time timeToAllocation = Seconds (0);
uint16_t nrPsPerRangOpp =
m_ss->GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize ();
uint16_t oppSize =
m_ss->GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize ()
/ m_ss->GetPhy ()->GetPsPerSymbol ();
for (uint8_t deferTOs = 0; deferTOs < m_nrRangingTransOpps; deferTOs++)
{
if (m_rangingBO == 0)
{
defferTime = Seconds (deferTOs * nrPsPerRangOpp
* m_ss->GetPhy ()->GetPsDuration ().GetSeconds ());
timeToAllocation = m_ss->GetTimeToAllocation (defferTime);
Simulator::Schedule (timeToAllocation,
&SSLinkManager::SendRangingRequest, this,
OfdmUlBurstProfile::UIUC_INITIAL_RANGING, oppSize);
m_rngReqFrameNumber = m_ss->GetNrFrames ();
m_initRangOppNumber = deferTOs + 1;
m_isBackoffSet = false;
break;
}
m_rangingBO--;
}
}
void
SSLinkManager::SelectRandomBackoff (void)
{
NS_ASSERT_MSG (m_rangingCW != 0 && m_rangingBO == 0,
"be sure that CW has been set and BO is not already set"); // ensuring CW has been set and BO is not already set
m_rangingBO = (rand () % m_rangingCW);
m_isBackoffSet = true;
}
void
SSLinkManager::IncreaseRangingRequestCW (void)
{
m_rangingCW = std::min (uint8_t ((m_rangingCW * 2 + 1) - 1),
m_ss->GetCurrentUcd ().GetRangingBackoffEnd ());
}
void
SSLinkManager::ResetRangingRequestCW (void)
{
m_rangingCW = (uint8_t) pow ((double) 2,
(double) m_ss->GetCurrentUcd ().GetRangingBackoffStart ()) - 1;
}
void
SSLinkManager::PerformRanging (Cid cid,
RngRsp rngrsp)
{
// need to distinguish initial ranging or periodic ranging
if (cid == m_ss->GetInitialRangingConnection ()->GetCid ())
{
if (rngrsp.GetFrameNumber () == m_rngReqFrameNumber
&& rngrsp.GetInitRangOppNumber () == m_initRangOppNumber)
{
Simulator::Cancel (m_waitForRngRspEvent);
m_nrRngRspsRecvd++;
// RNG-REQ was undecodable
ResetRangingRequestCW ();
AdjustRangingParameters (rngrsp);
m_ss->SetState (
SubscriberStationNetDevice::SS_STATE_ADJUSTING_PARAMETERS);
return;
}
if (m_ss->GetAddress () != rngrsp.GetMacAddress ())
{
return;
}
m_ss->SetBasicConnection (CreateObject<WimaxConnection> (rngrsp.GetBasicCid (),
Cid::BASIC));
m_ss->SetPrimaryConnection (CreateObject<WimaxConnection> (rngrsp.GetPrimaryCid (),
Cid::PRIMARY));
m_ss->SetAreManagementConnectionsAllocated (true);
}
else
{
// either periodic ranging or an additional RNG-RSP during initial ranging
}
m_nrRngRspsRecvd++;
if (m_waitForRngRspEvent.IsRunning ())
{
Simulator::Cancel (m_waitForRngRspEvent);
}
m_rangingStatus = (WimaxNetDevice::RangingStatus) rngrsp.GetRangStatus ();
NS_ASSERT_MSG (
m_rangingStatus == WimaxNetDevice::RANGING_STATUS_CONTINUE
|| m_rangingStatus == WimaxNetDevice::RANGING_STATUS_ABORT
|| m_rangingStatus == WimaxNetDevice::RANGING_STATUS_SUCCESS,
"SS: Can not perform ranging: the ranging status should be RANGING_STATUS_CONTINUE or RANGING_STATUS_ABORT or RANGING_STATUS_SUCCESS");
if (m_rangingStatus == WimaxNetDevice::RANGING_STATUS_ABORT)
{
if (rngrsp.GetDlFreqOverride ())
{
// code to move to new channel/frequency goes here
}
// deassigning basic and primary CIDs
m_ss->SetBasicConnection (0);
m_ss->SetPrimaryConnection (0);
m_ss->SetAreManagementConnectionsAllocated (false);
}
else
{
AdjustRangingParameters (rngrsp);
if (m_rangingStatus == WimaxNetDevice::RANGING_STATUS_SUCCESS)
{
m_ss->SetState (SubscriberStationNetDevice::SS_STATE_REGISTERED);
// initiate service flows
if (m_ss->HasServiceFlows () && !m_ss->GetAreServiceFlowsAllocated ())
{
m_ss->GetServiceFlowManager ()->InitiateServiceFlows ();
}
NegotiateBasicCapabilities ();
}
else
{
m_ss->SetState (
SubscriberStationNetDevice::SS_STATE_WAITING_INV_RANG_INTRVL);
// wait for invited ranging interval assigned to its Basic CID
}
}
}
void
SSLinkManager::DeleteUplinkParameters (void)
{
m_ss->SetCurrentUcd (Ucd ());
}
bool
SSLinkManager::IsUlChannelUsable (void)
{
// dont know how to check if usable, see Figure 58.
return true; // temporarily assuming usable
}
void
SSLinkManager::AdjustRangingParameters (const RngRsp &rngrsp)
{
#if 0 /* a template for future implementation following */
bool successful = true;
uint8_t temp = rngrsp.GetTimingAdjust ();
temp = rngrsp.GetPowerLevelAdjust ();
temp = rngrsp.GetOffsetFreqAdjust ();
// code for adjusting parameters goes here
if (!successful)
{
// code for setting ranging anomalies goes here
}
#endif
}
void
SSLinkManager::NegotiateBasicCapabilities (void)
{
// code to nagotiate basic capabilites goes here, ignored until very advanced stages
}
uint16_t
SSLinkManager::CalculateMaxIRSignalStrength (void)
{
// SS obtains RSSI measurement from the OFDM downlink preambles using a complex formula, page 486
uint16_t rss = 1;
if (m_bsEirp == 65535 || m_eirXPIrMax == 65535)
{
return GetMinTransmitPowerLevel ();
}
else
{
return m_eirXPIrMax + m_bsEirp - rss;
}
return 0;
}
uint16_t
SSLinkManager::GetMinTransmitPowerLevel (void)
{
// code to calculate minimum transmit power level of the SS, see page 189 of ammendment
return 10; // temp
}
void
SSLinkManager::ScheduleScanningRestart (Time interval,
SubscriberStationNetDevice::EventType eventType,
bool deleteUlParameters, EventId &eventId)
{
m_ss->SetTimer (Simulator::Schedule (interval, &SSLinkManager::StartScanning,
this, eventType, deleteUlParameters), eventId);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/ss-link-manager.cc | C++ | gpl2 | 14,426 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2010 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#include "wimax-mac-to-mac-header.h"
#include "ns3/address-utils.h"
#include "ns3/uinteger.h"
#include "ns3/log.h"
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (WimaxMacToMacHeader);
WimaxMacToMacHeader::WimaxMacToMacHeader (void)
: m_len (0)
{
}
WimaxMacToMacHeader::WimaxMacToMacHeader (uint32_t len)
: m_len (len)
{
}
WimaxMacToMacHeader::~WimaxMacToMacHeader (void)
{
}
TypeId
WimaxMacToMacHeader::GetTypeId (void)
{
static TypeId tid =
TypeId ("ns3::WimaxMacToMacHeader").SetParent<Header> ().AddConstructor<WimaxMacToMacHeader> ();
return tid;
}
TypeId
WimaxMacToMacHeader::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
uint8_t
WimaxMacToMacHeader::GetSizeOfLen (void) const
{
uint8_t sizeOfLen = 1;
if (m_len > 127)
{
sizeOfLen = 2;
uint64_t testValue = 0xFF;
while (m_len > testValue)
{
sizeOfLen++;
testValue *= 0xFF;
}
}
return sizeOfLen;
}
uint32_t
WimaxMacToMacHeader::GetSerializedSize (void) const
{
uint8_t sizeOfLen = GetSizeOfLen ();
if (sizeOfLen==1)
{
return 20;
}
else
{
return 20 + sizeOfLen -1;
}
//return 19+sizeOfLen;
}
void
WimaxMacToMacHeader::Serialize (Buffer::Iterator i) const
{
// The following header encoding was reverse-engineered by looking
// at existing live pcap traces which could be opened with wireshark
// i.e., we have no idea where this is coming from.
//
// 6 zeros for mac destination
// 6 zeros for mac source
// 2 bytes for length/type: 0x08f0
// 2 bytes for sequence number: 0x0001
// 2 bytes for number of tlvs: 0x0001
// 1 byte for type of first tlv: 0x09
// 1 byte to indicate the length of the length field of the tlv : 0x80 | 0x04
// n bytes to indicate the size of the packet (network order)
// n bytes for the packet data
uint8_t zero = 0;
for (int j = 0; j < 12; j++)
{
i.WriteU8 (zero);
}
i.WriteU16 (0xf008); // eth length/type
i.WriteU16 (0x0100); // sequence number
i.WriteU16 (0x0100); // number of tlvs
i.WriteU8 (0x09); // type of first tlv
uint8_t lenSize = GetSizeOfLen ();
if (lenSize == 1)
{
i.WriteU8 (m_len);
}
else
{
i.WriteU8 ((lenSize-1) | 0x80);
for (int j = 0; j < lenSize - 1; j++)
{
i.WriteU8 ((uint8_t)(m_len >> ((lenSize - 1 - 1 - j) * 8)));
}
}
}
uint32_t
WimaxMacToMacHeader::Deserialize (Buffer::Iterator start)
{
// not needed here
return 20;
}
void
WimaxMacToMacHeader::Print (std::ostream &os) const
{
}
};
| zy901002-gpsr | src/wimax/model/wimax-mac-to-mac-header.cc | C++ | gpl2 | 3,388 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include <stdint.h>
#include "cid-factory.h"
#include "ns3/uinteger.h"
namespace ns3 {
CidFactory::CidFactory (void)
: m_m (0x5500),
// this is an arbitrary default
m_basicIdentifier (1),
m_primaryIdentifier (m_m + 1),
m_transportOrSecondaryIdentifier (2 * m_m + 1),
m_multicastPollingIdentifier (0xff00)
{
}
Cid
CidFactory::AllocateBasic (void)
{
NS_ASSERT (m_basicIdentifier < m_m);
m_basicIdentifier++;
return Cid (m_basicIdentifier);
}
Cid
CidFactory::AllocatePrimary (void)
{
NS_ASSERT (m_primaryIdentifier < 2 * m_m);
m_primaryIdentifier++;
return Cid (m_primaryIdentifier);
}
Cid
CidFactory::AllocateTransportOrSecondary (void)
{
NS_ASSERT (m_transportOrSecondaryIdentifier < 0xfefe);
m_transportOrSecondaryIdentifier++;
return Cid (m_transportOrSecondaryIdentifier);
}
Cid
CidFactory::AllocateMulticast (void)
{
NS_ASSERT (m_multicastPollingIdentifier < 0xfffd);
m_multicastPollingIdentifier++;
return Cid (m_multicastPollingIdentifier);
}
Cid
CidFactory::Allocate (enum Cid::Type type)
{
switch (type)
{
case Cid::BROADCAST:
return Cid::Broadcast ();
case Cid::INITIAL_RANGING:
return Cid::InitialRanging ();
case Cid::BASIC:
return AllocateBasic ();
case Cid::PRIMARY:
return AllocatePrimary ();
case Cid::TRANSPORT:
return AllocateTransportOrSecondary ();
case Cid::MULTICAST:
return AllocateMulticast ();
case Cid::PADDING:
return Cid::Padding ();
default:
NS_FATAL_ERROR ("Cannot be reached");
return 0; // quiet compiler
}
}
bool
CidFactory::IsTransport (Cid cid) const
{
uint16_t id = cid.m_identifier;
return id >= 2 * m_m + 1 && id <= 0xfefe;
}
bool
CidFactory::IsPrimary (Cid cid) const
{
uint16_t id = cid.m_identifier;
return id >= m_m + 1 && id <= 2 * m_m;
}
bool
CidFactory::IsBasic (Cid cid) const
{
uint16_t id = cid.m_identifier;
return id >= 1 && id <= m_m;
}
void
CidFactory::FreeCid (Cid cid)
{
// TODO:We need to update the cid bitmap properly here.
NS_FATAL_ERROR ("TODO: Update the cid bitmap properly here-- please implement and contribute a patch");
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/cid-factory.cc | C++ | gpl2 | 3,136 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef SERVICE_FLOW_RECORD_H
#define SERVICE_FLOW_RECORD_H
#include <stdint.h>
#include "ns3/nstime.h"
#include "bs-uplink-scheduler.h"
#include "bs-net-device.h"
#include "ns3/ptr.h"
namespace ns3 {
/**
* \ingroup wimax
* \brief this class implements a structure to manage some parameters and statistics related to a service flow
*/
class ServiceFlowRecord
{
public:
ServiceFlowRecord (void);
~ServiceFlowRecord (void);
/**
* \brief Set the grant size (only for UGS service flows)
* \param grantSize the grant size to set
*/
void SetGrantSize (uint32_t grantSize);
/**
* \return the grant size (only for ugs service flows)
*/
uint32_t GetGrantSize (void) const;
/**
* \brief Set the grant time stamp. Used for data alocation for ugs flows, and unicast poll (bw request)
* for non-UGS flows
* \param grantTimeStamp the grant time stamp to set
*/
void SetGrantTimeStamp (Time grantTimeStamp);
/**
* \return the grant time stamp. Used for data allocation for ugs flows, and unicast poll (bw request) for non-UGS flows
*/
Time GetGrantTimeStamp (void) const;
/**
* \brief Set the DlTimeStamp.
* \param dlTimeStamp: time when this service flow's traffic was last sent.
*/
void SetDlTimeStamp (Time dlTimeStamp);
/**
* \return the DlTimeStamp: time when this service flow's traffic was last sent
*/
Time GetDlTimeStamp (void) const;
/**
* \brief set the number of sent packets in this service flow
* \param pktsSent the number of sent packets
*/
void SetPktsSent (uint32_t pktsSent);
/**
* \brief update the number of sent packets by adding pktsSent
* \param pktsSent the number of sent packets to add
*/
void UpdatePktsSent (uint32_t pktsSent);
/**
* \return the number of sent packet in this service flow
*/
uint32_t GetPktsSent (void) const;
/**
* \brief Set the number of received packet
* \param pktsRcvd The number of received packets
*/
void SetPktsRcvd (uint32_t pktsRcvd);
/**
* \brief update the number of received packets by adding pktsRcvd
* \param pktsRcvd the number of received packets to add
*/
void UpdatePktsRcvd (uint32_t pktsRcvd);
/**
* \return the number of received packet
*/
uint32_t GetPktsRcvd (void) const;
/**
* \brief Set the number of sent bytes
* \param bytesSent the number of sent bytes
*/
void SetBytesSent (uint32_t bytesSent);
/**
* \brief update the number of sent bytes by adding bytesSent
* \param bytesSent the number of bytes to add
*/
void UpdateBytesSent (uint32_t bytesSent);
/**
* \return The number of sent bytes
*/
uint32_t GetBytesSent (void) const;
/**
* \brief Set the number of received bytes
* \param bytesRcvd the number of received bytes
*/
void SetBytesRcvd (uint32_t bytesRcvd);
/**
* \brief update the number of received bytes by adding bytesRcvd
* \param bytesRcvd the number of bytes to add
*/
void UpdateBytesRcvd (uint32_t bytesRcvd);
/**
* \return The number of received bytes
*/
uint32_t GetBytesRcvd (void) const;
void SetRequestedBandwidth (uint32_t requestedBandwidth);
void UpdateRequestedBandwidth (uint32_t requestedBandwidth);
uint32_t GetRequestedBandwidth (void);
void SetGrantedBandwidth (uint32_t grantedBandwidth);
void UpdateGrantedBandwidth (uint32_t grantedBandwidth);
uint32_t GetGrantedBandwidth (void);
void SetGrantedBandwidthTemp (uint32_t grantedBandwidthTemp);
void UpdateGrantedBandwidthTemp (uint32_t grantedBandwidthTemp);
uint32_t GetGrantedBandwidthTemp (void);
void SetBwSinceLastExpiry (uint32_t bwSinceLastExpiry);
void UpdateBwSinceLastExpiry (uint32_t bwSinceLastExpiry);
uint32_t GetBwSinceLastExpiry (void);
void SetLastGrantTime (Time grantTime);
Time GetLastGrantTime (void) const;
void SetBacklogged (uint32_t backlogged);
void IncreaseBacklogged (uint32_t backlogged);
uint32_t GetBacklogged (void) const;
void SetBackloggedTemp (uint32_t backloggedTemp);
void IncreaseBackloggedTemp (uint32_t backloggedTemp);
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
// stats members
uint32_t m_pktsSent;
uint32_t m_pktsRcvd;
uint32_t m_bytesSent;
uint32_t m_bytesRcvd;
uint32_t m_requestedBandwidth;
uint32_t m_grantedBandwidth;
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 */
uint32_t m_bwSinceLastExpiry;
Time m_lastGrantTime;
int32_t m_backlogged;
int32_t m_backloggedTemp;
};
} // namespace ns3
#endif /* SERVICE_FLOW_RECORD_H */
| zy901002-gpsr | src/wimax/model/service-flow-record.h | C++ | gpl2 | 5,833 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include "ns3/simulator.h"
#include "ns3/drop-tail-queue.h"
#include "ns3/node.h"
#include "ss-net-device.h"
#include "wimax-phy.h"
#include "ns3/packet-burst.h"
#include <algorithm>
#include "dl-mac-messages.h"
#include "ul-mac-messages.h"
#include "ss-scheduler.h"
#include "wimax-mac-queue.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/pointer.h"
#include "ns3/enum.h"
#include "service-flow.h"
#include "service-flow-record.h"
#include "service-flow-manager.h"
#include "connection-manager.h"
#include "burst-profile-manager.h"
#include "ss-link-manager.h"
#include "bandwidth-manager.h"
NS_LOG_COMPONENT_DEFINE ("SubscriberStationNetDevice");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (SubscriberStationNetDevice);
Time SubscriberStationNetDevice::GetDefaultLostDlMapInterval ()
{
return (MicroSeconds (500000));
}
TypeId
SubscriberStationNetDevice::GetTypeId (void)
{
static TypeId
tid =
TypeId ("ns3::SubscriberStationNetDevice")
.SetParent<WimaxNetDevice> ()
.AddConstructor<SubscriberStationNetDevice> ()
.AddAttribute ("BasicConnection",
"Basic connection",
PointerValue (),
MakePointerAccessor (&SubscriberStationNetDevice::m_basicConnection),
MakePointerChecker<WimaxConnection> ())
.AddAttribute ("PrimaryConnection",
"Primary connection",
PointerValue (),
MakePointerAccessor (&SubscriberStationNetDevice::m_primaryConnection),
MakePointerChecker<WimaxConnection> ())
.AddAttribute ("LostDlMapInterval",
"Time since last received DL-MAP message before downlink synchronization is considered lost. Maximum is 600ms",
TimeValue (Seconds (0.5)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetLostDlMapInterval,
&SubscriberStationNetDevice::SetLostDlMapInterval),
MakeTimeChecker ())
.AddAttribute ("LostUlMapInterval",
"Time since last received UL-MAP before uplink synchronization is considered lost, maximum is 600.",
TimeValue (MilliSeconds (500)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetLostUlMapInterval,
&SubscriberStationNetDevice::SetLostUlMapInterval),
MakeTimeChecker ())
.AddAttribute ("MaxDcdInterval",
"Maximum time between transmission of DCD messages. Maximum is 10s",
TimeValue (Seconds (10)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetMaxDcdInterval,
&SubscriberStationNetDevice::SetMaxDcdInterval),
MakeTimeChecker ())
.AddAttribute ("MaxUcdInterval",
"Maximum time between transmission of UCD messages. Maximum is 10s",
TimeValue (Seconds (10)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetMaxUcdInterval,
&SubscriberStationNetDevice::SetMaxUcdInterval),
MakeTimeChecker ())
.AddAttribute ("IntervalT1",
"Wait for DCD timeout. Maximum is 5*maxDcdInterval",
TimeValue (Seconds (50)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT1,
&SubscriberStationNetDevice::SetIntervalT1),
MakeTimeChecker ())
.AddAttribute ("IntervalT2",
"Wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity. Maximum is 5*Ranging interval",
TimeValue (Seconds (10)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT2,
&SubscriberStationNetDevice::SetIntervalT2),
MakeTimeChecker ())
.AddAttribute ("IntervalT3",
"ranging Response reception timeout following the transmission of a ranging request. Maximum is 200ms",
TimeValue (Seconds (0.2)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT3,
&SubscriberStationNetDevice::SetIntervalT3),
MakeTimeChecker ())
.AddAttribute ("IntervalT7",
"wait for DSA/DSC/DSD Response timeout. Maximum is 1s",
TimeValue (Seconds (0.1)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT7,
&SubscriberStationNetDevice::SetIntervalT7),
MakeTimeChecker ())
.AddAttribute ("IntervalT12",
"Wait for UCD descriptor.Maximum is 5*MaxUcdInterval",
TimeValue (Seconds (10)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT12,
&SubscriberStationNetDevice::SetIntervalT12),
MakeTimeChecker ())
.AddAttribute ("IntervalT20",
"Time the SS searches for preambles on a given channel. Minimum is 2 MAC frames",
TimeValue (Seconds (0.5)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT20,
&SubscriberStationNetDevice::SetIntervalT20),
MakeTimeChecker ())
.AddAttribute ("IntervalT21",
"time the SS searches for (decodable) DL-MAP on a given channel",
TimeValue (Seconds (10)),
MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT21,
&SubscriberStationNetDevice::SetIntervalT21),
MakeTimeChecker ())
.AddAttribute ("MaxContentionRangingRetries",
"Number of retries on contention Ranging Requests",
UintegerValue (16),
MakeUintegerAccessor (&SubscriberStationNetDevice::GetMaxContentionRangingRetries,
&SubscriberStationNetDevice::SetMaxContentionRangingRetries),
MakeUintegerChecker<uint8_t> (1, 16))
.AddAttribute ("SSScheduler",
"The ss scheduler attached to this device.",
PointerValue (),
MakePointerAccessor (&SubscriberStationNetDevice::GetScheduler,
&SubscriberStationNetDevice::SetScheduler),
MakePointerChecker<SSScheduler> ())
.AddAttribute ("LinkManager",
"The ss link manager attached to this device.",
PointerValue (),
MakePointerAccessor (&SubscriberStationNetDevice::GetLinkManager,
&SubscriberStationNetDevice::SetLinkManager),
MakePointerChecker<SSLinkManager> ())
.AddAttribute ("Classifier",
"The ss classifier attached to this device.",
PointerValue (),
MakePointerAccessor (&SubscriberStationNetDevice::GetIpcsClassifier,
&SubscriberStationNetDevice::SetIpcsPacketClassifier),
MakePointerChecker<IpcsClassifier> ())
.AddTraceSource ("SSTxDrop",
"A packet has been dropped in the MAC layer before being queued for transmission.",
MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssTxDropTrace))
.AddTraceSource ("SSPromiscRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a promiscuous trace,",
MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssPromiscRxTrace))
.AddTraceSource ("SSRx",
"A packet has been received by this device, has been passed up from the physical layer "
"and is being forwarded up the local protocol stack. This is a non-promiscuous trace,",
MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssRxTrace))
.AddTraceSource ("SSRxDrop",
"A packet has been dropped in the MAC layer after it has been passed up from the physical "
"layer.",
MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssRxDropTrace));
return tid;
}
SubscriberStationNetDevice::SubscriberStationNetDevice (void)
{
InitSubscriberStationNetDevice ();
}
void
SubscriberStationNetDevice::InitSubscriberStationNetDevice (void)
{
m_lostDlMapInterval = MilliSeconds (500);
m_lostUlMapInterval = MilliSeconds (500);
m_maxDcdInterval = Seconds (10);
m_maxUcdInterval = Seconds (10);
m_intervalT1 = Seconds (5 * m_maxDcdInterval.GetSeconds ());
m_intervalT2 = Seconds (5 * 2); // shall be 5 * RangingInterval, if ranging interval=see T2 at page 638) means Initial Ranging Interval=see page 637)
m_intervalT3 = MilliSeconds (200);
m_intervalT7 = Seconds (0.1); // maximum is 1
m_intervalT12 = Seconds (5 * m_maxUcdInterval.GetSeconds ());
m_intervalT21 = Seconds (11);
m_maxContentionRangingRetries = 16;
m_dcdCount = 0;
m_baseStationId = Mac48Address ("00:00:00:00:00:00");
m_ucdCount = 0;
m_allocationStartTime = 0;
m_nrDlMapElements = 0;
m_nrUlMapElements = 0;
m_nrDlMapRecvd = 0;
m_nrUlMapRecvd = 0;
m_nrDcdRecvd = 0;
m_nrUcdRecvd = 0;
m_modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
m_areManagementConnectionsAllocated = false;
m_areServiceFlowsAllocated = false;
m_basicConnection = 0;
m_primaryConnection = 0;
m_dlBurstProfile = new OfdmDlBurstProfile ();
m_ulBurstProfile = new OfdmUlBurstProfile ();
m_classifier = CreateObject<IpcsClassifier> ();
m_linkManager = CreateObject<SSLinkManager> (this);
m_scheduler = CreateObject<SSScheduler> (this);
m_serviceFlowManager = CreateObject<SsServiceFlowManager> (this);
}
SubscriberStationNetDevice::SubscriberStationNetDevice (Ptr<Node> node, Ptr<WimaxPhy> phy)
{
InitSubscriberStationNetDevice ();
this->SetNode (node);
this->SetPhy (phy);
}
SubscriberStationNetDevice::~SubscriberStationNetDevice (void)
{
}
void
SubscriberStationNetDevice::DoDispose (void)
{
delete m_dlBurstProfile;
delete m_ulBurstProfile;
m_scheduler = 0;
m_serviceFlowManager = 0;
m_basicConnection = 0;
m_primaryConnection = 0;
m_classifier = 0;
m_dlBurstProfile = 0;
m_ulBurstProfile = 0;
m_linkManager = 0;
WimaxNetDevice::DoDispose ();
}
void
SubscriberStationNetDevice::SetLostDlMapInterval (Time lostDlMapInterval)
{
m_lostDlMapInterval = lostDlMapInterval;
}
Time
SubscriberStationNetDevice::GetLostDlMapInterval (void) const
{
return m_lostDlMapInterval;
}
void
SubscriberStationNetDevice::SetLostUlMapInterval (Time lostUlMapInterval)
{
m_lostUlMapInterval = lostUlMapInterval;
}
Time
SubscriberStationNetDevice::GetLostUlMapInterval (void) const
{
return m_lostUlMapInterval;
}
void
SubscriberStationNetDevice::SetMaxDcdInterval (Time maxDcdInterval)
{
m_maxDcdInterval = maxDcdInterval;
}
Time
SubscriberStationNetDevice::GetMaxDcdInterval (void) const
{
return m_maxDcdInterval;
}
void
SubscriberStationNetDevice::SetMaxUcdInterval (Time maxUcdInterval)
{
m_maxUcdInterval = maxUcdInterval;
}
Time
SubscriberStationNetDevice::GetMaxUcdInterval (void) const
{
return m_maxUcdInterval;
}
void
SubscriberStationNetDevice::SetIntervalT1 (Time interval)
{
m_intervalT1 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT1 (void) const
{
return m_intervalT1;
}
void
SubscriberStationNetDevice::SetIntervalT2 (Time interval)
{
m_intervalT2 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT2 (void) const
{
return m_intervalT2;
}
void
SubscriberStationNetDevice::SetIntervalT3 (Time interval)
{
m_intervalT3 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT3 (void) const
{
return m_intervalT3;
}
void
SubscriberStationNetDevice::SetIntervalT7 (Time interval)
{
m_intervalT7 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT7 (void) const
{
return m_intervalT7;
}
void
SubscriberStationNetDevice::SetIntervalT12 (Time interval)
{
m_intervalT12 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT12 (void) const
{
return m_intervalT12;
}
void
SubscriberStationNetDevice::SetIntervalT20 (Time interval)
{
m_intervalT20 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT20 (void) const
{
return m_intervalT20;
}
void
SubscriberStationNetDevice::SetIntervalT21 (Time interval)
{
m_intervalT21 = interval;
}
Time
SubscriberStationNetDevice::GetIntervalT21 (void) const
{
return m_intervalT21;
}
void
SubscriberStationNetDevice::SetMaxContentionRangingRetries (uint8_t maxContentionRangingRetries)
{
m_maxContentionRangingRetries = maxContentionRangingRetries;
}
uint8_t
SubscriberStationNetDevice::GetMaxContentionRangingRetries (void) const
{
return m_maxContentionRangingRetries;
}
void
SubscriberStationNetDevice::SetBasicConnection (Ptr<WimaxConnection> basicConnection)
{
m_basicConnection = basicConnection;
}
Ptr<WimaxConnection>
SubscriberStationNetDevice::GetBasicConnection (void) const
{
return m_basicConnection;
}
void
SubscriberStationNetDevice::SetPrimaryConnection (Ptr<WimaxConnection> primaryConnection)
{
m_primaryConnection = primaryConnection;
}
Ptr<WimaxConnection>
SubscriberStationNetDevice::GetPrimaryConnection (void) const
{
return m_primaryConnection;
}
Cid
SubscriberStationNetDevice::GetBasicCid (void) const
{
return m_basicConnection->GetCid ();
}
Cid
SubscriberStationNetDevice::GetPrimaryCid (void) const
{
return m_primaryConnection->GetCid ();
}
void
SubscriberStationNetDevice::SetModulationType (WimaxPhy::ModulationType modulationType)
{
m_modulationType = modulationType;
}
WimaxPhy::ModulationType
SubscriberStationNetDevice::GetModulationType (void) const
{
return m_modulationType;
}
void
SubscriberStationNetDevice::SetAreManagementConnectionsAllocated (bool areManagementConnectionsAllocated)
{
m_areManagementConnectionsAllocated = areManagementConnectionsAllocated;
}
bool
SubscriberStationNetDevice::GetAreManagementConnectionsAllocated (void) const
{
return m_areManagementConnectionsAllocated;
}
void
SubscriberStationNetDevice::SetAreServiceFlowsAllocated (bool areServiceFlowsAllocated)
{
m_areServiceFlowsAllocated = areServiceFlowsAllocated;
}
bool
SubscriberStationNetDevice::GetAreServiceFlowsAllocated (void) const
{
return m_areServiceFlowsAllocated;
}
Ptr<SSScheduler>
SubscriberStationNetDevice::GetScheduler (void) const
{
return m_scheduler;
}
void
SubscriberStationNetDevice::SetScheduler (Ptr<SSScheduler> scheduler)
{
m_scheduler = scheduler;
}
bool
SubscriberStationNetDevice::HasServiceFlows (void) const
{
return GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).size () > 0;
}
Ptr<IpcsClassifier>
SubscriberStationNetDevice::GetIpcsClassifier () const
{
return m_classifier;
}
void
SubscriberStationNetDevice::SetIpcsPacketClassifier (Ptr<IpcsClassifier> classifier)
{
m_classifier = classifier;
}
Ptr<SSLinkManager>
SubscriberStationNetDevice::GetLinkManager (void) const
{
return m_linkManager;
}
void
SubscriberStationNetDevice::SetLinkManager (Ptr<SSLinkManager> linkManager)
{
m_linkManager = linkManager;
}
Ptr<SsServiceFlowManager>
SubscriberStationNetDevice::GetServiceFlowManager (void) const
{
return m_serviceFlowManager;
}
void
SubscriberStationNetDevice::SetServiceFlowManager (Ptr<SsServiceFlowManager> sfm)
{
m_serviceFlowManager = sfm;
}
void
SubscriberStationNetDevice::Start (void)
{
SetReceiveCallback ();
GetPhy ()->SetPhyParameters ();
GetPhy ()->SetDataRates ();
m_intervalT20 = Seconds (4 * GetPhy ()->GetFrameDuration ().GetSeconds ());
CreateDefaultConnections ();
Simulator::ScheduleNow (&SSLinkManager::StartScanning, m_linkManager, EVENT_NONE, false);
}
void
SubscriberStationNetDevice::Stop (void)
{
SetState (SS_STATE_STOPPED);
}
void
SubscriberStationNetDevice::AddServiceFlow (ServiceFlow sf)
{
GetServiceFlowManager ()->AddServiceFlow (sf);
}
void
SubscriberStationNetDevice::AddServiceFlow (ServiceFlow * sf)
{
GetServiceFlowManager ()->AddServiceFlow (sf);
}
bool
SubscriberStationNetDevice::DoSend (Ptr<Packet> packet,
const Mac48Address &source,
const Mac48Address &dest,
uint16_t protocolNumber)
{
NS_LOG_INFO ("SS (" << source << "):" );
NS_LOG_INFO ("\tSending packet..." );
NS_LOG_INFO ("\t\tDestination: " << dest );
NS_LOG_INFO ("\t\tPacket Size: " << packet->GetSize () );
NS_LOG_INFO ("\t\tProtocol: " << protocolNumber );
ServiceFlow *serviceFlow = 0;
if (IsRegistered ())
{
NS_LOG_DEBUG ("SS (Basic CID: " << m_basicConnection->GetCid () << ")");
}
else
{
NS_LOG_DEBUG ("SS (" << GetMacAddress () << ")");
NS_LOG_INFO ("\tCan't send packet! (NotRegitered with the network)");
return false;
}
NS_LOG_DEBUG ("packet to send, size : " << packet->GetSize () << ", destination : " << dest);
if (GetServiceFlowManager ()->GetNrServiceFlows () == 0)
{
NS_LOG_INFO ("\tCan't send packet! (No service Flow)");
return false;
}
if (protocolNumber == 2048)
{
serviceFlow = m_classifier->Classify (packet, GetServiceFlowManager (), ServiceFlow::SF_DIRECTION_UP);
}
if ((protocolNumber != 2048) || (serviceFlow == NULL))
{
serviceFlow = *GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).begin ();
NS_LOG_INFO ("\tNo service flows matches...using the default one.");
}
NS_LOG_INFO ("\tPacket classified in the service flow SFID = " << serviceFlow->GetSfid () << " CID = "
<< serviceFlow->GetCid ());
if (serviceFlow->GetIsEnabled ())
{
if (!Enqueue (packet, MacHeaderType (), serviceFlow->GetConnection ()))
{
NS_LOG_INFO ("\tEnqueue ERROR!!" );
m_ssTxDropTrace (packet);
return false;
}
else
{
m_ssTxTrace (packet);
}
}
else
{
NS_LOG_INFO ("Error!! The Service Flow is not enabled" );
m_ssTxDropTrace (packet);
return false;
}
return true;
}
bool
SubscriberStationNetDevice::Enqueue (Ptr<Packet> packet,
const MacHeaderType &hdrType,
Ptr<WimaxConnection> connection)
{
NS_ASSERT_MSG (connection != 0, "SS: Can not enqueue the packet: the selected connection is nor initialized");
GenericMacHeader hdr;
if (hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
hdr.SetLen (packet->GetSize () + hdr.GetSerializedSize ());
hdr.SetCid (connection->GetCid ());
}
if (connection->GetType () == Cid::TRANSPORT)
{
if (connection->GetSchedulingType () == ServiceFlow::SF_TYPE_UGS && m_scheduler->GetPollMe ())
{
NS_ASSERT_MSG (hdrType.GetType () != MacHeaderType::HEADER_TYPE_BANDWIDTH,
"Error while equeuing packet: incorrect header type");
GrantManagementSubheader grantMgmntSubhdr;
grantMgmntSubhdr.SetPm (true);
packet->AddHeader (grantMgmntSubhdr);
}
}
NS_LOG_INFO ("ServiceFlowManager: enqueuing packet" );
return connection->Enqueue (packet, hdrType, hdr);
}
void
SubscriberStationNetDevice::SendBurst (uint8_t uiuc,
uint16_t nrSymbols,
Ptr<WimaxConnection> connection,
MacHeaderType::HeaderType packetType)
{
WimaxPhy::ModulationType modulationType;
if (uiuc == OfdmUlBurstProfile::UIUC_INITIAL_RANGING || uiuc == OfdmUlBurstProfile::UIUC_REQ_REGION_FULL)
{
modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;
}
else
{
modulationType = GetBurstProfileManager ()->GetModulationType (uiuc, DIRECTION_UPLINK);
}
Ptr<PacketBurst> burst = m_scheduler->Schedule (nrSymbols, modulationType, packetType, connection);
if (burst->GetNPackets () == 0)
{
return;
}
if (IsRegistered ())
{
NS_LOG_DEBUG ("SS (Basic CID: " << m_basicConnection->GetCid () << ")");
}
else
{
NS_LOG_DEBUG ("SS (" << GetMacAddress () << ")");
}
if (connection->GetType () == Cid::TRANSPORT)
{
ServiceFlowRecord *record = connection->GetServiceFlow ()->GetRecord ();
record->UpdatePktsSent (burst->GetNPackets ());
record->UpdateBytesSent (burst->GetSize ());
NS_LOG_DEBUG (" sending burst" << ", SFID: " << connection->GetServiceFlow ()->GetSfid () << ", pkts sent: "
<< record->GetPktsSent () << ", pkts rcvd: " << record->GetPktsRcvd () << ", bytes sent: "
<< record->GetBytesSent () << ", bytes rcvd: " << record->GetBytesRcvd () );
}
else
{
}
ForwardDown (burst, modulationType);
}
void
SubscriberStationNetDevice::DoReceive (Ptr<Packet> packet)
{
GenericMacHeader gnrcMacHdr;
ManagementMessageType msgType;
RngRsp rngrsp;
Cid cid;
uint32_t pktSize = packet->GetSize ();
packet->RemoveHeader (gnrcMacHdr);
FragmentationSubheader fragSubhdr;
bool fragmentation = false; // it becames true when there is a fragmentation subheader
if (gnrcMacHdr.GetHt () == MacHeaderType::HEADER_TYPE_GENERIC)
{
if (gnrcMacHdr.check_hcs () == false)
{
// The header is noisy
NS_LOG_INFO ("Header HCS ERROR");
m_ssRxDropTrace (packet);
return;
}
cid = gnrcMacHdr.GetCid ();
// checking for subheaders
uint8_t type = gnrcMacHdr.GetType ();
if (type)
{
// Check if there is a fragmentation Subheader
uint8_t tmpType = type;
if (((tmpType >> 2) & 1) == 1)
{
// a TRANSPORT packet with fragmentation subheader has been received!
fragmentation = true;
NS_LOG_INFO ("SS DoReceive -> the packet is a fragment" << std::endl);
}
}
if (cid == GetBroadcastConnection ()->GetCid () && !fragmentation)
{
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_DL_MAP:
{
if (GetState () == SS_STATE_SYNCHRONIZING)
{
Simulator::Cancel (m_linkManager->GetDlMapSyncTimeoutEvent ());
}
if (m_lostDlMapEvent.IsRunning ())
{
Simulator::Cancel (m_lostDlMapEvent);
}
m_linkManager->ScheduleScanningRestart (m_lostDlMapInterval, EVENT_LOST_DL_MAP, false, m_lostDlMapEvent);
if (m_dcdWaitTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_dcdWaitTimeoutEvent);
}
m_linkManager->ScheduleScanningRestart (m_intervalT1,
EVENT_DCD_WAIT_TIMEOUT,
false,
m_dcdWaitTimeoutEvent);
if (m_ucdWaitTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_ucdWaitTimeoutEvent);
}
m_linkManager->ScheduleScanningRestart (m_intervalT12,
EVENT_UCD_WAIT_TIMEOUT,
true,
m_ucdWaitTimeoutEvent);
DlMap dlmap;
packet->RemoveHeader (dlmap);
ProcessDlMap (dlmap);
break;
}
case ManagementMessageType::MESSAGE_TYPE_UL_MAP:
{
if (m_lostUlMapEvent.IsRunning ())
{
Simulator::Cancel (m_lostUlMapEvent);
m_linkManager->ScheduleScanningRestart (m_lostUlMapInterval,
EVENT_LOST_UL_MAP,
true,
m_lostUlMapEvent);
}
UlMap ulmap;
packet->RemoveHeader (ulmap);
ProcessUlMap (ulmap);
if (GetState () == SS_STATE_WAITING_REG_RANG_INTRVL)
{
if (m_linkManager->GetRangingIntervalFound ())
{
if (m_rangOppWaitTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_rangOppWaitTimeoutEvent);
}
m_linkManager->PerformBackoff ();
}
}
break;
}
case ManagementMessageType::MESSAGE_TYPE_DCD:
{
if (GetState () == SS_STATE_SYNCHRONIZING)
{
SetState (SS_STATE_ACQUIRING_PARAMETERS);
}
if (m_dcdWaitTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_dcdWaitTimeoutEvent);
m_linkManager->ScheduleScanningRestart (m_intervalT1,
EVENT_DCD_WAIT_TIMEOUT,
false,
m_dcdWaitTimeoutEvent);
}
Dcd dcd;
// number of burst profiles is set to number of DL-MAP IEs after processing DL-MAP, not a very good solution
// dcd.SetNrDlBurstProfiles (m_nrDlMapElements);
dcd.SetNrDlBurstProfiles (7);
packet->RemoveHeader (dcd);
ProcessDcd (dcd);
break;
}
case ManagementMessageType::MESSAGE_TYPE_UCD:
{
Ucd ucd;
// number of burst profiles is set to number of UL-MAP IEs after processing UL-MAP, not a very good solution
// ucd.SetNrUlBurstProfiles (m_nrUlMapElements);
ucd.SetNrUlBurstProfiles (7);
packet->RemoveHeader (ucd);
ProcessUcd (ucd);
if (m_ucdWaitTimeoutEvent.IsRunning ())
{
Simulator::Cancel (m_ucdWaitTimeoutEvent);
m_linkManager->ScheduleScanningRestart (m_intervalT12,
EVENT_UCD_WAIT_TIMEOUT,
true,
m_ucdWaitTimeoutEvent);
}
if (GetState () == SS_STATE_ACQUIRING_PARAMETERS)
{
/*state indicating that SS has completed scanning, synchronization and parameter acquisition
successfully and now waiting for UL-MAP to start initial ranging.*/
SetState (SS_STATE_WAITING_REG_RANG_INTRVL);
m_linkManager->ScheduleScanningRestart (m_intervalT2,
EVENT_RANG_OPP_WAIT_TIMEOUT,
false,
m_rangOppWaitTimeoutEvent);
m_linkManager->ScheduleScanningRestart (m_lostUlMapInterval,
EVENT_LOST_UL_MAP,
true,
m_lostUlMapEvent);
}
break;
}
default:
NS_FATAL_ERROR ("Invalid management message type");
}
}
else if (GetInitialRangingConnection () != 0 && cid == GetInitialRangingConnection ()->GetCid () && !fragmentation)
{
m_traceSSRx (packet, GetMacAddress (), &cid);
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_RNG_REQ:
// intended for base station, ignore
break;
case ManagementMessageType::MESSAGE_TYPE_RNG_RSP:
NS_ASSERT_MSG (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);
break;
default:
NS_LOG_ERROR ("Invalid management message type");
}
}
else if (m_basicConnection != 0 && cid == m_basicConnection->GetCid () && !fragmentation)
{
m_traceSSRx (packet, GetMacAddress (), &cid);
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_RNG_REQ:
// intended for base station, ignore
break;
case ManagementMessageType::MESSAGE_TYPE_RNG_RSP:
NS_ASSERT_MSG (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);
break;
default:
NS_LOG_ERROR ("Invalid management message type");
}
}
else if (m_primaryConnection != 0 && cid == m_primaryConnection->GetCid () && !fragmentation)
{
m_traceSSRx (packet, GetMacAddress (), &cid);
packet->RemoveHeader (msgType);
switch (msgType.GetType ())
{
case ManagementMessageType::MESSAGE_TYPE_REG_REQ:
// not yet implemented
break;
case ManagementMessageType::MESSAGE_TYPE_REG_RSP:
// intended for base station, ignore
break;
case ManagementMessageType::MESSAGE_TYPE_DSA_REQ:
/*from other station as DSA initiation
by BS is not supported, ignore*/
break;
case ManagementMessageType::MESSAGE_TYPE_DSA_RSP:
{
Simulator::Cancel (GetServiceFlowManager ()->GetDsaRspTimeoutEvent ());
DsaRsp dsaRsp;
packet->RemoveHeader (dsaRsp);
GetServiceFlowManager ()->ProcessDsaRsp (dsaRsp);
break;
}
case ManagementMessageType::MESSAGE_TYPE_DSA_ACK:
/*from other station as DSA initiation
by BS is not supported, ignore*/
break;
default:
NS_LOG_ERROR ("Invalid management message type");
}
}
else if (GetConnectionManager ()->GetConnection (cid)) // transport connection
{
ServiceFlow *serviceFlow = GetConnectionManager ()->GetConnection (cid)->GetServiceFlow ();
ServiceFlowRecord *record = serviceFlow->GetRecord ();
record->UpdatePktsRcvd (1);
record->UpdateBytesRcvd (pktSize);
// If fragmentation is true, the packet is a fragment.
if (!fragmentation)
{
m_ssRxTrace (packet);
ForwardUp (packet, m_baseStationId, GetMacAddress ()); // source shall be BS's address or sender SS's?
}
else
{
NS_LOG_INFO ( "FRAG_DEBUG: SS DoReceive, the Packet is a fragment" << std::endl);
packet->RemoveHeader (fragSubhdr);
uint32_t fc = fragSubhdr.GetFc ();
NS_LOG_INFO ( "\t fragment size = " << packet->GetSize () << std::endl);
if (fc == 2)
{
// This is the latest fragment.
// Take the fragment queue, defragment a packet and send it to the upper layer
NS_LOG_INFO ( "\t Received the latest fragment" << std::endl);
GetConnectionManager ()->GetConnection (cid)
->FragmentEnqueue (packet);
WimaxConnection::FragmentsQueue fragmentsQueue = GetConnectionManager ()->
GetConnection (cid)->GetFragmentsQueue ();
Ptr<Packet> fullPacket = Create<Packet> ();
// DEFRAGMENTATION
NS_LOG_INFO ( "\t SS PACKET DEFRAGMENTATION" << std::endl);
for (std::list<Ptr<const Packet> >::const_iterator iter = fragmentsQueue.begin ();
iter != fragmentsQueue.end (); ++iter)
{
// Create the whole Packet
fullPacket->AddAtEnd (*iter);
}
GetConnectionManager ()->GetConnection (cid)
->ClearFragmentsQueue ();
NS_LOG_INFO ( "\t fullPacket size = " << fullPacket->GetSize () << std::endl);
m_ssRxTrace (fullPacket);
ForwardUp (fullPacket, m_baseStationId, GetMacAddress ()); // source shall be BS's address or sender SS's?
}
else
{
// This is the first or middle fragment.
// Take the fragment queue, store the fragment into the queue
NS_LOG_INFO ( "\t Received the first or the middle fragment" << std::endl);
GetConnectionManager ()->GetConnection (cid)->FragmentEnqueue (packet);
}
}
}
else if (cid.IsMulticast ())
{
m_traceSSRx (packet, GetMacAddress (), &cid);
ForwardUp (packet, m_baseStationId, GetMacAddress ()); // source shall be BS's address or sender SS's?
}
else if (IsPromisc ())
{
NotifyPromiscTrace (packet);
m_ssPromiscRxTrace (packet);
// not for me, ignore
}
else
{
// not for me drop
}
}
else
{
// from other SS, ignore
}
}
void
SubscriberStationNetDevice::ProcessDlMap (const DlMap &dlmap)
{
m_nrDlMapRecvd++;
m_dcdCount = dlmap.GetDcdCount ();
m_baseStationId = dlmap.GetBaseStationId ();
std::list<OfdmDlMapIe> dlMapElements = dlmap.GetDlMapElements ();
for (std::list<OfdmDlMapIe>::iterator iter = dlMapElements.begin (); iter != dlMapElements.end (); ++iter)
{
if (iter->GetDiuc () == OfdmDlBurstProfile::DIUC_END_OF_MAP)
{
break;
}
if (iter->GetCid () == m_basicConnection->GetCid ())
{
/*here the SS shall actually acquire the start time it shall start receiving the burst at. start time is used for power saving
which is not implemented here, furthermore there is no need since the simulator architecture automatically callbacks the receive
function. shall acquire the DIUC (burst profile) as well to decode the burst, again not required again because the callback
mechanism automatically passes it as parameter.*/
}
#if 0 /* a template for future implementation following */
uint8_t temp = iter->GetDiuc ();
temp = iter->GetPreamblePresent ();
temp = iter->GetStartTime ();
#endif
}
}
void
SubscriberStationNetDevice::ProcessUlMap (const UlMap &ulmap)
{
m_nrUlMapRecvd++;
m_ucdCount = ulmap.GetUcdCount ();
m_allocationStartTime = ulmap.GetAllocationStartTime ();
std::list<OfdmUlMapIe> ulMapElements = ulmap.GetUlMapElements ();
m_linkManager->SetRangingIntervalFound (false);
for (std::list<OfdmUlMapIe>::iterator iter = ulMapElements.begin (); iter != ulMapElements.end (); ++iter)
{
OfdmUlMapIe ulMapIe = *iter;
if (ulMapIe.GetUiuc () == OfdmUlBurstProfile::UIUC_END_OF_MAP)
{
break;
}
Cid cid = ulMapIe.GetCid ();
if (ulMapIe.GetUiuc () == OfdmUlBurstProfile::UIUC_INITIAL_RANGING && cid == GetBroadcastConnection ()->GetCid ())
{
m_linkManager->SetRangingIntervalFound (true);
}
if (m_areManagementConnectionsAllocated && cid == m_basicConnection->GetCid ())
{
Time timeToAllocation = GetTimeToAllocation (Seconds (ulMapIe.GetStartTime ()
* GetPhy ()->GetSymbolDuration ().GetSeconds ()));
if (ulMapIe.GetUiuc () == OfdmUlBurstProfile::UIUC_INITIAL_RANGING) // invited ranging interval
{
m_linkManager->IncrementNrInvitedPollsRecvd ();
NS_ASSERT_MSG (GetState () == SS_STATE_WAITING_INV_RANG_INTRVL,
"SS: Error while processing UL MAP: SS state should be SS_STATE_WAITING_INV_RANG_INTRVL");
Simulator::Schedule (timeToAllocation,
&SSLinkManager::SendRangingRequest,
m_linkManager,
ulMapIe.GetUiuc (),
ulMapIe.GetDuration ());
}
else if (ulMapIe.GetUiuc () == OfdmUlBurstProfile::UIUC_REQ_REGION_FULL) // unicast poll
{
Simulator::Schedule (timeToAllocation,
&BandwidthManager::SendBandwidthRequest,
GetBandwidthManager (),
ulMapIe.GetUiuc (),
ulMapIe.GetDuration ());
}
else // regular allocation/grant for data, for UGS flows or in response of requests for non-UGS flows
{
Ptr<WimaxConnection> connection = NULL;
Simulator::Schedule (timeToAllocation,
&SubscriberStationNetDevice::SendBurst,
this,
ulMapIe.GetUiuc (),
ulMapIe.GetDuration (),
connection,
MacHeaderType::HEADER_TYPE_GENERIC);
}
}
else
{
if (ulMapIe.GetUiuc () == OfdmUlBurstProfile::UIUC_INITIAL_RANGING && cid
== GetBroadcastConnection ()->GetCid ()) // regular ranging interval
{
if (GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize () != 0)
{
m_linkManager->SetNrRangingTransOpps ((ulMapIe.GetDuration () * GetPhy ()->GetPsPerSymbol ())
/ GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize ());
}
if (GetState () == SS_STATE_WAITING_REG_RANG_INTRVL || GetState () == SS_STATE_ADJUSTING_PARAMETERS)
{
m_linkManager->StartContentionResolution ();
}
}
}
}
}
void
SubscriberStationNetDevice::ProcessDcd (const Dcd &dcd)
{
m_nrDcdRecvd++;
if (dcd.GetConfigurationChangeCount () == GetCurrentDcd ().GetConfigurationChangeCount ())
{
return; // nothing new in DCD so dont read
}
SetCurrentDcd (dcd);
OfdmDcdChannelEncodings dcdChnlEncodings = dcd.GetChannelEncodings ();
// parameters for initial ranging
m_linkManager->SetBsEirp (dcdChnlEncodings.GetBsEirp ());
m_linkManager->SetEirXPIrMax (dcdChnlEncodings.GetEirxPIrMax ());
GetPhy ()->GetFrameDuration (dcdChnlEncodings.GetFrameDurationCode ());
std::vector<OfdmDlBurstProfile> dlBurstProfiles = dcd.GetDlBurstProfiles ();
for (std::vector<OfdmDlBurstProfile>::iterator iter = dlBurstProfiles.begin (); iter != dlBurstProfiles.end (); ++iter)
{
OfdmDlBurstProfile brstProfile = *iter;
/*NS-2 does this, may be not correct, assumes DIUC/UIUC to
modulation type mapping in DCD/UCD may change over time*/
if (brstProfile.GetFecCodeType () == m_modulationType)
{
m_dlBurstProfile->SetFecCodeType (brstProfile.GetFecCodeType ());
m_dlBurstProfile->SetDiuc (brstProfile.GetDiuc ());
}
}
}
void
SubscriberStationNetDevice::ProcessUcd (const Ucd &ucd)
{
m_nrUcdRecvd++;
if (!m_linkManager->IsUlChannelUsable ())
{
m_linkManager->StartScanning (EVENT_NONE, false);
return;
}
if (ucd.GetConfigurationChangeCount () == GetCurrentUcd ().GetConfigurationChangeCount ())
{
return; // nothing new in UCD so don't read
}
SetCurrentUcd (ucd);
m_linkManager->SetRangingCW ((uint8_t) pow ((double) 2, (double) ucd.GetRangingBackoffStart ()) - 1); // initializing ranging CW
OfdmUcdChannelEncodings ucdChnlEncodings = ucd.GetChannelEncodings ();
std::vector<OfdmUlBurstProfile> ulBurstProfiles = ucd.GetUlBurstProfiles ();
for (std::vector<OfdmUlBurstProfile>::iterator iter = ulBurstProfiles.begin (); iter != ulBurstProfiles.end (); ++iter)
{
OfdmUlBurstProfile brstProfile = *iter;
/*NS-2 does this, may be not correct, assumes DIUC/UIUC to
modulation type mapping in DCD/UCD may change over time*/
if (brstProfile.GetFecCodeType () == m_modulationType)
{
m_ulBurstProfile->SetFecCodeType (brstProfile.GetFecCodeType ());
m_ulBurstProfile->SetUiuc (brstProfile.GetUiuc ());
}
}
}
/*temporarily assuming registered if ranging is complete,
shall actually consider the registration step also */
bool
SubscriberStationNetDevice::IsRegistered (void) const
{
return GetState () >= SS_STATE_REGISTERED;
}
Time
SubscriberStationNetDevice::GetTimeToAllocation (Time defferTime)
{
Time timeAlreadyElapsed = Simulator::Now () - m_frameStartTime;
Time timeToUlSubframe = Seconds (m_allocationStartTime * GetPhy ()->GetPsDuration ().GetSeconds ())
- timeAlreadyElapsed;
return timeToUlSubframe + defferTime;
}
void
SubscriberStationNetDevice::SetTimer (EventId eventId, EventId &event)
{
if (GetState () == SS_STATE_STOPPED)
{
Simulator::Cancel (eventId); // cancelling this event (already scheduled in function call)
return;
}
event = eventId;
}
} // namespace ns`
| zy901002-gpsr | src/wimax/model/ss-net-device.cc | C++ | gpl2 | 43,905 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
*/
#ifndef WIMAX_CHANNEL_H
#define WIMAX_CHANNEL_H
#include <list>
#include "ns3/channel.h"
#include "wimax-connection.h"
#include "ns3/log.h"
namespace ns3 {
class WimaxPhy;
class Packet;
class Position;
class PacketBurst;
/**
* \ingroup wimax
*/
class WimaxChannel : public Channel
{
public:
static TypeId GetTypeId (void);
WimaxChannel (void);
virtual ~WimaxChannel (void);
/**
* \brief attach the channel to a physical layer of a device
* \param phy the physical layer to which the channel will be attached
*/
void Attach (Ptr<WimaxPhy> phy);
/**
* \return the number of attached devices
*/
uint32_t GetNDevices (void) const;
/**
* \return the ith attached device
*/
Ptr<NetDevice> GetDevice (uint32_t i) const;
private:
virtual void DoAttach (Ptr<WimaxPhy> phy) = 0;
virtual uint32_t DoGetNDevices (void) const = 0;
virtual Ptr<NetDevice> DoGetDevice (uint32_t i) const = 0;
};
} // namespace ns3
#endif /* WIMAX_CHANNEL_H */
| zy901002-gpsr | src/wimax/model/wimax-channel.h | C++ | gpl2 | 1,804 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008,2009 INRIA, UDcast
*
* 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: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@UDcast.com>
*/
#include <stdint.h>
#include "dl-mac-messages.h"
#include "ns3/address-utils.h"
namespace ns3 {
DcdChannelEncodings::DcdChannelEncodings (void)
: m_bsEirp (0),
m_eirXPIrMax (0),
m_frequency (0)
{
}
DcdChannelEncodings::~DcdChannelEncodings (void)
{
}
void
DcdChannelEncodings::SetBsEirp (uint16_t bs_eirp)
{
m_bsEirp = bs_eirp;
}
void
DcdChannelEncodings::SetEirxPIrMax (uint16_t eir_x_p_ir_max)
{
m_eirXPIrMax = eir_x_p_ir_max;
}
void
DcdChannelEncodings::SetFrequency (uint32_t frequency)
{
m_frequency = frequency;
}
uint16_t
DcdChannelEncodings::GetBsEirp (void) const
{
return m_bsEirp;
}
uint16_t
DcdChannelEncodings::GetEirxPIrMax (void) const
{
return m_eirXPIrMax;
}
uint32_t
DcdChannelEncodings::GetFrequency (void) const
{
return m_frequency;
}
uint16_t
DcdChannelEncodings::GetSize (void) const
{
return 2 + 2 + 4;
}
Buffer::Iterator
DcdChannelEncodings::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_bsEirp);
i.WriteU16 (m_eirXPIrMax);
i.WriteU32 (m_frequency);
return DoWrite (i);
}
Buffer::Iterator
DcdChannelEncodings::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_bsEirp = i.ReadU16 ();
m_eirXPIrMax = i.ReadU16 ();
m_frequency = i.ReadU32 ();
return DoRead (i);
}
// ----------------------------------------------------------------------------------------------------------
OfdmDcdChannelEncodings::OfdmDcdChannelEncodings (void)
: m_channelNr (0),
m_ttg (0),
m_rtg (0),
m_baseStationId (Mac48Address ("00:00:00:00:00:00")),
m_frameDurationCode (0),
m_frameNumber (0)
{
}
OfdmDcdChannelEncodings::~OfdmDcdChannelEncodings (void)
{
}
void
OfdmDcdChannelEncodings::SetChannelNr (uint8_t channelNr)
{
m_channelNr = channelNr;
}
void
OfdmDcdChannelEncodings::SetTtg (uint8_t ttg)
{
m_ttg = ttg;
}
void
OfdmDcdChannelEncodings::SetRtg (uint8_t rtg)
{
m_rtg = rtg;
}
void
OfdmDcdChannelEncodings::SetBaseStationId (Mac48Address baseStationId)
{
m_baseStationId = baseStationId;
}
void
OfdmDcdChannelEncodings::SetFrameDurationCode (uint8_t frameDurationCode)
{
m_frameDurationCode = frameDurationCode;
}
void
OfdmDcdChannelEncodings::SetFrameNumber (uint32_t frameNumber)
{
m_frameNumber = frameNumber;
}
uint8_t
OfdmDcdChannelEncodings::GetChannelNr (void) const
{
return m_channelNr;
}
uint8_t
OfdmDcdChannelEncodings::GetTtg (void) const
{
return m_ttg;
}
uint8_t
OfdmDcdChannelEncodings::GetRtg (void) const
{
return m_rtg;
}
Mac48Address
OfdmDcdChannelEncodings::GetBaseStationId (void) const
{
return m_baseStationId;
}
uint8_t
OfdmDcdChannelEncodings::GetFrameDurationCode (void) const
{
return m_frameDurationCode;
}
uint32_t
OfdmDcdChannelEncodings::GetFrameNumber (void) const
{
return m_frameNumber;
}
uint16_t
OfdmDcdChannelEncodings::GetSize (void) const
{
return DcdChannelEncodings::GetSize () + 1 + 1 + 1 + 6 + 1 + 4;
}
Buffer::Iterator
OfdmDcdChannelEncodings::DoWrite (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_channelNr);
i.WriteU8 (m_ttg);
i.WriteU8 (m_rtg);
WriteTo (i, m_baseStationId);
i.WriteU8 (m_frameDurationCode);
i.WriteU32 (m_frameNumber);
return i;
}
Buffer::Iterator
OfdmDcdChannelEncodings::DoRead (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_channelNr = i.ReadU8 ();
m_ttg = i.ReadU8 ();
m_rtg = i.ReadU8 ();
ReadFrom (i, m_baseStationId); // length (6) shall also be written in packet instead of hard coded, see ARP example
m_frameDurationCode = i.ReadU8 ();
m_frameNumber = i.ReadU32 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
OfdmDlBurstProfile::OfdmDlBurstProfile (void)
: m_type (0),
m_length (0),
m_diuc (0),
m_fecCodeType (0)
{
}
OfdmDlBurstProfile::~OfdmDlBurstProfile (void)
{
}
void
OfdmDlBurstProfile::SetType (uint8_t type)
{
m_type = type;
}
void
OfdmDlBurstProfile::SetLength (uint8_t length)
{
m_length = length;
}
void
OfdmDlBurstProfile::SetDiuc (uint8_t diuc)
{
m_diuc = diuc;
}
void
OfdmDlBurstProfile::SetFecCodeType (uint8_t fecCodeType)
{
m_fecCodeType = fecCodeType;
}
uint8_t
OfdmDlBurstProfile::GetType (void) const
{
return m_type;
}
uint8_t
OfdmDlBurstProfile::GetLength (void) const
{
return m_length;
}
uint8_t
OfdmDlBurstProfile::GetDiuc (void) const
{
return m_diuc;
}
uint8_t
OfdmDlBurstProfile::GetFecCodeType (void) const
{
return m_fecCodeType;
}
uint16_t
OfdmDlBurstProfile::GetSize (void) const
{
return 1 + 1 + 1 + 1;
}
Buffer::Iterator
OfdmDlBurstProfile::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_type);
i.WriteU8 (m_length);
i.WriteU8 (m_diuc);
i.WriteU8 (m_fecCodeType);
return i;
}
Buffer::Iterator
OfdmDlBurstProfile::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_type = i.ReadU8 ();
m_length = i.ReadU8 ();
m_diuc = i.ReadU8 ();
m_fecCodeType = i.ReadU8 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (Dcd);
Dcd::Dcd (void)
: m_reserved (0),
m_configurationChangeCount (0),
m_nrDlBurstProfiles (0)
{
}
Dcd::~Dcd (void)
{
}
void
Dcd::SetConfigurationChangeCount (uint8_t configurationChangeCount)
{
m_configurationChangeCount = configurationChangeCount;
}
void
Dcd::SetChannelEncodings (OfdmDcdChannelEncodings channelEncodings)
{
m_channelEncodings = channelEncodings;
}
void
Dcd::SetNrDlBurstProfiles (uint8_t nrDlBurstProfiles)
{
m_nrDlBurstProfiles = nrDlBurstProfiles;
}
void
Dcd::AddDlBurstProfile (OfdmDlBurstProfile dlBurstProfile)
{
m_dlBurstProfiles.push_back (dlBurstProfile);
}
uint8_t
Dcd::GetConfigurationChangeCount (void) const
{
return m_configurationChangeCount;
}
OfdmDcdChannelEncodings
Dcd::GetChannelEncodings (void) const
{
return m_channelEncodings;
}
std::vector<OfdmDlBurstProfile>
Dcd::GetDlBurstProfiles (void) const
{
return m_dlBurstProfiles;
}
uint8_t
Dcd::GetNrDlBurstProfiles (void) const
{
return m_nrDlBurstProfiles;
}
std::string
Dcd::GetName (void) const
{
return "DCD";
}
TypeId
Dcd::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::Dcd")
.SetParent<Header> ()
.AddConstructor<Dcd> ()
;
return tid;
}
TypeId
Dcd::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
Dcd::Print (std::ostream &os) const
{
os << " configuration change count = "
<< (uint32_t) m_configurationChangeCount
<< ", number of dl burst profiles = " << m_dlBurstProfiles.size ();
}
uint32_t
Dcd::GetSerializedSize (void) const
{
uint32_t dlBurstProfilesSize = 0;
for (std::vector<OfdmDlBurstProfile>::const_iterator iter =
m_dlBurstProfiles.begin (); iter != m_dlBurstProfiles.end (); ++iter)
{
OfdmDlBurstProfile burstProfile = *iter;
dlBurstProfilesSize += burstProfile.GetSize ();
}
return 1 + 1 + m_channelEncodings.GetSize () + dlBurstProfilesSize;
}
void
Dcd::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_reserved);
i.WriteU8 (m_configurationChangeCount);
i = m_channelEncodings.Write (i);
for (std::vector<OfdmDlBurstProfile>::const_iterator iter =
m_dlBurstProfiles.begin (); iter != m_dlBurstProfiles.end (); ++iter)
{
OfdmDlBurstProfile burstProfile = *iter;
i = burstProfile.Write (i);
}
}
uint32_t
Dcd::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_reserved = i.ReadU8 ();
m_configurationChangeCount = i.ReadU8 ();
i = m_channelEncodings.Read (i);
for (uint8_t j = 0; j < m_nrDlBurstProfiles; j++)
{
OfdmDlBurstProfile burstProfile;
i = burstProfile.Read (i);
AddDlBurstProfile (burstProfile);
}
return i.GetDistanceFrom (start);
}
// ----------------------------------------------------------------------------------------------------------
OfdmDlMapIe::OfdmDlMapIe (void)
: m_cid (),
m_diuc (0),
m_preamblePresent (0),
m_startTime (0)
{
}
OfdmDlMapIe::~OfdmDlMapIe (void)
{
}
void
OfdmDlMapIe::SetCid (Cid cid)
{
m_cid = cid;
}
void
OfdmDlMapIe::SetDiuc (uint8_t diuc)
{
m_diuc = diuc;
}
void
OfdmDlMapIe::SetPreamblePresent (uint8_t preamblePresent)
{
m_preamblePresent = preamblePresent;
}
void
OfdmDlMapIe::SetStartTime (uint16_t startTime)
{
m_startTime = startTime;
}
Cid
OfdmDlMapIe::GetCid (void) const
{
return m_cid;
}
uint8_t
OfdmDlMapIe::GetDiuc (void) const
{
return m_diuc;
}
uint8_t
OfdmDlMapIe::GetPreamblePresent (void) const
{
return m_preamblePresent;
}
uint16_t
OfdmDlMapIe::GetStartTime (void) const
{
return m_startTime;
}
uint16_t
OfdmDlMapIe::GetSize (void) const
{
return 2 + 1 + 1 + 2;
}
Buffer::Iterator
OfdmDlMapIe::Write (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU16 (m_cid.GetIdentifier ());
i.WriteU8 (m_diuc);
i.WriteU8 (m_preamblePresent);
i.WriteU16 (m_startTime);
return i;
}
Buffer::Iterator
OfdmDlMapIe::Read (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_cid = i.ReadU16 ();
m_diuc = i.ReadU8 ();
m_preamblePresent = i.ReadU8 ();
m_startTime = i.ReadU16 ();
return i;
}
// ----------------------------------------------------------------------------------------------------------
NS_OBJECT_ENSURE_REGISTERED (DlMap);
DlMap::DlMap (void)
: m_dcdCount (0),
m_baseStationId (Mac48Address ("00:00:00:00:00:00"))
{
}
DlMap::~DlMap (void)
{
}
void
DlMap::SetDcdCount (uint8_t dcdCount)
{
m_dcdCount = dcdCount;
}
void
DlMap::SetBaseStationId (Mac48Address baseStationId)
{
m_baseStationId = baseStationId;
}
void
DlMap::AddDlMapElement (OfdmDlMapIe dlMapElement)
{
m_dlMapElements.push_back (dlMapElement);
}
uint8_t
DlMap::GetDcdCount (void) const
{
return m_dcdCount;
}
Mac48Address
DlMap::GetBaseStationId (void) const
{
return m_baseStationId;
}
std::list<OfdmDlMapIe>
DlMap::GetDlMapElements (void) const
{
return m_dlMapElements;
}
std::string
DlMap::GetName (void) const
{
return "DL-MAP";
}
TypeId
DlMap::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::DlMap")
.SetParent<Header> ()
.AddConstructor<DlMap> ()
;
return tid;
}
TypeId
DlMap::GetInstanceTypeId (void) const
{
return GetTypeId ();
}
void
DlMap::Print (std::ostream &os) const
{
os << " dcd count = " << (uint32_t) m_dcdCount << ", base station id = "
<< m_baseStationId << ", number of dl-map elements = "
<< m_dlMapElements.size ();
}
uint32_t
DlMap::GetSerializedSize (void) const
{
uint32_t dlMapElementsSize = 0;
for (std::list<OfdmDlMapIe>::const_iterator iter = m_dlMapElements.begin (); iter
!= m_dlMapElements.end (); ++iter)
{
OfdmDlMapIe dlMapIe = *iter;
dlMapElementsSize += dlMapIe.GetSize ();
}
return 1 + 6 + dlMapElementsSize;
}
void
DlMap::Serialize (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
i.WriteU8 (m_dcdCount);
WriteTo (i, m_baseStationId);
for (std::list<OfdmDlMapIe>::const_iterator iter = m_dlMapElements.begin (); iter
!= m_dlMapElements.end (); ++iter)
{
OfdmDlMapIe dlMapIe = *iter;
i = dlMapIe.Write (i);
}
}
uint32_t
DlMap::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
m_dcdCount = i.ReadU8 ();
ReadFrom (i, m_baseStationId); // length (6) shall also be written in packet instead of hard coded, see ARP example
m_dlMapElements.clear (); // only for printing, otherwise it shows wrong number of elements
while (true)
{
OfdmDlMapIe dlMapIe;
i = dlMapIe.Read (i);
AddDlMapElement (dlMapIe);
if (dlMapIe.GetDiuc () == 14) // End of Map IE
{
break;
}
}
return i.GetDistanceFrom (start);
}
} // namespace ns3
| zy901002-gpsr | src/wimax/model/dl-mac-messages.cc | C++ | gpl2 | 12,799 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#include "ipcs-classifier.h"
#include <stdint.h>
#include "ns3/log.h"
#include "service-flow.h"
#include "ns3/packet.h"
#include "ns3/ipv4-header.h"
#include "ns3/udp-header.h"
#include "ns3/tcp-header.h"
#include "ns3/llc-snap-header.h"
#include "ns3/udp-l4-protocol.h"
#include "ns3/tcp-l4-protocol.h"
NS_LOG_COMPONENT_DEFINE ("IpcsClassifier");
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (IpcsClassifier);
TypeId IpcsClassifier::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::IpcsClassifier")
.SetParent<Object> ();
return tid;
}
IpcsClassifier::IpcsClassifier (void)
{
}
IpcsClassifier::~IpcsClassifier (void)
{
}
ServiceFlow *
IpcsClassifier::Classify (Ptr<const Packet> packet,
Ptr<ServiceFlowManager> sfm, ServiceFlow::Direction dir)
{
Ptr<Packet> C_Packet = packet->Copy ();
LlcSnapHeader llc;
C_Packet->RemoveHeader (llc);
Ipv4Header ipv4Header;
C_Packet->RemoveHeader (ipv4Header);
Ipv4Address source_address = ipv4Header.GetSource ();
Ipv4Address dest_address = ipv4Header.GetDestination ();
uint8_t protocol = ipv4Header.GetProtocol ();
uint16_t sourcePort = 0;
uint16_t destPort = 0;
if (protocol == UdpL4Protocol::PROT_NUMBER)
{
UdpHeader udpHeader;
C_Packet->RemoveHeader (udpHeader);
sourcePort = udpHeader.GetSourcePort ();
destPort = udpHeader.GetDestinationPort ();
}
else if (protocol == TcpL4Protocol::PROT_NUMBER)
{
TcpHeader tcpHeader;
C_Packet->RemoveHeader (tcpHeader);
sourcePort = tcpHeader.GetSourcePort ();
destPort = tcpHeader.GetDestinationPort ();
}
else
{
NS_LOG_INFO ("\t\t\tUnknown protocol: " << protocol);
return 0;
}
NS_LOG_INFO ("Classifing packet: src_addr=" << source_address << " dst_addr="
<< dest_address << " src_port=" << sourcePort << " dst_port="
<< destPort << " proto=" << (uint16_t) protocol);
return (sfm->DoClassify (source_address,
dest_address,
sourcePort,
destPort,
protocol,dir));
}
}
| zy901002-gpsr | src/wimax/model/ipcs-classifier.cc | C++ | gpl2 | 3,040 |
from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
import pybindgen.settings
import warnings
class ErrorHandler(pybindgen.settings.ErrorHandler):
def handle_error(self, wrapper, exception, traceback_):
warnings.warn("exception %r in wrapper %s" % (exception, wrapper))
return True
pybindgen.settings.error_handler = ErrorHandler()
import sys
def module_init():
root_module = Module('ns.wimax', cpp_namespace='::ns3')
return root_module
def register_types(module):
root_module = module.get_root()
## ul-job.h (module 'wimax'): ns3::ReqType [enumeration]
module.add_enum('ReqType', ['DATA', 'UNICAST_POLLING'])
## 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'], import_from_module='ns.core')
## 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]
module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::AsciiTraceHelper [class]
module.add_class('AsciiTraceHelper', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice [class]
module.add_class('AsciiTraceHelperForDevice', allow_subclassing=True, import_from_module='ns.network')
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class]
module.add_class('AttributeConstructionList', import_from_module='ns.core')
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct]
module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList'])
## buffer.h (module 'network'): ns3::Buffer [class]
module.add_class('Buffer', import_from_module='ns.network')
## buffer.h (module 'network'): ns3::Buffer::Iterator [class]
module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::Buffer'])
## packet.h (module 'network'): ns3::ByteTagIterator [class]
module.add_class('ByteTagIterator', import_from_module='ns.network')
## packet.h (module 'network'): ns3::ByteTagIterator::Item [class]
module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagIterator'])
## byte-tag-list.h (module 'network'): ns3::ByteTagList [class]
module.add_class('ByteTagList', import_from_module='ns.network')
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator [class]
module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList'])
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item [struct]
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')
## cid.h (module 'wimax'): ns3::Cid [class]
module.add_class('Cid')
## cid.h (module 'wimax'): ns3::Cid::Type [enumeration]
module.add_enum('Type', ['BROADCAST', 'INITIAL_RANGING', 'BASIC', 'PRIMARY', 'TRANSPORT', 'MULTICAST', 'PADDING'], outer_class=root_module['ns3::Cid'])
## cid-factory.h (module 'wimax'): ns3::CidFactory [class]
module.add_class('CidFactory')
## cs-parameters.h (module 'wimax'): ns3::CsParameters [class]
module.add_class('CsParameters')
## cs-parameters.h (module 'wimax'): ns3::CsParameters::Action [enumeration]
module.add_enum('Action', ['ADD', 'REPLACE', 'DELETE'], outer_class=root_module['ns3::CsParameters'])
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings [class]
module.add_class('DcdChannelEncodings', allow_subclassing=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe [class]
module.add_class('DlFramePrefixIe')
## event-id.h (module 'core'): ns3::EventId [class]
module.add_class('EventId', import_from_module='ns.core')
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord [class]
module.add_class('IpcsClassifierRecord')
## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
module.add_class('Ipv4Address', import_from_module='ns.network')
## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask [class]
module.add_class('Ipv4Mask', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## log.h (module 'core'): ns3::LogComponent [class]
module.add_class('LogComponent', import_from_module='ns.core')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
module.add_class('Mac48Address', import_from_module='ns.network')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer [class]
module.add_class('NetDeviceContainer', import_from_module='ns.network')
## node-container.h (module 'network'): ns3::NodeContainer [class]
module.add_class('NodeContainer', import_from_module='ns.network')
## object-base.h (module 'core'): ns3::ObjectBase [class]
module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')
## object.h (module 'core'): ns3::ObjectDeleter [struct]
module.add_class('ObjectDeleter', import_from_module='ns.core')
## object-factory.h (module 'core'): ns3::ObjectFactory [class]
module.add_class('ObjectFactory', import_from_module='ns.core')
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings [class]
module.add_class('OfdmDcdChannelEncodings', parent=root_module['ns3::DcdChannelEncodings'])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile [class]
module.add_class('OfdmDlBurstProfile')
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::Diuc [enumeration]
module.add_enum('Diuc', ['DIUC_STC_ZONE', 'DIUC_BURST_PROFILE_1', 'DIUC_BURST_PROFILE_2', 'DIUC_BURST_PROFILE_3', 'DIUC_BURST_PROFILE_4', 'DIUC_BURST_PROFILE_5', 'DIUC_BURST_PROFILE_6', 'DIUC_BURST_PROFILE_7', 'DIUC_BURST_PROFILE_8', 'DIUC_BURST_PROFILE_9', 'DIUC_BURST_PROFILE_10', 'DIUC_BURST_PROFILE_11', 'DIUC_GAP', 'DIUC_END_OF_MAP'], outer_class=root_module['ns3::OfdmDlBurstProfile'])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe [class]
module.add_class('OfdmDlMapIe')
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile [class]
module.add_class('OfdmUlBurstProfile')
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::Uiuc [enumeration]
module.add_enum('Uiuc', ['UIUC_INITIAL_RANGING', 'UIUC_REQ_REGION_FULL', 'UIUC_REQ_REGION_FOCUSED', 'UIUC_FOCUSED_CONTENTION_IE', 'UIUC_BURST_PROFILE_5', 'UIUC_BURST_PROFILE_6', 'UIUC_BURST_PROFILE_7', 'UIUC_BURST_PROFILE_8', 'UIUC_BURST_PROFILE_9', 'UIUC_BURST_PROFILE_10', 'UIUC_BURST_PROFILE_11', 'UIUC_BURST_PROFILE_12', 'UIUC_SUBCH_NETWORK_ENTRY', 'UIUC_END_OF_MAP'], outer_class=root_module['ns3::OfdmUlBurstProfile'])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe [class]
module.add_class('OfdmUlMapIe')
## packet-metadata.h (module 'network'): ns3::PacketMetadata [class]
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::ItemIterator [class]
module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata'])
## packet.h (module 'network'): ns3::PacketTagIterator [class]
module.add_class('PacketTagIterator', import_from_module='ns.network')
## packet.h (module 'network'): ns3::PacketTagIterator::Item [class]
module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagIterator'])
## packet-tag-list.h (module 'network'): ns3::PacketTagList [class]
module.add_class('PacketTagList', import_from_module='ns.network')
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData [struct]
module.add_class('TagData', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagList'])
## pcap-file.h (module 'network'): ns3::PcapFile [class]
module.add_class('PcapFile', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelper [class]
module.add_class('PcapHelper', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelper [enumeration]
module.add_enum('', ['DLT_NULL', 'DLT_EN10MB', 'DLT_PPP', 'DLT_RAW', 'DLT_IEEE802_11', 'DLT_PRISM_HEADER', 'DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'], import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice [class]
module.add_class('PcapHelperForDevice', allow_subclassing=True, import_from_module='ns.network')
## random-variable.h (module 'core'): ns3::RandomVariable [class]
module.add_class('RandomVariable', import_from_module='ns.core')
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager [class]
module.add_class('SNRToBlockErrorRateManager')
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord [class]
module.add_class('SNRToBlockErrorRateRecord')
## ss-record.h (module 'wimax'): ns3::SSRecord [class]
module.add_class('SSRecord')
## random-variable.h (module 'core'): ns3::SeedManager [class]
module.add_class('SeedManager', import_from_module='ns.core')
## send-params.h (module 'wimax'): ns3::SendParams [class]
module.add_class('SendParams')
## random-variable.h (module 'core'): ns3::SequentialVariable [class]
module.add_class('SequentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow [class]
module.add_class('ServiceFlow')
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Direction [enumeration]
module.add_enum('Direction', ['SF_DIRECTION_DOWN', 'SF_DIRECTION_UP'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Type [enumeration]
module.add_enum('Type', ['SF_TYPE_PROVISIONED', 'SF_TYPE_ADMITTED', 'SF_TYPE_ACTIVE'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType [enumeration]
module.add_enum('SchedulingType', ['SF_TYPE_NONE', 'SF_TYPE_UNDEF', 'SF_TYPE_BE', 'SF_TYPE_NRTPS', 'SF_TYPE_RTPS', 'SF_TYPE_UGS', 'SF_TYPE_ALL'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::CsSpecification [enumeration]
module.add_enum('CsSpecification', ['ATM', 'IPV4', 'IPV6', 'ETHERNET', 'VLAN', 'IPV4_OVER_ETHERNET', 'IPV6_OVER_ETHERNET', 'IPV4_OVER_VLAN', 'IPV6_OVER_VLAN'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ModulationType [enumeration]
module.add_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'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord [class]
module.add_class('ServiceFlowRecord')
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
## simulator.h (module 'core'): ns3::Simulator [class]
module.add_class('Simulator', destructor_visibility='private', import_from_module='ns.core')
## tag.h (module 'network'): ns3::Tag [class]
module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## tag-buffer.h (module 'network'): ns3::TagBuffer [class]
module.add_class('TagBuffer', import_from_module='ns.network')
## wimax-tlv.h (module 'wimax'): ns3::TlvValue [class]
module.add_class('TlvValue', allow_subclassing=True)
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue [class]
module.add_class('TosTlvValue', parent=root_module['ns3::TlvValue'])
## random-variable.h (module 'core'): ns3::TriangularVariable [class]
module.add_class('TriangularVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## type-id.h (module 'core'): ns3::TypeId [class]
module.add_class('TypeId', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation [struct]
module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct]
module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue [class]
module.add_class('U16TlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue [class]
module.add_class('U32TlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue [class]
module.add_class('U8TlvValue', parent=root_module['ns3::TlvValue'])
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings [class]
module.add_class('UcdChannelEncodings', allow_subclassing=True)
## random-variable.h (module 'core'): ns3::UniformVariable [class]
module.add_class('UniformVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue [class]
module.add_class('VectorTlvValue', parent=root_module['ns3::TlvValue'])
## random-variable.h (module 'core'): ns3::WeibullVariable [class]
module.add_class('WeibullVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper [class]
module.add_class('WimaxHelper', parent=[root_module['ns3::PcapHelperForDevice'], root_module['ns3::AsciiTraceHelperForDevice']])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::NetDeviceType [enumeration]
module.add_enum('NetDeviceType', ['DEVICE_TYPE_SUBSCRIBER_STATION', 'DEVICE_TYPE_BASE_STATION'], outer_class=root_module['ns3::WimaxHelper'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::PhyType [enumeration]
module.add_enum('PhyType', ['SIMPLE_PHY_TYPE_OFDM'], outer_class=root_module['ns3::WimaxHelper'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::SchedulerType [enumeration]
module.add_enum('SchedulerType', ['SCHED_TYPE_SIMPLE', 'SCHED_TYPE_RTPS', 'SCHED_TYPE_MBQOS'], outer_class=root_module['ns3::WimaxHelper'])
## random-variable.h (module 'core'): ns3::ZetaVariable [class]
module.add_class('ZetaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ZipfVariable [class]
module.add_class('ZipfVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## 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]
module.add_class('int64x64_t', import_from_module='ns.core')
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam [class]
module.add_class('simpleOfdmSendParam')
## chunk.h (module 'network'): ns3::Chunk [class]
module.add_class('Chunk', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue [class]
module.add_class('ClassificationRuleVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleTlvType [enumeration]
module.add_enum('ClassificationRuleTlvType', ['Priority', 'ToS', 'Protocol', 'IP_src', 'IP_dst', 'Port_src', 'Port_dst', 'Index'], outer_class=root_module['ns3::ClassificationRuleVectorTlvValue'])
## random-variable.h (module 'core'): ns3::ConstantVariable [class]
module.add_class('ConstantVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue [class]
module.add_class('CsParamVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::Type [enumeration]
module.add_enum('Type', ['Classifier_DSC_Action', 'Packet_Classification_Rule'], outer_class=root_module['ns3::CsParamVectorTlvValue'])
## random-variable.h (module 'core'): ns3::DeterministicVariable [class]
module.add_class('DeterministicVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::EmpiricalVariable [class]
module.add_class('EmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ErlangVariable [class]
module.add_class('ErlangVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ExponentialVariable [class]
module.add_class('ExponentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::GammaVariable [class]
module.add_class('GammaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## header.h (module 'network'): ns3::Header [class]
module.add_class('Header', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable [class]
module.add_class('IntEmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::EmpiricalVariable'])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue [class]
module.add_class('Ipv4AddressTlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr [struct]
module.add_class('ipv4Addr', outer_class=root_module['ns3::Ipv4AddressTlvValue'])
## random-variable.h (module 'core'): ns3::LogNormalVariable [class]
module.add_class('LogNormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType [class]
module.add_class('MacHeaderType', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::HeaderType [enumeration]
module.add_enum('HeaderType', ['HEADER_TYPE_GENERIC', 'HEADER_TYPE_BANDWIDTH'], outer_class=root_module['ns3::MacHeaderType'])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType [class]
module.add_class('ManagementMessageType', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::MessageType [enumeration]
module.add_enum('MessageType', ['MESSAGE_TYPE_UCD', 'MESSAGE_TYPE_DCD', 'MESSAGE_TYPE_DL_MAP', 'MESSAGE_TYPE_UL_MAP', 'MESSAGE_TYPE_RNG_REQ', 'MESSAGE_TYPE_RNG_RSP', 'MESSAGE_TYPE_REG_REQ', 'MESSAGE_TYPE_REG_RSP', 'MESSAGE_TYPE_DSA_REQ', 'MESSAGE_TYPE_DSA_RSP', 'MESSAGE_TYPE_DSA_ACK'], outer_class=root_module['ns3::ManagementMessageType'])
## random-variable.h (module 'core'): ns3::NormalVariable [class]
module.add_class('NormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## object.h (module 'core'): ns3::Object [class]
module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
## object.h (module 'core'): ns3::Object::AggregateIterator [class]
module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix [class]
module.add_class('OfdmDownlinkFramePrefix', parent=root_module['ns3::Header'])
## send-params.h (module 'wimax'): ns3::OfdmSendParams [class]
module.add_class('OfdmSendParams', parent=root_module['ns3::SendParams'])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings [class]
module.add_class('OfdmUcdChannelEncodings', parent=root_module['ns3::UcdChannelEncodings'])
## packet-burst.h (module 'network'): ns3::PacketBurst [class]
module.add_class('PacketBurst', import_from_module='ns.network', parent=root_module['ns3::Object'])
## random-variable.h (module 'core'): ns3::ParetoVariable [class]
module.add_class('ParetoVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## pcap-file-wrapper.h (module 'network'): ns3::PcapFileWrapper [class]
module.add_class('PcapFileWrapper', import_from_module='ns.network', parent=root_module['ns3::Object'])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue [class]
module.add_class('PortRangeTlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange [struct]
module.add_class('PortRange', outer_class=root_module['ns3::PortRangeTlvValue'])
## ul-job.h (module 'wimax'): ns3::PriorityUlJob [class]
module.add_class('PriorityUlJob', parent=root_module['ns3::Object'])
## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel [class]
module.add_class('PropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::Object'])
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue [class]
module.add_class('ProtocolTlvValue', parent=root_module['ns3::TlvValue'])
## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel [class]
module.add_class('RandomPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel [class]
module.add_class('RangePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## mac-messages.h (module 'wimax'): ns3::RngReq [class]
module.add_class('RngReq', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::RngRsp [class]
module.add_class('RngRsp', parent=root_module['ns3::Header'])
## ss-manager.h (module 'wimax'): ns3::SSManager [class]
module.add_class('SSManager', parent=root_module['ns3::Object'])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager [class]
module.add_class('ServiceFlowManager', parent=root_module['ns3::Object'])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::ServiceFlowManager'])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue [class]
module.add_class('SfVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::Type [enumeration]
module.add_enum('Type', ['SFID', 'CID', 'Service_Class_Name', 'reserved1', 'QoS_Parameter_Set_Type', 'Traffic_Priority', 'Maximum_Sustained_Traffic_Rate', 'Maximum_Traffic_Burst', 'Minimum_Reserved_Traffic_Rate', 'Minimum_Tolerable_Traffic_Rate', 'Service_Flow_Scheduling_Type', 'Request_Transmission_Policy', 'Tolerated_Jitter', 'Maximum_Latency', 'Fixed_length_versus_Variable_length_SDU_Indicator', 'SDU_Size', 'Target_SAID', 'ARQ_Enable', 'ARQ_WINDOW_SIZE', 'ARQ_RETRY_TIMEOUT_Transmitter_Delay', 'ARQ_RETRY_TIMEOUT_Receiver_Delay', 'ARQ_BLOCK_LIFETIME', 'ARQ_SYNC_LOSS', 'ARQ_DELIVER_IN_ORDER', 'ARQ_PURGE_TIMEOUT', 'ARQ_BLOCK_SIZE', 'reserved2', 'CS_Specification', 'IPV4_CS_Parameters'], outer_class=root_module['ns3::SfVectorTlvValue'])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeAccessor>'], 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<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeChecker>'], 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<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeValue>'], 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<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter<ns3::CallbackImplBase>'], 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<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], 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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::NixVector', 'ns3::empty', 'ns3::DefaultDeleter<ns3::NixVector>'], 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<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::OutputStreamWrapper', 'ns3::empty', 'ns3::DefaultDeleter<ns3::OutputStreamWrapper>'], 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<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Packet>'], 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<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::TraceSourceAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager [class]
module.add_class('SsServiceFlowManager', parent=root_module['ns3::ServiceFlowManager'])
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::SsServiceFlowManager'])
## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel [class]
module.add_class('ThreeLogDistancePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## nstime.h (module 'core'): ns3::Time [class]
module.add_class('Time', import_from_module='ns.core')
## nstime.h (module 'core'): ns3::Time::Unit [enumeration]
module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')
## nstime.h (module 'core'): ns3::Time [class]
root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t'])
## wimax-tlv.h (module 'wimax'): ns3::Tlv [class]
module.add_class('Tlv', parent=root_module['ns3::Header'])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::CommonTypes [enumeration]
module.add_enum('CommonTypes', ['HMAC_TUPLE', 'MAC_VERSION_ENCODING', 'CURRENT_TRANSMIT_POWER', 'DOWNLINK_SERVICE_FLOW', 'UPLINK_SERVICE_FLOW', 'VENDOR_ID_EMCODING', 'VENDOR_SPECIFIC_INFORMATION'], outer_class=root_module['ns3::Tlv'])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]
module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
## trailer.h (module 'network'): ns3::Trailer [class]
module.add_class('Trailer', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel [class]
module.add_class('TwoRayGroundPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## ul-mac-messages.h (module 'wimax'): ns3::Ucd [class]
module.add_class('Ucd', parent=root_module['ns3::Header'])
## ul-job.h (module 'wimax'): ns3::UlJob [class]
module.add_class('UlJob', parent=root_module['ns3::Object'])
## ul-job.h (module 'wimax'): ns3::UlJob::JobPriority [enumeration]
module.add_enum('JobPriority', ['LOW', 'INTERMEDIATE', 'HIGH'], outer_class=root_module['ns3::UlJob'])
## ul-mac-messages.h (module 'wimax'): ns3::UlMap [class]
module.add_class('UlMap', parent=root_module['ns3::Header'])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler [class]
module.add_class('UplinkScheduler', parent=root_module['ns3::Object'])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS [class]
module.add_class('UplinkSchedulerMBQoS', parent=root_module['ns3::UplinkScheduler'])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps [class]
module.add_class('UplinkSchedulerRtps', parent=root_module['ns3::UplinkScheduler'])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple [class]
module.add_class('UplinkSchedulerSimple', parent=root_module['ns3::UplinkScheduler'])
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection [class]
module.add_class('WimaxConnection', parent=root_module['ns3::Object'])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue [class]
module.add_class('WimaxMacQueue', parent=root_module['ns3::Object'])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader [class]
module.add_class('WimaxMacToMacHeader', parent=root_module['ns3::Header'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy [class]
module.add_class('WimaxPhy', parent=root_module['ns3::Object'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::ModulationType [enumeration]
module.add_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'], outer_class=root_module['ns3::WimaxPhy'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyState [enumeration]
module.add_enum('PhyState', ['PHY_STATE_IDLE', 'PHY_STATE_SCANNING', 'PHY_STATE_TX', 'PHY_STATE_RX'], outer_class=root_module['ns3::WimaxPhy'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType [enumeration]
module.add_enum('PhyType', ['SimpleWimaxPhy', 'simpleOfdmWimaxPhy'], outer_class=root_module['ns3::WimaxPhy'])
## attribute.h (module 'core'): ns3::AttributeAccessor [class]
module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
## attribute.h (module 'core'): ns3::AttributeChecker [class]
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<ns3::AttributeChecker> >'])
## 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<ns3::AttributeValue> >'])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler [class]
module.add_class('BSScheduler', parent=root_module['ns3::Object'])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps [class]
module.add_class('BSSchedulerRtps', parent=root_module['ns3::BSScheduler'])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple [class]
module.add_class('BSSchedulerSimple', parent=root_module['ns3::BSScheduler'])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader [class]
module.add_class('BandwidthRequestHeader', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::HeaderType [enumeration]
module.add_enum('HeaderType', ['HEADER_TYPE_INCREMENTAL', 'HEADER_TYPE_AGGREGATE'], outer_class=root_module['ns3::BandwidthRequestHeader'])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager [class]
module.add_class('BsServiceFlowManager', parent=root_module['ns3::ServiceFlowManager'])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::BsServiceFlowManager'])
## callback.h (module 'core'): ns3::CallbackChecker [class]
module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## callback.h (module 'core'): ns3::CallbackImplBase [class]
module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
## callback.h (module 'core'): ns3::CallbackValue [class]
module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## channel.h (module 'network'): ns3::Channel [class]
module.add_class('Channel', import_from_module='ns.network', parent=root_module['ns3::Object'])
## connection-manager.h (module 'wimax'): ns3::ConnectionManager [class]
module.add_class('ConnectionManager', parent=root_module['ns3::Object'])
## dl-mac-messages.h (module 'wimax'): ns3::Dcd [class]
module.add_class('Dcd', parent=root_module['ns3::Header'])
## dl-mac-messages.h (module 'wimax'): ns3::DlMap [class]
module.add_class('DlMap', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaAck [class]
module.add_class('DsaAck', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaReq [class]
module.add_class('DsaReq', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaRsp [class]
module.add_class('DsaRsp', parent=root_module['ns3::Header'])
## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]
module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## event-impl.h (module 'core'): ns3::EventImpl [class]
module.add_class('EventImpl', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel [class]
module.add_class('FixedRssLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader [class]
module.add_class('FragmentationSubheader', parent=root_module['ns3::Header'])
## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel [class]
module.add_class('FriisPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader [class]
module.add_class('GenericMacHeader', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader [class]
module.add_class('GrantManagementSubheader', parent=root_module['ns3::Header'])
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier [class]
module.add_class('IpcsClassifier', parent=root_module['ns3::Object'])
## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker [class]
module.add_class('Ipv4AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue [class]
module.add_class('Ipv4AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker [class]
module.add_class('Ipv4MaskChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue [class]
module.add_class('Ipv4MaskValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
module.add_class('Ipv6PrefixValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel [class]
module.add_class('LogDistancePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## mac48-address.h (module 'network'): ns3::Mac48AddressChecker [class]
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'])
## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class]
module.add_class('MatrixPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel [class]
module.add_class('NakagamiPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## 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]
module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'], import_from_module='ns.network')
## nix-vector.h (module 'network'): ns3::NixVector [class]
module.add_class('NixVector', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
## node.h (module 'network'): ns3::Node [class]
module.add_class('Node', import_from_module='ns.network', parent=root_module['ns3::Object'])
## object-factory.h (module 'core'): ns3::ObjectFactoryChecker [class]
module.add_class('ObjectFactoryChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## object-factory.h (module 'core'): ns3::ObjectFactoryValue [class]
module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper [class]
module.add_class('OutputStreamWrapper', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
## packet.h (module 'network'): ns3::Packet [class]
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
## random-variable.h (module 'core'): ns3::RandomVariableChecker [class]
module.add_class('RandomVariableChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## random-variable.h (module 'core'): ns3::RandomVariableValue [class]
module.add_class('RandomVariableValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy [class]
module.add_class('SimpleOfdmWimaxPhy', parent=root_module['ns3::WimaxPhy'])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::FrameDurationCode [enumeration]
module.add_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'], outer_class=root_module['ns3::SimpleOfdmWimaxPhy'])
## nstime.h (module 'core'): ns3::TimeChecker [class]
module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## type-id.h (module 'core'): ns3::TypeIdValue [class]
module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## uinteger.h (module 'core'): ns3::UintegerValue [class]
module.add_class('UintegerValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel [class]
module.add_class('WimaxChannel', parent=root_module['ns3::Channel'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice [class]
module.add_class('WimaxNetDevice', parent=root_module['ns3::NetDevice'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::Direction [enumeration]
module.add_enum('Direction', ['DIRECTION_DOWNLINK', 'DIRECTION_UPLINK'], outer_class=root_module['ns3::WimaxNetDevice'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::RangingStatus [enumeration]
module.add_enum('RangingStatus', ['RANGING_STATUS_EXPIRED', 'RANGING_STATUS_CONTINUE', 'RANGING_STATUS_ABORT', 'RANGING_STATUS_SUCCESS'], outer_class=root_module['ns3::WimaxNetDevice'])
## address.h (module 'network'): ns3::AddressChecker [class]
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'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice [class]
module.add_class('BaseStationNetDevice', parent=root_module['ns3::WimaxNetDevice'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::State [enumeration]
module.add_enum('State', ['BS_STATE_DL_SUB_FRAME', 'BS_STATE_UL_SUB_FRAME', 'BS_STATE_TTG', 'BS_STATE_RTG'], outer_class=root_module['ns3::BaseStationNetDevice'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::MacPreamble [enumeration]
module.add_enum('MacPreamble', ['SHORT_PREAMBLE', 'LONG_PREAMBLE'], outer_class=root_module['ns3::BaseStationNetDevice'])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel [class]
module.add_class('SimpleOfdmWimaxChannel', parent=root_module['ns3::WimaxChannel'])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::PropModel [enumeration]
module.add_enum('PropModel', ['RANDOM_PROPAGATION', 'FRIIS_PROPAGATION', 'LOG_DISTANCE_PROPAGATION', 'COST231_PROPAGATION'], outer_class=root_module['ns3::SimpleOfdmWimaxChannel'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice [class]
module.add_class('SubscriberStationNetDevice', parent=root_module['ns3::WimaxNetDevice'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::State [enumeration]
module.add_enum('State', ['SS_STATE_IDLE', 'SS_STATE_SCANNING', 'SS_STATE_SYNCHRONIZING', 'SS_STATE_ACQUIRING_PARAMETERS', 'SS_STATE_WAITING_REG_RANG_INTRVL', 'SS_STATE_WAITING_INV_RANG_INTRVL', 'SS_STATE_WAITING_RNG_RSP', 'SS_STATE_ADJUSTING_PARAMETERS', 'SS_STATE_REGISTERED', 'SS_STATE_TRANSMITTING', 'SS_STATE_STOPPED'], outer_class=root_module['ns3::SubscriberStationNetDevice'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::EventType [enumeration]
module.add_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'], outer_class=root_module['ns3::SubscriberStationNetDevice'])
module.add_container('std::vector< ns3::ServiceFlow * >', 'ns3::ServiceFlow *', container_type='vector')
module.add_container('std::vector< bool >', 'bool', container_type='vector')
module.add_container('ns3::bvec', 'bool', container_type='vector')
module.add_container('std::vector< ns3::DlFramePrefixIe >', 'ns3::DlFramePrefixIe', container_type='vector')
module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type='list')
module.add_container('std::vector< ns3::SSRecord * >', 'ns3::SSRecord *', container_type='vector')
module.add_container('std::vector< ns3::OfdmUlBurstProfile >', 'ns3::OfdmUlBurstProfile', container_type='vector')
module.add_container('std::list< ns3::OfdmUlMapIe >', 'ns3::OfdmUlMapIe', container_type='list')
module.add_container('std::list< ns3::Ptr< ns3::UlJob > >', 'ns3::Ptr< ns3::UlJob >', container_type='list')
module.add_container('std::list< ns3::Ptr< ns3::Packet const > >', 'ns3::Ptr< ns3::Packet const >', container_type='list')
module.add_container('std::deque< ns3::WimaxMacQueue::QueueElement >', 'ns3::WimaxMacQueue::QueueElement', container_type='dequeue')
module.add_container('std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > >', 'std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > >', container_type='list')
module.add_container('std::vector< ns3::Ptr< ns3::WimaxConnection > >', 'ns3::Ptr< ns3::WimaxConnection >', container_type='vector')
module.add_container('std::vector< ns3::OfdmDlBurstProfile >', 'ns3::OfdmDlBurstProfile', container_type='vector')
module.add_container('std::list< ns3::OfdmDlMapIe >', 'ns3::OfdmDlMapIe', container_type='list')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogNodePrinter')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogNodePrinter*')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogNodePrinter&')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogTimePrinter')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogTimePrinter*')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogTimePrinter&')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >', 'ns3::bvec')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >*', 'ns3::bvec*')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >&', 'ns3::bvec&')
## Register a nested module for the namespace FatalImpl
nested_module = module.add_cpp_namespace('FatalImpl')
register_types_ns3_FatalImpl(nested_module)
## Register a nested module for the namespace internal
nested_module = module.add_cpp_namespace('internal')
register_types_ns3_internal(nested_module)
def register_types_ns3_FatalImpl(module):
root_module = module.get_root()
def register_types_ns3_internal(module):
root_module = module.get_root()
def register_methods(root_module):
register_Ns3Address_methods(root_module, root_module['ns3::Address'])
register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
register_Ns3AsciiTraceHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceHelperForDevice'])
register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])
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'])
register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item'])
register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList'])
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_Ns3Cid_methods(root_module, root_module['ns3::Cid'])
register_Ns3CidFactory_methods(root_module, root_module['ns3::CidFactory'])
register_Ns3CsParameters_methods(root_module, root_module['ns3::CsParameters'])
register_Ns3DcdChannelEncodings_methods(root_module, root_module['ns3::DcdChannelEncodings'])
register_Ns3DlFramePrefixIe_methods(root_module, root_module['ns3::DlFramePrefixIe'])
register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
register_Ns3IpcsClassifierRecord_methods(root_module, root_module['ns3::IpcsClassifierRecord'])
register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3LogComponent_methods(root_module, root_module['ns3::LogComponent'])
register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])
register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
register_Ns3OfdmDcdChannelEncodings_methods(root_module, root_module['ns3::OfdmDcdChannelEncodings'])
register_Ns3OfdmDlBurstProfile_methods(root_module, root_module['ns3::OfdmDlBurstProfile'])
register_Ns3OfdmDlMapIe_methods(root_module, root_module['ns3::OfdmDlMapIe'])
register_Ns3OfdmUlBurstProfile_methods(root_module, root_module['ns3::OfdmUlBurstProfile'])
register_Ns3OfdmUlMapIe_methods(root_module, root_module['ns3::OfdmUlMapIe'])
register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator'])
register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item'])
register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList'])
register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData'])
register_Ns3PcapFile_methods(root_module, root_module['ns3::PcapFile'])
register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
register_Ns3PcapHelperForDevice_methods(root_module, root_module['ns3::PcapHelperForDevice'])
register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
register_Ns3SNRToBlockErrorRateManager_methods(root_module, root_module['ns3::SNRToBlockErrorRateManager'])
register_Ns3SNRToBlockErrorRateRecord_methods(root_module, root_module['ns3::SNRToBlockErrorRateRecord'])
register_Ns3SSRecord_methods(root_module, root_module['ns3::SSRecord'])
register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])
register_Ns3SendParams_methods(root_module, root_module['ns3::SendParams'])
register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
register_Ns3ServiceFlow_methods(root_module, root_module['ns3::ServiceFlow'])
register_Ns3ServiceFlowRecord_methods(root_module, root_module['ns3::ServiceFlowRecord'])
register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
register_Ns3TlvValue_methods(root_module, root_module['ns3::TlvValue'])
register_Ns3TosTlvValue_methods(root_module, root_module['ns3::TosTlvValue'])
register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
register_Ns3U16TlvValue_methods(root_module, root_module['ns3::U16TlvValue'])
register_Ns3U32TlvValue_methods(root_module, root_module['ns3::U32TlvValue'])
register_Ns3U8TlvValue_methods(root_module, root_module['ns3::U8TlvValue'])
register_Ns3UcdChannelEncodings_methods(root_module, root_module['ns3::UcdChannelEncodings'])
register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
register_Ns3VectorTlvValue_methods(root_module, root_module['ns3::VectorTlvValue'])
register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
register_Ns3WimaxHelper_methods(root_module, root_module['ns3::WimaxHelper'])
register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])
register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])
register_Ns3SimpleOfdmSendParam_methods(root_module, root_module['ns3::simpleOfdmSendParam'])
register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
register_Ns3ClassificationRuleVectorTlvValue_methods(root_module, root_module['ns3::ClassificationRuleVectorTlvValue'])
register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
register_Ns3CsParamVectorTlvValue_methods(root_module, root_module['ns3::CsParamVectorTlvValue'])
register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])
register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])
register_Ns3Header_methods(root_module, root_module['ns3::Header'])
register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
register_Ns3Ipv4AddressTlvValue_methods(root_module, root_module['ns3::Ipv4AddressTlvValue'])
register_Ns3Ipv4AddressTlvValueIpv4Addr_methods(root_module, root_module['ns3::Ipv4AddressTlvValue::ipv4Addr'])
register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
register_Ns3MacHeaderType_methods(root_module, root_module['ns3::MacHeaderType'])
register_Ns3ManagementMessageType_methods(root_module, root_module['ns3::ManagementMessageType'])
register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
register_Ns3Object_methods(root_module, root_module['ns3::Object'])
register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
register_Ns3OfdmDownlinkFramePrefix_methods(root_module, root_module['ns3::OfdmDownlinkFramePrefix'])
register_Ns3OfdmSendParams_methods(root_module, root_module['ns3::OfdmSendParams'])
register_Ns3OfdmUcdChannelEncodings_methods(root_module, root_module['ns3::OfdmUcdChannelEncodings'])
register_Ns3PacketBurst_methods(root_module, root_module['ns3::PacketBurst'])
register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
register_Ns3PcapFileWrapper_methods(root_module, root_module['ns3::PcapFileWrapper'])
register_Ns3PortRangeTlvValue_methods(root_module, root_module['ns3::PortRangeTlvValue'])
register_Ns3PortRangeTlvValuePortRange_methods(root_module, root_module['ns3::PortRangeTlvValue::PortRange'])
register_Ns3PriorityUlJob_methods(root_module, root_module['ns3::PriorityUlJob'])
register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
register_Ns3ProtocolTlvValue_methods(root_module, root_module['ns3::ProtocolTlvValue'])
register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])
register_Ns3RngReq_methods(root_module, root_module['ns3::RngReq'])
register_Ns3RngRsp_methods(root_module, root_module['ns3::RngRsp'])
register_Ns3SSManager_methods(root_module, root_module['ns3::SSManager'])
register_Ns3ServiceFlowManager_methods(root_module, root_module['ns3::ServiceFlowManager'])
register_Ns3SfVectorTlvValue_methods(root_module, root_module['ns3::SfVectorTlvValue'])
register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
register_Ns3SsServiceFlowManager_methods(root_module, root_module['ns3::SsServiceFlowManager'])
register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3Tlv_methods(root_module, root_module['ns3::Tlv'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
register_Ns3Ucd_methods(root_module, root_module['ns3::Ucd'])
register_Ns3UlJob_methods(root_module, root_module['ns3::UlJob'])
register_Ns3UlMap_methods(root_module, root_module['ns3::UlMap'])
register_Ns3UplinkScheduler_methods(root_module, root_module['ns3::UplinkScheduler'])
register_Ns3UplinkSchedulerMBQoS_methods(root_module, root_module['ns3::UplinkSchedulerMBQoS'])
register_Ns3UplinkSchedulerRtps_methods(root_module, root_module['ns3::UplinkSchedulerRtps'])
register_Ns3UplinkSchedulerSimple_methods(root_module, root_module['ns3::UplinkSchedulerSimple'])
register_Ns3WimaxConnection_methods(root_module, root_module['ns3::WimaxConnection'])
register_Ns3WimaxMacQueue_methods(root_module, root_module['ns3::WimaxMacQueue'])
register_Ns3WimaxMacToMacHeader_methods(root_module, root_module['ns3::WimaxMacToMacHeader'])
register_Ns3WimaxPhy_methods(root_module, root_module['ns3::WimaxPhy'])
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_Ns3BSScheduler_methods(root_module, root_module['ns3::BSScheduler'])
register_Ns3BSSchedulerRtps_methods(root_module, root_module['ns3::BSSchedulerRtps'])
register_Ns3BSSchedulerSimple_methods(root_module, root_module['ns3::BSSchedulerSimple'])
register_Ns3BandwidthRequestHeader_methods(root_module, root_module['ns3::BandwidthRequestHeader'])
register_Ns3BsServiceFlowManager_methods(root_module, root_module['ns3::BsServiceFlowManager'])
register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
register_Ns3ConnectionManager_methods(root_module, root_module['ns3::ConnectionManager'])
register_Ns3Dcd_methods(root_module, root_module['ns3::Dcd'])
register_Ns3DlMap_methods(root_module, root_module['ns3::DlMap'])
register_Ns3DsaAck_methods(root_module, root_module['ns3::DsaAck'])
register_Ns3DsaReq_methods(root_module, root_module['ns3::DsaReq'])
register_Ns3DsaRsp_methods(root_module, root_module['ns3::DsaRsp'])
register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
register_Ns3FragmentationSubheader_methods(root_module, root_module['ns3::FragmentationSubheader'])
register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
register_Ns3GenericMacHeader_methods(root_module, root_module['ns3::GenericMacHeader'])
register_Ns3GrantManagementSubheader_methods(root_module, root_module['ns3::GrantManagementSubheader'])
register_Ns3IpcsClassifier_methods(root_module, root_module['ns3::IpcsClassifier'])
register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
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'])
register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
register_Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::OutputStreamWrapper'])
register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
register_Ns3SimpleOfdmWimaxPhy_methods(root_module, root_module['ns3::SimpleOfdmWimaxPhy'])
register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
register_Ns3WimaxChannel_methods(root_module, root_module['ns3::WimaxChannel'])
register_Ns3WimaxNetDevice_methods(root_module, root_module['ns3::WimaxNetDevice'])
register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
register_Ns3BaseStationNetDevice_methods(root_module, root_module['ns3::BaseStationNetDevice'])
register_Ns3SimpleOfdmWimaxChannel_methods(root_module, root_module['ns3::SimpleOfdmWimaxChannel'])
register_Ns3SubscriberStationNetDevice_methods(root_module, root_module['ns3::SubscriberStationNetDevice'])
return
def register_Ns3Address_methods(root_module, cls):
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]
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')],
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')])
## 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')],
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')])
## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
cls.add_method('CopyTo',
'uint32_t',
[param('uint8_t *', 'buffer')],
is_const=True)
## address.h (module 'network'): void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
cls.add_method('Deserialize',
'void',
[param('ns3::TagBuffer', 'buffer')])
## address.h (module 'network'): uint8_t ns3::Address::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## address.h (module 'network'): uint32_t ns3::Address::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## address.h (module 'network'): bool ns3::Address::IsInvalid() const [member function]
cls.add_method('IsInvalid',
'bool',
[],
is_const=True)
## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
cls.add_method('IsMatchingType',
'bool',
[param('uint8_t', 'type')],
is_const=True)
## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function]
cls.add_method('Register',
'uint8_t',
[],
is_static=True)
## address.h (module 'network'): void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::TagBuffer', 'buffer')],
is_const=True)
return
def register_Ns3AsciiTraceHelper_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [copy 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::OutputStreamWrapper> ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::_Ios_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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('DefaultReceiveSinkWithoutContext',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')],
is_static=True)
## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> 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')])
return
def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceHelperForDevice const &', 'arg0')])
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice() [constructor]
cls.add_constructor([])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename=false) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, std::string ndName, bool explicitFilename=false) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'ndName')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::NodeContainer', 'n')])
## 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')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> 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')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('std::string', 'prefix')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamWrapper> stream) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AttributeConstructionList_methods(root_module, cls):
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy 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<ns3::AttributeChecker const> checker, ns3::Ptr<ns3::AttributeValue> 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::Item> ns3::AttributeConstructionList::Begin() const [member function]
cls.add_method('Begin',
'std::_List_const_iterator< ns3::AttributeConstructionList::Item >',
[],
is_const=True)
## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::End() const [member function]
cls.add_method('End',
'std::_List_const_iterator< ns3::AttributeConstructionList::Item >',
[],
is_const=True)
## attribute-construction-list.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeConstructionList::Find(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('Find',
'ns3::Ptr< ns3::AttributeValue >',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True)
return
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]
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)
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable]
cls.add_instance_attribute('value', 'ns3::Ptr< ns3::AttributeValue >', is_const=False)
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'): bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
cls.add_method('AddAtEnd',
'bool',
[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'): bool ns3::Buffer::AddAtStart(uint32_t start) [member function]
cls.add_method('AddAtStart',
'bool',
[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'): ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function]
cls.add_method('CreateFullCopy',
'ns3::Buffer',
[],
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'): int32_t ns3::Buffer::GetCurrentEndOffset() const [member function]
cls.add_method('GetCurrentEndOffset',
'int32_t',
[],
is_const=True)
## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentStartOffset() const [member function]
cls.add_method('GetCurrentStartOffset',
'int32_t',
[],
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',
'void',
[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('uint32_t', '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]
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')])
## 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')])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function]
cls.add_method('GetDistanceFrom',
'uint32_t',
[param('ns3::Buffer::Iterator const &', 'o')],
is_const=True)
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsEnd() const [member function]
cls.add_method('IsEnd',
'bool',
[],
is_const=True)
## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsStart() const [member function]
cls.add_method('IsStart',
'bool',
[],
is_const=True)
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next() [member function]
cls.add_method('Next',
'void',
[])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function]
cls.add_method('Next',
'void',
[param('uint32_t', 'delta')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev() [member function]
cls.add_method('Prev',
'void',
[])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function]
cls.add_method('Prev',
'void',
[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('uint32_t', 'size')])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function]
cls.add_method('ReadLsbtohU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function]
cls.add_method('ReadLsbtohU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function]
cls.add_method('ReadLsbtohU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function]
cls.add_method('ReadNtohU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function]
cls.add_method('ReadNtohU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function]
cls.add_method('ReadNtohU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadU16() [member function]
cls.add_method('ReadU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadU32() [member function]
cls.add_method('ReadU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadU64() [member function]
cls.add_method('ReadU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::ReadU8() [member function]
cls.add_method('ReadU8',
'uint8_t',
[])
## 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')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function]
cls.add_method('Write',
'void',
[param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function]
cls.add_method('WriteHtolsbU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function]
cls.add_method('WriteHtolsbU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function]
cls.add_method('WriteHtolsbU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function]
cls.add_method('WriteHtonU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function]
cls.add_method('WriteHtonU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function]
cls.add_method('WriteHtonU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function]
cls.add_method('WriteU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function]
cls.add_method('WriteU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function]
cls.add_method('WriteU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function]
cls.add_method('WriteU8',
'void',
[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('uint8_t', 'data'), param('uint32_t', 'len')])
return
def register_Ns3ByteTagIterator_methods(root_module, cls):
## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')])
## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet.h (module 'network'): ns3::ByteTagIterator::Item ns3::ByteTagIterator::Next() [member function]
cls.add_method('Next',
'ns3::ByteTagIterator::Item',
[])
return
def register_Ns3ByteTagIteratorItem_methods(root_module, cls):
## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy 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',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetStart() const [member function]
cls.add_method('GetStart',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): void ns3::ByteTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
cls.add_method('GetTag',
'void',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::TypeId ns3::ByteTagIterator::Item::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
return
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]
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')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function]
cls.add_method('Add',
'void',
[param('ns3::ByteTagList const &', 'o')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function]
cls.add_method('AddAtEnd',
'void',
[param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function]
cls.add_method('AddAtStart',
'void',
[param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])
## 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')],
is_const=True)
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function]
cls.add_method('RemoveAll',
'void',
[])
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]
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',
'uint32_t',
[],
is_const=True)
## byte-tag-list.h (module 'network'): bool ns3::ByteTagList::Iterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item ns3::ByteTagList::Iterator::Next() [member function]
cls.add_method('Next',
'ns3::ByteTagList::Iterator::Item',
[])
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]
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')])
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::buf [variable]
cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::end [variable]
cls.add_instance_attribute('end', 'int32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::size [variable]
cls.add_instance_attribute('size', 'uint32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::start [variable]
cls.add_instance_attribute('start', 'int32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::tid [variable]
cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
return
def register_Ns3CallbackBase_methods(root_module, cls):
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor]
cls.add_constructor([])
## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
cls.add_method('GetImpl',
'ns3::Ptr< ns3::CallbackImplBase >',
[],
is_const=True)
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')],
visibility='protected')
## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]
cls.add_method('Demangle',
'std::string',
[param('std::string const &', 'mangled')],
is_static=True, visibility='protected')
return
def register_Ns3Cid_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
cls.add_binary_comparison_operator('==')
## cid.h (module 'wimax'): ns3::Cid::Cid(ns3::Cid const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Cid const &', 'arg0')])
## cid.h (module 'wimax'): ns3::Cid::Cid() [constructor]
cls.add_constructor([])
## cid.h (module 'wimax'): ns3::Cid::Cid(uint16_t cid) [constructor]
cls.add_constructor([param('uint16_t', 'cid')])
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::Broadcast() [member function]
cls.add_method('Broadcast',
'ns3::Cid',
[],
is_static=True)
## cid.h (module 'wimax'): uint16_t ns3::Cid::GetIdentifier() const [member function]
cls.add_method('GetIdentifier',
'uint16_t',
[],
is_const=True)
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::InitialRanging() [member function]
cls.add_method('InitialRanging',
'ns3::Cid',
[],
is_static=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsInitialRanging() const [member function]
cls.add_method('IsInitialRanging',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsPadding() const [member function]
cls.add_method('IsPadding',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::Padding() [member function]
cls.add_method('Padding',
'ns3::Cid',
[],
is_static=True)
return
def register_Ns3CidFactory_methods(root_module, cls):
## cid-factory.h (module 'wimax'): ns3::CidFactory::CidFactory(ns3::CidFactory const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CidFactory const &', 'arg0')])
## cid-factory.h (module 'wimax'): ns3::CidFactory::CidFactory() [constructor]
cls.add_constructor([])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::Allocate(ns3::Cid::Type type) [member function]
cls.add_method('Allocate',
'ns3::Cid',
[param('ns3::Cid::Type', 'type')])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateBasic() [member function]
cls.add_method('AllocateBasic',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateMulticast() [member function]
cls.add_method('AllocateMulticast',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocatePrimary() [member function]
cls.add_method('AllocatePrimary',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateTransportOrSecondary() [member function]
cls.add_method('AllocateTransportOrSecondary',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): void ns3::CidFactory::FreeCid(ns3::Cid cid) [member function]
cls.add_method('FreeCid',
'void',
[param('ns3::Cid', 'cid')])
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsBasic(ns3::Cid cid) const [member function]
cls.add_method('IsBasic',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsPrimary(ns3::Cid cid) const [member function]
cls.add_method('IsPrimary',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsTransport(ns3::Cid cid) const [member function]
cls.add_method('IsTransport',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
return
def register_Ns3CsParameters_methods(root_module, cls):
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::CsParameters const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CsParameters const &', 'arg0')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters() [constructor]
cls.add_constructor([])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::CsParameters::Action classifierDscAction, ns3::IpcsClassifierRecord classifier) [constructor]
cls.add_constructor([param('ns3::CsParameters::Action', 'classifierDscAction'), param('ns3::IpcsClassifierRecord', 'classifier')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::Action ns3::CsParameters::GetClassifierDscAction() const [member function]
cls.add_method('GetClassifierDscAction',
'ns3::CsParameters::Action',
[],
is_const=True)
## cs-parameters.h (module 'wimax'): ns3::IpcsClassifierRecord ns3::CsParameters::GetPacketClassifierRule() const [member function]
cls.add_method('GetPacketClassifierRule',
'ns3::IpcsClassifierRecord',
[],
is_const=True)
## cs-parameters.h (module 'wimax'): void ns3::CsParameters::SetClassifierDscAction(ns3::CsParameters::Action action) [member function]
cls.add_method('SetClassifierDscAction',
'void',
[param('ns3::CsParameters::Action', 'action')])
## cs-parameters.h (module 'wimax'): void ns3::CsParameters::SetPacketClassifierRule(ns3::IpcsClassifierRecord packetClassifierRule) [member function]
cls.add_method('SetPacketClassifierRule',
'void',
[param('ns3::IpcsClassifierRecord', 'packetClassifierRule')])
## cs-parameters.h (module 'wimax'): ns3::Tlv ns3::CsParameters::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
return
def register_Ns3DcdChannelEncodings_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings::DcdChannelEncodings(ns3::DcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DcdChannelEncodings const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings::DcdChannelEncodings() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetBsEirp() const [member function]
cls.add_method('GetBsEirp',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetEirxPIrMax() const [member function]
cls.add_method('GetEirxPIrMax',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DcdChannelEncodings::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetBsEirp(uint16_t bs_eirp) [member function]
cls.add_method('SetBsEirp',
'void',
[param('uint16_t', 'bs_eirp')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetEirxPIrMax(uint16_t rss_ir_max) [member function]
cls.add_method('SetEirxPIrMax',
'void',
[param('uint16_t', 'rss_ir_max')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3DlFramePrefixIe_methods(root_module, cls):
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe::DlFramePrefixIe(ns3::DlFramePrefixIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DlFramePrefixIe const &', 'arg0')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe::DlFramePrefixIe() [constructor]
cls.add_constructor([])
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetLength() const [member function]
cls.add_method('GetLength',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetPreamblePresent() const [member function]
cls.add_method('GetPreamblePresent',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetRateId() const [member function]
cls.add_method('GetRateId',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Buffer::Iterator ns3::DlFramePrefixIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetLength(uint16_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint16_t', 'length')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetPreamblePresent(uint8_t preamblePresent) [member function]
cls.add_method('SetPreamblePresent',
'void',
[param('uint8_t', 'preamblePresent')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetRateId(uint8_t rateId) [member function]
cls.add_method('SetRateId',
'void',
[param('uint8_t', 'rateId')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Buffer::Iterator ns3::DlFramePrefixIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
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_constructor([param('ns3::EventId const &', 'arg0')])
## event-id.h (module 'core'): ns3::EventId::EventId() [constructor]
cls.add_constructor([])
## event-id.h (module 'core'): ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])
## event-id.h (module 'core'): void ns3::EventId::Cancel() [member function]
cls.add_method('Cancel',
'void',
[])
## event-id.h (module 'core'): uint32_t ns3::EventId::GetContext() const [member function]
cls.add_method('GetContext',
'uint32_t',
[],
is_const=True)
## event-id.h (module 'core'): uint64_t ns3::EventId::GetTs() const [member function]
cls.add_method('GetTs',
'uint64_t',
[],
is_const=True)
## event-id.h (module 'core'): uint32_t ns3::EventId::GetUid() const [member function]
cls.add_method('GetUid',
'uint32_t',
[],
is_const=True)
## event-id.h (module 'core'): bool ns3::EventId::IsExpired() const [member function]
cls.add_method('IsExpired',
'bool',
[],
is_const=True)
## event-id.h (module 'core'): bool ns3::EventId::IsRunning() const [member function]
cls.add_method('IsRunning',
'bool',
[],
is_const=True)
## event-id.h (module 'core'): ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]
cls.add_method('PeekEventImpl',
'ns3::EventImpl *',
[],
is_const=True)
return
def register_Ns3IpcsClassifierRecord_methods(root_module, cls):
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::IpcsClassifierRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IpcsClassifierRecord const &', 'arg0')])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord() [constructor]
cls.add_constructor([])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::Ipv4Address srcAddress, ns3::Ipv4Mask srcMask, ns3::Ipv4Address dstAddress, ns3::Ipv4Mask dstMask, uint16_t srcPortLow, uint16_t srcPortHigh, uint16_t dstPortLow, uint16_t dstPortHigh, uint8_t protocol, uint8_t priority) [constructor]
cls.add_constructor([param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Mask', 'srcMask'), param('ns3::Ipv4Address', 'dstAddress'), param('ns3::Ipv4Mask', 'dstMask'), param('uint16_t', 'srcPortLow'), param('uint16_t', 'srcPortHigh'), param('uint16_t', 'dstPortLow'), param('uint16_t', 'dstPortHigh'), param('uint8_t', 'protocol'), param('uint8_t', 'priority')])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddDstAddr(ns3::Ipv4Address dstAddress, ns3::Ipv4Mask dstMask) [member function]
cls.add_method('AddDstAddr',
'void',
[param('ns3::Ipv4Address', 'dstAddress'), param('ns3::Ipv4Mask', 'dstMask')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddDstPortRange(uint16_t dstPortLow, uint16_t dstPortHigh) [member function]
cls.add_method('AddDstPortRange',
'void',
[param('uint16_t', 'dstPortLow'), param('uint16_t', 'dstPortHigh')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddProtocol(uint8_t proto) [member function]
cls.add_method('AddProtocol',
'void',
[param('uint8_t', 'proto')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddSrcAddr(ns3::Ipv4Address srcAddress, ns3::Ipv4Mask srcMask) [member function]
cls.add_method('AddSrcAddr',
'void',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Mask', 'srcMask')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddSrcPortRange(uint16_t srcPortLow, uint16_t srcPortHigh) [member function]
cls.add_method('AddSrcPortRange',
'void',
[param('uint16_t', 'srcPortLow'), param('uint16_t', 'srcPortHigh')])
## ipcs-classifier-record.h (module 'wimax'): bool ns3::IpcsClassifierRecord::CheckMatch(ns3::Ipv4Address srcAddress, ns3::Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const [member function]
cls.add_method('CheckMatch',
'bool',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Address', 'dstAddress'), param('uint16_t', 'srcPort'), param('uint16_t', 'dstPort'), param('uint8_t', 'proto')],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint16_t ns3::IpcsClassifierRecord::GetCid() const [member function]
cls.add_method('GetCid',
'uint16_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint16_t ns3::IpcsClassifierRecord::GetIndex() const [member function]
cls.add_method('GetIndex',
'uint16_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint8_t ns3::IpcsClassifierRecord::GetPriority() const [member function]
cls.add_method('GetPriority',
'uint8_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetCid(uint16_t cid) [member function]
cls.add_method('SetCid',
'void',
[param('uint16_t', 'cid')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetIndex(uint16_t index) [member function]
cls.add_method('SetIndex',
'void',
[param('uint16_t', 'index')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetPriority(uint8_t prio) [member function]
cls.add_method('SetPriority',
'void',
[param('uint8_t', 'prio')])
## ipcs-classifier-record.h (module 'wimax'): ns3::Tlv ns3::IpcsClassifierRecord::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
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_constructor([param('ns3::Ipv4Address const &', 'arg0')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor]
cls.add_constructor([])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
cls.add_constructor([param('uint32_t', 'address')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
cls.add_constructor([param('char const *', 'address')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('CombineMask',
'ns3::Ipv4Address',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Ipv4Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
cls.add_method('Deserialize',
'ns3::Ipv4Address',
[param('uint8_t const *', 'buf')],
is_static=True)
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Address::Get() const [member function]
cls.add_method('Get',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
cls.add_method('GetAny',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
cls.add_method('GetBroadcast',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('GetSubnetDirectedBroadcast',
'ns3::Ipv4Address',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv4Address const &', 'other')],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsLocalMulticast() const [member function]
cls.add_method('IsLocalMulticast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('IsSubnetDirectedBroadcast',
'bool',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
cls.add_method('Serialize',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function]
cls.add_method('Set',
'void',
[param('uint32_t', 'address')])
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function]
cls.add_method('Set',
'void',
[param('char const *', 'address')])
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_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor]
cls.add_constructor([])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
cls.add_constructor([param('uint32_t', 'mask')])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
cls.add_constructor([param('char const *', 'mask')])
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::Get() const [member function]
cls.add_method('Get',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
cls.add_method('GetInverse',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): uint16_t ns3::Ipv4Mask::GetPrefixLength() const [member function]
cls.add_method('GetPrefixLength',
'uint16_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv4Mask', 'other')],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
cls.add_method('IsMatch',
'bool',
[param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
cls.add_method('Set',
'void',
[param('uint32_t', '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('==')
## 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]
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')])
## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function]
cls.add_method('CombinePrefix',
'ns3::Ipv6Address',
[param('ns3::Ipv6Prefix const &', 'prefix')])
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Ipv6Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function]
cls.add_method('Deserialize',
'ns3::Ipv6Address',
[param('uint8_t const *', 'buf')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]
cls.add_method('GetAllHostsMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]
cls.add_method('GetAllNodesMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]
cls.add_method('GetAllRoutersMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]
cls.add_method('GetAny',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function]
cls.add_method('GetBytes',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]
cls.add_method('IsAllHostsMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]
cls.add_method('IsAllNodesMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]
cls.add_method('IsAllRoutersMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAny() const [member function]
cls.add_method('IsAny',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv6Address const &', 'other')],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocal() const [member function]
cls.add_method('IsLinkLocal',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLocalhost() const [member function]
cls.add_method('IsLocalhost',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]
cls.add_method('IsSolicitedMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function]
cls.add_method('MakeAutoconfiguredAddress',
'ns3::Ipv6Address',
[param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function]
cls.add_method('MakeAutoconfiguredLinkLocalAddress',
'ns3::Ipv6Address',
[param('ns3::Mac48Address', 'mac')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function]
cls.add_method('MakeSolicitedAddress',
'ns3::Ipv6Address',
[param('ns3::Ipv6Address', 'addr')],
is_static=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function]
cls.add_method('Serialize',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(char const * address) [member function]
cls.add_method('Set',
'void',
[param('char const *', 'address')])
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(uint8_t * address) [member function]
cls.add_method('Set',
'void',
[param('uint8_t *', 'address')])
return
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_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]
cls.add_constructor([param('uint8_t *', 'prefix')])
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]
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]
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')])
## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function]
cls.add_method('GetBytes',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): uint8_t ns3::Ipv6Prefix::GetPrefixLength() const [member function]
cls.add_method('GetPrefixLength',
'uint8_t',
[],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv6Prefix const &', 'other')],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function]
cls.add_method('IsMatch',
'bool',
[param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
return
def register_Ns3LogComponent_methods(root_module, cls):
## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor]
cls.add_constructor([param('ns3::LogComponent const &', 'arg0')])
## log.h (module 'core'): ns3::LogComponent::LogComponent(char const * name) [constructor]
cls.add_constructor([param('char const *', 'name')])
## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel level) [member function]
cls.add_method('Disable',
'void',
[param('ns3::LogLevel', 'level')])
## log.h (module 'core'): void ns3::LogComponent::Enable(ns3::LogLevel level) [member function]
cls.add_method('Enable',
'void',
[param('ns3::LogLevel', 'level')])
## log.h (module 'core'): void ns3::LogComponent::EnvVarCheck(char const * name) [member function]
cls.add_method('EnvVarCheck',
'void',
[param('char const *', 'name')])
## log.h (module 'core'): bool ns3::LogComponent::IsEnabled(ns3::LogLevel level) const [member function]
cls.add_method('IsEnabled',
'bool',
[param('ns3::LogLevel', 'level')],
is_const=True)
## log.h (module 'core'): bool ns3::LogComponent::IsNoneEnabled() const [member function]
cls.add_method('IsNoneEnabled',
'bool',
[],
is_const=True)
## log.h (module 'core'): char const * ns3::LogComponent::Name() const [member function]
cls.add_method('Name',
'char const *',
[],
is_const=True)
return
def register_Ns3Mac48Address_methods(root_module, cls):
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]
cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor]
cls.add_constructor([])
## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(char const * str) [constructor]
cls.add_constructor([param('char const *', 'str')])
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
cls.add_method('Allocate',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Mac48Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
cls.add_method('CopyFrom',
'void',
[param('uint8_t const *', 'buffer')])
## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
cls.add_method('CopyTo',
'void',
[param('uint8_t *', 'buffer')],
is_const=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
cls.add_method('GetBroadcast',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
cls.add_method('GetMulticast',
'ns3::Mac48Address',
[param('ns3::Ipv4Address', 'address')],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv6Address address) [member function]
cls.add_method('GetMulticast',
'ns3::Mac48Address',
[param('ns3::Ipv6Address', 'address')],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast6Prefix() [member function]
cls.add_method('GetMulticast6Prefix',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
cls.add_method('GetMulticastPrefix',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsGroup() const [member function]
cls.add_method('IsGroup',
'bool',
[],
is_const=True)
## mac48-address.h (module 'network'): static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
return
def register_Ns3NetDeviceContainer_methods(root_module, cls):
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor]
cls.add_constructor([])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::Ptr<ns3::NetDevice> dev) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::NetDevice >', 'dev')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(std::string devName) [constructor]
cls.add_constructor([param('std::string', 'devName')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & a, ns3::NetDeviceContainer const & b) [constructor]
cls.add_constructor([param('ns3::NetDeviceContainer const &', 'a'), param('ns3::NetDeviceContainer const &', 'b')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::NetDeviceContainer other) [member function]
cls.add_method('Add',
'void',
[param('ns3::NetDeviceContainer', 'other')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::Ptr<ns3::NetDevice> device) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ptr< ns3::NetDevice >', 'device')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(std::string deviceName) [member function]
cls.add_method('Add',
'void',
[param('std::string', 'deviceName')])
## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > 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 > > >',
[],
is_const=True)
## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > 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 > > >',
[],
is_const=True)
## net-device-container.h (module 'network'): ns3::Ptr<ns3::NetDevice> ns3::NetDeviceContainer::Get(uint32_t i) const [member function]
cls.add_method('Get',
'ns3::Ptr< ns3::NetDevice >',
[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',
'uint32_t',
[],
is_const=True)
return
def register_Ns3NodeContainer_methods(root_module, cls):
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor]
cls.add_constructor([])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::Ptr<ns3::Node> node) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(std::string nodeName) [constructor]
cls.add_constructor([param('std::string', 'nodeName')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d, ns3::NodeContainer const & e) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd'), param('ns3::NodeContainer const &', 'e')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::NodeContainer other) [member function]
cls.add_method('Add',
'void',
[param('ns3::NodeContainer', 'other')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ptr< ns3::Node >', 'node')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(std::string nodeName) [member function]
cls.add_method('Add',
'void',
[param('std::string', 'nodeName')])
## node-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > 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 > > >',
[],
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')])
## 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<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > 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 > > >',
[],
is_const=True)
## node-container.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NodeContainer::Get(uint32_t i) const [member function]
cls.add_method('Get',
'ns3::Ptr< ns3::Node >',
[param('uint32_t', 'i')],
is_const=True)
## node-container.h (module 'network'): static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function]
cls.add_method('GetGlobal',
'ns3::NodeContainer',
[],
is_static=True)
## node-container.h (module 'network'): uint32_t ns3::NodeContainer::GetN() const [member function]
cls.add_method('GetN',
'uint32_t',
[],
is_const=True)
return
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]
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',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue &', 'value')],
is_const=True)
## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
cls.add_method('GetAttributeFailSafe',
'bool',
[param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')],
is_const=True)
## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('SetAttribute',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('SetAttributeFailSafe',
'bool',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceConnect',
'bool',
[param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceConnectWithoutContext',
'bool',
[param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceDisconnect',
'bool',
[param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceDisconnectWithoutContext',
'bool',
[param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeConstructionList const & attributes) [member function]
cls.add_method('ConstructSelf',
'void',
[param('ns3::AttributeConstructionList const &', 'attributes')],
visibility='protected')
## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
cls.add_method('NotifyConstructionCompleted',
'void',
[],
visibility='protected', is_virtual=True)
return
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]
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',
'void',
[param('ns3::Object *', 'object')],
is_static=True)
return
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]
cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor]
cls.add_constructor([])
## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(std::string typeId) [constructor]
cls.add_constructor([param('std::string', 'typeId')])
## object-factory.h (module 'core'): ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
cls.add_method('Create',
'ns3::Ptr< ns3::Object >',
[],
is_const=True)
## object-factory.h (module 'core'): ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
## object-factory.h (module 'core'): void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('Set',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('ns3::TypeId', 'tid')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('char const *', 'tid')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('std::string', 'tid')])
return
def register_Ns3OfdmDcdChannelEncodings_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings::OfdmDcdChannelEncodings(ns3::OfdmDcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDcdChannelEncodings const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings::OfdmDcdChannelEncodings() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::OfdmDcdChannelEncodings::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetChannelNr() const [member function]
cls.add_method('GetChannelNr',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetFrameDurationCode() const [member function]
cls.add_method('GetFrameDurationCode',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::OfdmDcdChannelEncodings::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetBaseStationId(ns3::Mac48Address baseStationId) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationId')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetChannelNr(uint8_t channelNr) [member function]
cls.add_method('SetChannelNr',
'void',
[param('uint8_t', 'channelNr')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetFrameDurationCode(uint8_t frameDurationCode) [member function]
cls.add_method('SetFrameDurationCode',
'void',
[param('uint8_t', 'frameDurationCode')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetRtg(uint8_t rtg) [member function]
cls.add_method('SetRtg',
'void',
[param('uint8_t', 'rtg')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetTtg(uint8_t ttg) [member function]
cls.add_method('SetTtg',
'void',
[param('uint8_t', 'ttg')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
visibility='private', is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3OfdmDlBurstProfile_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::OfdmDlBurstProfile(ns3::OfdmDlBurstProfile const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDlBurstProfile const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::OfdmDlBurstProfile() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetFecCodeType() const [member function]
cls.add_method('GetFecCodeType',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlBurstProfile::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlBurstProfile::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetFecCodeType(uint8_t fecCodeType) [member function]
cls.add_method('SetFecCodeType',
'void',
[param('uint8_t', 'fecCodeType')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetLength(uint8_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint8_t', 'length')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlBurstProfile::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmDlMapIe_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe::OfdmDlMapIe(ns3::OfdmDlMapIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDlMapIe const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe::OfdmDlMapIe() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): ns3::Cid ns3::OfdmDlMapIe::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlMapIe::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlMapIe::GetPreamblePresent() const [member function]
cls.add_method('GetPreamblePresent',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlMapIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlMapIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlMapIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetPreamblePresent(uint8_t preamblePresent) [member function]
cls.add_method('SetPreamblePresent',
'void',
[param('uint8_t', 'preamblePresent')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlMapIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmUlBurstProfile_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::OfdmUlBurstProfile(ns3::OfdmUlBurstProfile const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUlBurstProfile const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::OfdmUlBurstProfile() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetFecCodeType() const [member function]
cls.add_method('GetFecCodeType',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlBurstProfile::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetUiuc() const [member function]
cls.add_method('GetUiuc',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlBurstProfile::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetFecCodeType(uint8_t fecCodeType) [member function]
cls.add_method('SetFecCodeType',
'void',
[param('uint8_t', 'fecCodeType')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetLength(uint8_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint8_t', 'length')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetUiuc(uint8_t uiuc) [member function]
cls.add_method('SetUiuc',
'void',
[param('uint8_t', 'uiuc')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlBurstProfile::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmUlMapIe_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe::OfdmUlMapIe(ns3::OfdmUlMapIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUlMapIe const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe::OfdmUlMapIe() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): ns3::Cid ns3::OfdmUlMapIe::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetDuration() const [member function]
cls.add_method('GetDuration',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetMidambleRepetitionInterval() const [member function]
cls.add_method('GetMidambleRepetitionInterval',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetSubchannelIndex() const [member function]
cls.add_method('GetSubchannelIndex',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetUiuc() const [member function]
cls.add_method('GetUiuc',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlMapIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetDuration(uint16_t duration) [member function]
cls.add_method('SetDuration',
'void',
[param('uint16_t', 'duration')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetMidambleRepetitionInterval(uint8_t midambleRepetitionInterval) [member function]
cls.add_method('SetMidambleRepetitionInterval',
'void',
[param('uint8_t', 'midambleRepetitionInterval')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetSubchannelIndex(uint8_t subchannelIndex) [member function]
cls.add_method('SetSubchannelIndex',
'void',
[param('uint8_t', 'subchannelIndex')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetUiuc(uint8_t uiuc) [member function]
cls.add_method('SetUiuc',
'void',
[param('uint8_t', 'uiuc')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlMapIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
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]
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',
'void',
[param('ns3::PacketMetadata const &', 'o')])
## 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')])
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function]
cls.add_method('AddPaddingAtEnd',
'void',
[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('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',
[param('ns3::Buffer', 'buffer')],
is_const=True)
## 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')],
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')])
## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function]
cls.add_method('Enable',
'void',
[],
is_static=True)
## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::EnableChecking() [member function]
cls.add_method('EnableChecking',
'void',
[],
is_static=True)
## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## packet-metadata.h (module 'network'): uint64_t ns3::PacketMetadata::GetUid() const [member function]
cls.add_method('GetUid',
'uint64_t',
[],
is_const=True)
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]
cls.add_method('RemoveAtEnd',
'void',
[param('uint32_t', 'end')])
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function]
cls.add_method('RemoveAtStart',
'void',
[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('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('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('uint32_t', '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]
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)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentSize [variable]
cls.add_instance_attribute('currentSize', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromEnd [variable]
cls.add_instance_attribute('currentTrimedFromEnd', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromStart [variable]
cls.add_instance_attribute('currentTrimedFromStart', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::isFragment [variable]
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)
return
def register_Ns3PacketMetadataItemIterator_methods(root_module, cls):
## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy 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')])
## packet-metadata.h (module 'network'): bool ns3::PacketMetadata::ItemIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item ns3::PacketMetadata::ItemIterator::Next() [member function]
cls.add_method('Next',
'ns3::PacketMetadata::Item',
[])
return
def register_Ns3PacketTagIterator_methods(root_module, cls):
## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')])
## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet.h (module 'network'): ns3::PacketTagIterator::Item ns3::PacketTagIterator::Next() [member function]
cls.add_method('Next',
'ns3::PacketTagIterator::Item',
[])
return
def register_Ns3PacketTagIteratorItem_methods(root_module, cls):
## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy 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',
'void',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::TypeId ns3::PacketTagIterator::Item::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
return
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]
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',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData const * ns3::PacketTagList::Head() const [member function]
cls.add_method('Head',
'ns3::PacketTagList::TagData const *',
[],
is_const=True)
## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Peek(ns3::Tag & tag) const [member function]
cls.add_method('Peek',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Remove(ns3::Tag & tag) [member function]
cls.add_method('Remove',
'bool',
[param('ns3::Tag &', 'tag')])
## packet-tag-list.h (module 'network'): void ns3::PacketTagList::RemoveAll() [member function]
cls.add_method('RemoveAll',
'void',
[])
return
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]
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)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::data [variable]
cls.add_instance_attribute('data', 'uint8_t [ 20 ]', is_const=False)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::next [variable]
cls.add_instance_attribute('next', 'ns3::PacketTagList::TagData *', is_const=False)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::tid [variable]
cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
return
def register_Ns3PcapFile_methods(root_module, cls):
## pcap-file.h (module 'network'): ns3::PcapFile::PcapFile() [constructor]
cls.add_constructor([])
## pcap-file.h (module 'network'): void ns3::PcapFile::Clear() [member function]
cls.add_method('Clear',
'void',
[])
## pcap-file.h (module 'network'): void ns3::PcapFile::Close() [member function]
cls.add_method('Close',
'void',
[])
## 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 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', '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',
'bool',
[],
is_const=True)
## pcap-file.h (module 'network'): bool ns3::PcapFile::Fail() const [member function]
cls.add_method('Fail',
'bool',
[],
is_const=True)
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetDataLinkType() [member function]
cls.add_method('GetDataLinkType',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetMagic() [member function]
cls.add_method('GetMagic',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetSigFigs() [member function]
cls.add_method('GetSigFigs',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetSnapLen() [member function]
cls.add_method('GetSnapLen',
'uint32_t',
[])
## pcap-file.h (module 'network'): bool ns3::PcapFile::GetSwapMode() [member function]
cls.add_method('GetSwapMode',
'bool',
[])
## pcap-file.h (module 'network'): int32_t ns3::PcapFile::GetTimeZoneOffset() [member function]
cls.add_method('GetTimeZoneOffset',
'int32_t',
[])
## pcap-file.h (module 'network'): uint16_t ns3::PcapFile::GetVersionMajor() [member function]
cls.add_method('GetVersionMajor',
'uint16_t',
[])
## pcap-file.h (module 'network'): uint16_t ns3::PcapFile::GetVersionMinor() [member function]
cls.add_method('GetVersionMinor',
'uint16_t',
[])
## 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) [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')])
## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::_Ios_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')])
## 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<const ns3::Packet> 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 & header, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('Write',
'void',
[param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header &', '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]
cls.add_static_attribute('ZONE_DEFAULT', 'int32_t const', is_const=True)
return
def register_Ns3PcapHelper_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [copy 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::PcapFileWrapper> ns3::PcapHelper::CreateFile(std::string filename, std::_Ios_Openmode filemode, uint32_t dataLinkType, uint32_t snapLen=65535, int32_t tzCorrection=0) [member function]
cls.add_method('CreateFile',
'ns3::Ptr< ns3::PcapFileWrapper >',
[param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='65535'), param('int32_t', 'tzCorrection', default_value='0')])
## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> 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')])
return
def register_Ns3PcapHelperForDevice_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapHelperForDevice const &', 'arg0')])
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice() [constructor]
cls.add_constructor([])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false, bool explicitFilename=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false, bool explicitFilename=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
## 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')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
cls.add_method('EnablePcapAll',
'void',
[param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous, bool explicitFilename) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous'), param('bool', 'explicitFilename')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3RandomVariable_methods(root_module, cls):
cls.add_output_stream_operator()
## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
## random-variable.h (module 'core'): uint32_t ns3::RandomVariable::GetInteger() const [member function]
cls.add_method('GetInteger',
'uint32_t',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::RandomVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
return
def register_Ns3SNRToBlockErrorRateManager_methods(root_module, cls):
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager::SNRToBlockErrorRateManager(ns3::SNRToBlockErrorRateManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SNRToBlockErrorRateManager const &', 'arg0')])
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager::SNRToBlockErrorRateManager() [constructor]
cls.add_constructor([])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::ActivateLoss(bool loss) [member function]
cls.add_method('ActivateLoss',
'void',
[param('bool', 'loss')])
## snr-to-block-error-rate-manager.h (module 'wimax'): double ns3::SNRToBlockErrorRateManager::GetBlockErrorRate(double SNR, uint8_t modulation) [member function]
cls.add_method('GetBlockErrorRate',
'double',
[param('double', 'SNR'), param('uint8_t', 'modulation')])
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord * ns3::SNRToBlockErrorRateManager::GetSNRToBlockErrorRateRecord(double SNR, uint8_t modulation) [member function]
cls.add_method('GetSNRToBlockErrorRateRecord',
'ns3::SNRToBlockErrorRateRecord *',
[param('double', 'SNR'), param('uint8_t', 'modulation')])
## snr-to-block-error-rate-manager.h (module 'wimax'): std::string ns3::SNRToBlockErrorRateManager::GetTraceFilePath() [member function]
cls.add_method('GetTraceFilePath',
'std::string',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::LoadDefaultTraces() [member function]
cls.add_method('LoadDefaultTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::LoadTraces() [member function]
cls.add_method('LoadTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::ReLoadTraces() [member function]
cls.add_method('ReLoadTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::SetTraceFilePath(char * traceFilePath) [member function]
cls.add_method('SetTraceFilePath',
'void',
[param('char *', 'traceFilePath')])
return
def register_Ns3SNRToBlockErrorRateRecord_methods(root_module, cls):
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord::SNRToBlockErrorRateRecord(ns3::SNRToBlockErrorRateRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SNRToBlockErrorRateRecord const &', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord::SNRToBlockErrorRateRecord(double snrValue, double bitErrorRate, double BlockErrorRate, double sigma2, double I1, double I2) [constructor]
cls.add_constructor([param('double', 'snrValue'), param('double', 'bitErrorRate'), param('double', 'BlockErrorRate'), param('double', 'sigma2'), param('double', 'I1'), param('double', 'I2')])
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord * ns3::SNRToBlockErrorRateRecord::Copy() [member function]
cls.add_method('Copy',
'ns3::SNRToBlockErrorRateRecord *',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetBitErrorRate() [member function]
cls.add_method('GetBitErrorRate',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetBlockErrorRate() [member function]
cls.add_method('GetBlockErrorRate',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetI1() [member function]
cls.add_method('GetI1',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetI2() [member function]
cls.add_method('GetI2',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetSNRValue() [member function]
cls.add_method('GetSNRValue',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetSigma2() [member function]
cls.add_method('GetSigma2',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetBitErrorRate(double arg0) [member function]
cls.add_method('SetBitErrorRate',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetBlockErrorRate(double arg0) [member function]
cls.add_method('SetBlockErrorRate',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetI1(double arg0) [member function]
cls.add_method('SetI1',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetI2(double arg0) [member function]
cls.add_method('SetI2',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetSNRValue(double arg0) [member function]
cls.add_method('SetSNRValue',
'void',
[param('double', 'arg0')])
return
def register_Ns3SSRecord_methods(root_module, cls):
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::SSRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SSRecord const &', 'arg0')])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord() [constructor]
cls.add_constructor([])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::Mac48Address macAddress) [constructor]
cls.add_constructor([param('ns3::Mac48Address', 'macAddress')])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::Mac48Address macAddress, ns3::Ipv4Address IPaddress) [constructor]
cls.add_constructor([param('ns3::Mac48Address', 'macAddress'), param('ns3::Ipv4Address', 'IPaddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::DisablePollForRanging() [member function]
cls.add_method('DisablePollForRanging',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::EnablePollForRanging() [member function]
cls.add_method('EnablePollForRanging',
'void',
[])
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetAreServiceFlowsAllocated() const [member function]
cls.add_method('GetAreServiceFlowsAllocated',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Cid ns3::SSRecord::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::DsaRsp ns3::SSRecord::GetDsaRsp() const [member function]
cls.add_method('GetDsaRsp',
'ns3::DsaRsp',
[],
is_const=True)
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetDsaRspRetries() const [member function]
cls.add_method('GetDsaRspRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowBe() const [member function]
cls.add_method('GetHasServiceFlowBe',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowNrtps() const [member function]
cls.add_method('GetHasServiceFlowNrtps',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowRtps() const [member function]
cls.add_method('GetHasServiceFlowRtps',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowUgs() const [member function]
cls.add_method('GetHasServiceFlowUgs',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Ipv4Address ns3::SSRecord::GetIPAddress() [member function]
cls.add_method('GetIPAddress',
'ns3::Ipv4Address',
[])
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetInvitedRangRetries() const [member function]
cls.add_method('GetInvitedRangRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetIsBroadcastSS() [member function]
cls.add_method('GetIsBroadcastSS',
'bool',
[])
## ss-record.h (module 'wimax'): ns3::Mac48Address ns3::SSRecord::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::SSRecord::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetPollForRanging() const [member function]
cls.add_method('GetPollForRanging',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetPollMeBit() const [member function]
cls.add_method('GetPollMeBit',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Cid ns3::SSRecord::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetRangingCorrectionRetries() const [member function]
cls.add_method('GetRangingCorrectionRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::WimaxNetDevice::RangingStatus ns3::SSRecord::GetRangingStatus() const [member function]
cls.add_method('GetRangingStatus',
'ns3::WimaxNetDevice::RangingStatus',
[],
is_const=True)
## ss-record.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::SSRecord::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## ss-record.h (module 'wimax'): uint16_t ns3::SSRecord::GetSfTransactionId() const [member function]
cls.add_method('GetSfTransactionId',
'uint16_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementDsaRspRetries() [member function]
cls.add_method('IncrementDsaRspRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementInvitedRangingRetries() [member function]
cls.add_method('IncrementInvitedRangingRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementRangingCorrectionRetries() [member function]
cls.add_method('IncrementRangingCorrectionRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::ResetInvitedRangingRetries() [member function]
cls.add_method('ResetInvitedRangingRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::ResetRangingCorrectionRetries() [member function]
cls.add_method('ResetRangingCorrectionRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetAreServiceFlowsAllocated(bool val) [member function]
cls.add_method('SetAreServiceFlowsAllocated',
'void',
[param('bool', 'val')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetBasicCid(ns3::Cid basicCid) [member function]
cls.add_method('SetBasicCid',
'void',
[param('ns3::Cid', 'basicCid')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetDsaRsp(ns3::DsaRsp dsaRsp) [member function]
cls.add_method('SetDsaRsp',
'void',
[param('ns3::DsaRsp', 'dsaRsp')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetDsaRspRetries(uint8_t dsaRspRetries) [member function]
cls.add_method('SetDsaRspRetries',
'void',
[param('uint8_t', 'dsaRspRetries')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetIPAddress(ns3::Ipv4Address IPaddress) [member function]
cls.add_method('SetIPAddress',
'void',
[param('ns3::Ipv4Address', 'IPaddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetIsBroadcastSS(bool arg0) [member function]
cls.add_method('SetIsBroadcastSS',
'void',
[param('bool', 'arg0')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetPollMeBit(bool pollMeBit) [member function]
cls.add_method('SetPollMeBit',
'void',
[param('bool', 'pollMeBit')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetPrimaryCid(ns3::Cid primaryCid) [member function]
cls.add_method('SetPrimaryCid',
'void',
[param('ns3::Cid', 'primaryCid')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetRangingStatus(ns3::WimaxNetDevice::RangingStatus rangingStatus) [member function]
cls.add_method('SetRangingStatus',
'void',
[param('ns3::WimaxNetDevice::RangingStatus', 'rangingStatus')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetSfTransactionId(uint16_t sfTransactionId) [member function]
cls.add_method('SetSfTransactionId',
'void',
[param('uint16_t', 'sfTransactionId')])
return
def register_Ns3SeedManager_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::SeedManager::SeedManager() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SeedManager const &', 'arg0')])
## random-variable.h (module 'core'): static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]
cls.add_method('CheckSeed',
'bool',
[param('uint32_t', 'seed')],
is_static=True)
## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetRun() [member function]
cls.add_method('GetRun',
'uint32_t',
[],
is_static=True)
## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetSeed() [member function]
cls.add_method('GetSeed',
'uint32_t',
[],
is_static=True)
## random-variable.h (module 'core'): static void ns3::SeedManager::SetRun(uint32_t run) [member function]
cls.add_method('SetRun',
'void',
[param('uint32_t', 'run')],
is_static=True)
## random-variable.h (module 'core'): static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]
cls.add_method('SetSeed',
'void',
[param('uint32_t', 'seed')],
is_static=True)
return
def register_Ns3SendParams_methods(root_module, cls):
## send-params.h (module 'wimax'): ns3::SendParams::SendParams(ns3::SendParams const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SendParams const &', 'arg0')])
## send-params.h (module 'wimax'): ns3::SendParams::SendParams() [constructor]
cls.add_constructor([])
return
def register_Ns3SequentialVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
return
def register_Ns3ServiceFlow_methods(root_module, cls):
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::ServiceFlow::Direction direction) [constructor]
cls.add_constructor([param('ns3::ServiceFlow::Direction', 'direction')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow() [constructor]
cls.add_constructor([])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::ServiceFlow const & sf) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlow const &', 'sf')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(uint32_t sfid, ns3::ServiceFlow::Direction direction, ns3::Ptr<ns3::WimaxConnection> connection) [constructor]
cls.add_constructor([param('uint32_t', 'sfid'), param('ns3::ServiceFlow::Direction', 'direction'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')])
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::CheckClassifierMatch(ns3::Ipv4Address srcAddress, ns3::Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const [member function]
cls.add_method('CheckClassifierMatch',
'bool',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Address', 'dstAddress'), param('uint16_t', 'srcPort'), param('uint16_t', 'dstPort'), param('uint8_t', 'proto')],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::CleanUpQueue() [member function]
cls.add_method('CleanUpQueue',
'void',
[])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::CopyParametersFrom(ns3::ServiceFlow sf) [member function]
cls.add_method('CopyParametersFrom',
'void',
[param('ns3::ServiceFlow', 'sf')])
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqBlockLifeTime() const [member function]
cls.add_method('GetArqBlockLifeTime',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqBlockSize() const [member function]
cls.add_method('GetArqBlockSize',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetArqDeliverInOrder() const [member function]
cls.add_method('GetArqDeliverInOrder',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetArqEnable() const [member function]
cls.add_method('GetArqEnable',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqPurgeTimeout() const [member function]
cls.add_method('GetArqPurgeTimeout',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqRetryTimeoutRx() const [member function]
cls.add_method('GetArqRetryTimeoutRx',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqRetryTimeoutTx() const [member function]
cls.add_method('GetArqRetryTimeoutTx',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqSyncLoss() const [member function]
cls.add_method('GetArqSyncLoss',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqWindowSize() const [member function]
cls.add_method('GetArqWindowSize',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetCid() const [member function]
cls.add_method('GetCid',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ServiceFlow::GetConnection() const [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::CsParameters ns3::ServiceFlow::GetConvergenceSublayerParam() const [member function]
cls.add_method('GetConvergenceSublayerParam',
'ns3::CsParameters',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::CsSpecification ns3::ServiceFlow::GetCsSpecification() const [member function]
cls.add_method('GetCsSpecification',
'ns3::ServiceFlow::CsSpecification',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Direction ns3::ServiceFlow::GetDirection() const [member function]
cls.add_method('GetDirection',
'ns3::ServiceFlow::Direction',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetFixedversusVariableSduIndicator() const [member function]
cls.add_method('GetFixedversusVariableSduIndicator',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::GetIsEnabled() const [member function]
cls.add_method('GetIsEnabled',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::GetIsMulticast() const [member function]
cls.add_method('GetIsMulticast',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaxSustainedTrafficRate() const [member function]
cls.add_method('GetMaxSustainedTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaxTrafficBurst() const [member function]
cls.add_method('GetMaxTrafficBurst',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaximumLatency() const [member function]
cls.add_method('GetMaximumLatency',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMinReservedTrafficRate() const [member function]
cls.add_method('GetMinReservedTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMinTolerableTrafficRate() const [member function]
cls.add_method('GetMinTolerableTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::ServiceFlow::GetModulation() const [member function]
cls.add_method('GetModulation',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetQosParamSetType() const [member function]
cls.add_method('GetQosParamSetType',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::Ptr<ns3::WimaxMacQueue> ns3::ServiceFlow::GetQueue() const [member function]
cls.add_method('GetQueue',
'ns3::Ptr< ns3::WimaxMacQueue >',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlowRecord * ns3::ServiceFlow::GetRecord() const [member function]
cls.add_method('GetRecord',
'ns3::ServiceFlowRecord *',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetRequestTransmissionPolicy() const [member function]
cls.add_method('GetRequestTransmissionPolicy',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::ServiceFlow::GetSchedulingType() const [member function]
cls.add_method('GetSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[],
is_const=True)
## service-flow.h (module 'wimax'): char * ns3::ServiceFlow::GetSchedulingTypeStr() const [member function]
cls.add_method('GetSchedulingTypeStr',
'char *',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetSduSize() const [member function]
cls.add_method('GetSduSize',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): std::string ns3::ServiceFlow::GetServiceClassName() const [member function]
cls.add_method('GetServiceClassName',
'std::string',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::ServiceFlow::GetServiceSchedulingType() const [member function]
cls.add_method('GetServiceSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetTargetSAID() const [member function]
cls.add_method('GetTargetSAID',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetToleratedJitter() const [member function]
cls.add_method('GetToleratedJitter',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetTrafficPriority() const [member function]
cls.add_method('GetTrafficPriority',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Type ns3::ServiceFlow::GetType() const [member function]
cls.add_method('GetType',
'ns3::ServiceFlow::Type',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetUnsolicitedGrantInterval() const [member function]
cls.add_method('GetUnsolicitedGrantInterval',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetUnsolicitedPollingInterval() const [member function]
cls.add_method('GetUnsolicitedPollingInterval',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::HasPackets(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('HasPackets',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::InitValues() [member function]
cls.add_method('InitValues',
'void',
[])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::PrintQoSParameters() const [member function]
cls.add_method('PrintQoSParameters',
'void',
[],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqBlockLifeTime(uint16_t arg0) [member function]
cls.add_method('SetArqBlockLifeTime',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqBlockSize(uint16_t arg0) [member function]
cls.add_method('SetArqBlockSize',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqDeliverInOrder(uint8_t arg0) [member function]
cls.add_method('SetArqDeliverInOrder',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqEnable(uint8_t arg0) [member function]
cls.add_method('SetArqEnable',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqPurgeTimeout(uint16_t arg0) [member function]
cls.add_method('SetArqPurgeTimeout',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqRetryTimeoutRx(uint16_t arg0) [member function]
cls.add_method('SetArqRetryTimeoutRx',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqRetryTimeoutTx(uint16_t arg0) [member function]
cls.add_method('SetArqRetryTimeoutTx',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqSyncLoss(uint16_t arg0) [member function]
cls.add_method('SetArqSyncLoss',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqWindowSize(uint16_t arg0) [member function]
cls.add_method('SetArqWindowSize',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetConnection(ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('SetConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetConvergenceSublayerParam(ns3::CsParameters arg0) [member function]
cls.add_method('SetConvergenceSublayerParam',
'void',
[param('ns3::CsParameters', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetCsSpecification(ns3::ServiceFlow::CsSpecification arg0) [member function]
cls.add_method('SetCsSpecification',
'void',
[param('ns3::ServiceFlow::CsSpecification', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetDirection(ns3::ServiceFlow::Direction direction) [member function]
cls.add_method('SetDirection',
'void',
[param('ns3::ServiceFlow::Direction', 'direction')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetFixedversusVariableSduIndicator(uint8_t arg0) [member function]
cls.add_method('SetFixedversusVariableSduIndicator',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetIsEnabled(bool isEnabled) [member function]
cls.add_method('SetIsEnabled',
'void',
[param('bool', 'isEnabled')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetIsMulticast(bool isMulticast) [member function]
cls.add_method('SetIsMulticast',
'void',
[param('bool', 'isMulticast')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaxSustainedTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMaxSustainedTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaxTrafficBurst(uint32_t arg0) [member function]
cls.add_method('SetMaxTrafficBurst',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaximumLatency(uint32_t arg0) [member function]
cls.add_method('SetMaximumLatency',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMinReservedTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMinReservedTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMinTolerableTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMinTolerableTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetModulation(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulation',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetQosParamSetType(uint8_t arg0) [member function]
cls.add_method('SetQosParamSetType',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetRecord(ns3::ServiceFlowRecord * record) [member function]
cls.add_method('SetRecord',
'void',
[param('ns3::ServiceFlowRecord *', 'record')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetRequestTransmissionPolicy(uint32_t arg0) [member function]
cls.add_method('SetRequestTransmissionPolicy',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetSduSize(uint8_t arg0) [member function]
cls.add_method('SetSduSize',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetServiceClassName(std::string arg0) [member function]
cls.add_method('SetServiceClassName',
'void',
[param('std::string', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetServiceSchedulingType(ns3::ServiceFlow::SchedulingType arg0) [member function]
cls.add_method('SetServiceSchedulingType',
'void',
[param('ns3::ServiceFlow::SchedulingType', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetSfid(uint32_t arg0) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetTargetSAID(uint16_t arg0) [member function]
cls.add_method('SetTargetSAID',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetToleratedJitter(uint32_t arg0) [member function]
cls.add_method('SetToleratedJitter',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetTrafficPriority(uint8_t arg0) [member function]
cls.add_method('SetTrafficPriority',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetType(ns3::ServiceFlow::Type type) [member function]
cls.add_method('SetType',
'void',
[param('ns3::ServiceFlow::Type', 'type')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetUnsolicitedGrantInterval(uint16_t arg0) [member function]
cls.add_method('SetUnsolicitedGrantInterval',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetUnsolicitedPollingInterval(uint16_t arg0) [member function]
cls.add_method('SetUnsolicitedPollingInterval',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): ns3::Tlv ns3::ServiceFlow::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
return
def register_Ns3ServiceFlowRecord_methods(root_module, cls):
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord::ServiceFlowRecord(ns3::ServiceFlowRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlowRecord const &', 'arg0')])
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord::ServiceFlowRecord() [constructor]
cls.add_constructor([])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBacklogged() const [member function]
cls.add_method('GetBacklogged',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBackloggedTemp() const [member function]
cls.add_method('GetBackloggedTemp',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBwSinceLastExpiry() [member function]
cls.add_method('GetBwSinceLastExpiry',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBytesRcvd() const [member function]
cls.add_method('GetBytesRcvd',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBytesSent() const [member function]
cls.add_method('GetBytesSent',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetDlTimeStamp() const [member function]
cls.add_method('GetDlTimeStamp',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantSize() const [member function]
cls.add_method('GetGrantSize',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetGrantTimeStamp() const [member function]
cls.add_method('GetGrantTimeStamp',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantedBandwidth() [member function]
cls.add_method('GetGrantedBandwidth',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantedBandwidthTemp() [member function]
cls.add_method('GetGrantedBandwidthTemp',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetLastGrantTime() const [member function]
cls.add_method('GetLastGrantTime',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetPktsRcvd() const [member function]
cls.add_method('GetPktsRcvd',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetPktsSent() const [member function]
cls.add_method('GetPktsSent',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetRequestedBandwidth() [member function]
cls.add_method('GetRequestedBandwidth',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::IncreaseBacklogged(uint32_t backlogged) [member function]
cls.add_method('IncreaseBacklogged',
'void',
[param('uint32_t', 'backlogged')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::IncreaseBackloggedTemp(uint32_t backloggedTemp) [member function]
cls.add_method('IncreaseBackloggedTemp',
'void',
[param('uint32_t', 'backloggedTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBacklogged(uint32_t backlogged) [member function]
cls.add_method('SetBacklogged',
'void',
[param('uint32_t', 'backlogged')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBackloggedTemp(uint32_t backloggedTemp) [member function]
cls.add_method('SetBackloggedTemp',
'void',
[param('uint32_t', 'backloggedTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBwSinceLastExpiry(uint32_t bwSinceLastExpiry) [member function]
cls.add_method('SetBwSinceLastExpiry',
'void',
[param('uint32_t', 'bwSinceLastExpiry')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBytesRcvd(uint32_t bytesRcvd) [member function]
cls.add_method('SetBytesRcvd',
'void',
[param('uint32_t', 'bytesRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBytesSent(uint32_t bytesSent) [member function]
cls.add_method('SetBytesSent',
'void',
[param('uint32_t', 'bytesSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetDlTimeStamp(ns3::Time dlTimeStamp) [member function]
cls.add_method('SetDlTimeStamp',
'void',
[param('ns3::Time', 'dlTimeStamp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantSize(uint32_t grantSize) [member function]
cls.add_method('SetGrantSize',
'void',
[param('uint32_t', 'grantSize')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantTimeStamp(ns3::Time grantTimeStamp) [member function]
cls.add_method('SetGrantTimeStamp',
'void',
[param('ns3::Time', 'grantTimeStamp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantedBandwidth(uint32_t grantedBandwidth) [member function]
cls.add_method('SetGrantedBandwidth',
'void',
[param('uint32_t', 'grantedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantedBandwidthTemp(uint32_t grantedBandwidthTemp) [member function]
cls.add_method('SetGrantedBandwidthTemp',
'void',
[param('uint32_t', 'grantedBandwidthTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetLastGrantTime(ns3::Time grantTime) [member function]
cls.add_method('SetLastGrantTime',
'void',
[param('ns3::Time', 'grantTime')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetPktsRcvd(uint32_t pktsRcvd) [member function]
cls.add_method('SetPktsRcvd',
'void',
[param('uint32_t', 'pktsRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetPktsSent(uint32_t pktsSent) [member function]
cls.add_method('SetPktsSent',
'void',
[param('uint32_t', 'pktsSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetRequestedBandwidth(uint32_t requestedBandwidth) [member function]
cls.add_method('SetRequestedBandwidth',
'void',
[param('uint32_t', 'requestedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBwSinceLastExpiry(uint32_t bwSinceLastExpiry) [member function]
cls.add_method('UpdateBwSinceLastExpiry',
'void',
[param('uint32_t', 'bwSinceLastExpiry')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBytesRcvd(uint32_t bytesRcvd) [member function]
cls.add_method('UpdateBytesRcvd',
'void',
[param('uint32_t', 'bytesRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBytesSent(uint32_t bytesSent) [member function]
cls.add_method('UpdateBytesSent',
'void',
[param('uint32_t', 'bytesSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateGrantedBandwidth(uint32_t grantedBandwidth) [member function]
cls.add_method('UpdateGrantedBandwidth',
'void',
[param('uint32_t', 'grantedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateGrantedBandwidthTemp(uint32_t grantedBandwidthTemp) [member function]
cls.add_method('UpdateGrantedBandwidthTemp',
'void',
[param('uint32_t', 'grantedBandwidthTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdatePktsRcvd(uint32_t pktsRcvd) [member function]
cls.add_method('UpdatePktsRcvd',
'void',
[param('uint32_t', 'pktsRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdatePktsSent(uint32_t pktsSent) [member function]
cls.add_method('UpdatePktsSent',
'void',
[param('uint32_t', 'pktsSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateRequestedBandwidth(uint32_t requestedBandwidth) [member function]
cls.add_method('UpdateRequestedBandwidth',
'void',
[param('uint32_t', 'requestedBandwidth')])
return
def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount(ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> const & o) [copy 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<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3Simulator_methods(root_module, cls):
## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy 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',
'void',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Destroy() [member function]
cls.add_method('Destroy',
'void',
[],
is_static=True)
## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetContext() [member function]
cls.add_method('GetContext',
'uint32_t',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
cls.add_method('GetDelayLeft',
'ns3::Time',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static ns3::Ptr<ns3::SimulatorImpl> ns3::Simulator::GetImplementation() [member function]
cls.add_method('GetImplementation',
'ns3::Ptr< ns3::SimulatorImpl >',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]
cls.add_method('GetMaximumSimulationTime',
'ns3::Time',
[],
is_static=True)
## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetSystemId() [member function]
cls.add_method('GetSystemId',
'uint32_t',
[],
is_static=True)
## simulator.h (module 'core'): static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
cls.add_method('IsExpired',
'bool',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static bool ns3::Simulator::IsFinished() [member function]
cls.add_method('IsFinished',
'bool',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Next() [member function]
cls.add_method('Next',
'ns3::Time',
[],
is_static=True, deprecated=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Now() [member function]
cls.add_method('Now',
'ns3::Time',
[],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]
cls.add_method('Remove',
'void',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::RunOneEvent() [member function]
cls.add_method('RunOneEvent',
'void',
[],
is_static=True, deprecated=True)
## simulator.h (module 'core'): static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
cls.add_method('SetImplementation',
'void',
[param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
cls.add_method('SetScheduler',
'void',
[param('ns3::ObjectFactory', 'schedulerFactory')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Stop(ns3::Time const & time) [member function]
cls.add_method('Stop',
'void',
[param('ns3::Time const &', 'time')],
is_static=True)
return
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]
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',
'void',
[param('ns3::TagBuffer', 'i')],
is_pure_virtual=True, is_virtual=True)
## tag.h (module 'network'): uint32_t ns3::Tag::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## tag.h (module 'network'): static ns3::TypeId ns3::Tag::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## tag.h (module 'network'): void ns3::Tag::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## tag.h (module 'network'): void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::TagBuffer', 'i')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TagBuffer_methods(root_module, cls):
## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy 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')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function]
cls.add_method('CopyFrom',
'void',
[param('ns3::TagBuffer', 'o')])
## 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')])
## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function]
cls.add_method('ReadDouble',
'double',
[])
## tag-buffer.h (module 'network'): uint16_t ns3::TagBuffer::ReadU16() [member function]
cls.add_method('ReadU16',
'uint16_t',
[])
## tag-buffer.h (module 'network'): uint32_t ns3::TagBuffer::ReadU32() [member function]
cls.add_method('ReadU32',
'uint32_t',
[])
## tag-buffer.h (module 'network'): uint64_t ns3::TagBuffer::ReadU64() [member function]
cls.add_method('ReadU64',
'uint64_t',
[])
## tag-buffer.h (module 'network'): uint8_t ns3::TagBuffer::ReadU8() [member function]
cls.add_method('ReadU8',
'uint8_t',
[])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]
cls.add_method('TrimAtEnd',
'void',
[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('uint32_t', '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]
cls.add_method('WriteU16',
'void',
[param('uint16_t', 'data')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function]
cls.add_method('WriteU32',
'void',
[param('uint32_t', 'data')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function]
cls.add_method('WriteU64',
'void',
[param('uint64_t', 'v')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function]
cls.add_method('WriteU8',
'void',
[param('uint8_t', 'v')])
return
def register_Ns3TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::TlvValue::TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::TlvValue::TlvValue(ns3::TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::TlvValue *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_pure_virtual=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TosTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue(ns3::TosTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TosTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue(uint8_t arg0, uint8_t arg1, uint8_t arg2) [constructor]
cls.add_constructor([param('uint8_t', 'arg0'), param('uint8_t', 'arg1'), param('uint8_t', 'arg2')])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue * ns3::TosTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::TosTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TosTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetHigh() const [member function]
cls.add_method('GetHigh',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetLow() const [member function]
cls.add_method('GetLow',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetMask() const [member function]
cls.add_method('GetMask',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TosTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::TosTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3TriangularVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
return
def register_Ns3TypeId_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_binary_comparison_operator('<')
cls.add_output_stream_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]
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<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [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')])
## 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<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [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')])
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
cls.add_method('AddTraceSource',
'ns3::TypeId',
[param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
## 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')],
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')],
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::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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 >',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeId::GetGroupName() const [member function]
cls.add_method('GetGroupName',
'std::string',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::GetParent() const [member function]
cls.add_method('GetParent',
'ns3::TypeId',
[],
is_const=True)
## 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')],
is_static=True)
## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function]
cls.add_method('GetRegisteredN',
'uint32_t',
[],
is_static=True)
## 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')],
is_const=True)
## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
cls.add_method('GetTraceSourceN',
'uint32_t',
[],
is_const=True)
## type-id.h (module 'core'): uint16_t ns3::TypeId::GetUid() const [member function]
cls.add_method('GetUid',
'uint16_t',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::HasConstructor() const [member function]
cls.add_method('HasConstructor',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::HasParent() const [member function]
cls.add_method('HasParent',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
cls.add_method('HideFromDocumentation',
'ns3::TypeId',
[])
## type-id.h (module 'core'): bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
cls.add_method('IsChildOf',
'bool',
[param('ns3::TypeId', 'other')],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInformation * info) const [member function]
cls.add_method('LookupAttributeByName',
'bool',
[param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info')],
is_const=True)
## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
cls.add_method('LookupByName',
'ns3::TypeId',
[param('std::string', 'name')],
is_static=True)
## type-id.h (module 'core'): ns3::Ptr<ns3::TraceSourceAccessor const> 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'): bool ns3::TypeId::MustHideFromDocumentation() const [member function]
cls.add_method('MustHideFromDocumentation',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr<ns3::AttributeValue const> initialValue) [member function]
cls.add_method('SetAttributeInitialValue',
'bool',
[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',
[param('std::string', 'groupName')])
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
cls.add_method('SetParent',
'ns3::TypeId',
[param('ns3::TypeId', 'tid')])
## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t tid) [member function]
cls.add_method('SetUid',
'void',
[param('uint16_t', 'tid')])
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]
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)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::initialValue [variable]
cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::originalInitialValue [variable]
cls.add_instance_attribute('originalInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
return
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]
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)
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::help [variable]
cls.add_instance_attribute('help', 'std::string', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
return
def register_Ns3U16TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue(ns3::U16TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U16TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue(uint16_t value) [constructor]
cls.add_constructor([param('uint16_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue * ns3::U16TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U16TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint16_t ns3::U16TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint16_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U16TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3U32TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue(ns3::U32TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U32TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue(uint32_t value) [constructor]
cls.add_constructor([param('uint32_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue * ns3::U32TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U32TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint32_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U32TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3U8TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue(ns3::U8TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U8TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue(uint8_t value) [constructor]
cls.add_constructor([param('uint8_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue * ns3::U8TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U8TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::U8TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U8TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3UcdChannelEncodings_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings::UcdChannelEncodings(ns3::UcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UcdChannelEncodings const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings::UcdChannelEncodings() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetBwReqOppSize() const [member function]
cls.add_method('GetBwReqOppSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UcdChannelEncodings::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetRangReqOppSize() const [member function]
cls.add_method('GetRangReqOppSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetBwReqOppSize(uint16_t bwReqOppSize) [member function]
cls.add_method('SetBwReqOppSize',
'void',
[param('uint16_t', 'bwReqOppSize')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetRangReqOppSize(uint16_t rangReqOppSize) [member function]
cls.add_method('SetRangReqOppSize',
'void',
[param('uint16_t', 'rangReqOppSize')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3UniformVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
cls.add_constructor([param('double', 's'), param('double', 'l')])
## random-variable.h (module 'core'): uint32_t ns3::UniformVariable::GetInteger(uint32_t s, uint32_t l) [member function]
cls.add_method('GetInteger',
'uint32_t',
[param('uint32_t', 's'), param('uint32_t', 'l')])
## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue(double s, double l) [member function]
cls.add_method('GetValue',
'double',
[param('double', 's'), param('double', 'l')])
return
def register_Ns3VectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue::VectorTlvValue(ns3::VectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::VectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue::VectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::VectorTlvValue::Add(ns3::Tlv const & val) [member function]
cls.add_method('Add',
'void',
[param('ns3::Tlv const &', 'val')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<ns3::Tlv* const*,std::vector<ns3::Tlv*, std::allocator<ns3::Tlv*> > > ns3::VectorTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::Tlv * const *, std::vector< ns3::Tlv * > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue * ns3::VectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::VectorTlvValue *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::VectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_pure_virtual=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<ns3::Tlv* const*,std::vector<ns3::Tlv*, std::allocator<ns3::Tlv*> > > ns3::VectorTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::Tlv * const *, std::vector< ns3::Tlv * > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::VectorTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::VectorTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3WeibullVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
return
def register_Ns3WimaxHelper_methods(root_module, cls):
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::WimaxHelper(ns3::WimaxHelper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxHelper const &', 'arg0')])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::WimaxHelper() [constructor]
cls.add_constructor([])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::BSScheduler> ns3::WimaxHelper::CreateBSScheduler(ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('CreateBSScheduler',
'ns3::Ptr< ns3::BSScheduler >',
[param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhy(ns3::WimaxHelper::PhyType phyType) [member function]
cls.add_method('CreatePhy',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhy(ns3::WimaxHelper::PhyType phyType, char * SNRTraceFilePath, bool activateLoss) [member function]
cls.add_method('CreatePhy',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType'), param('char *', 'SNRTraceFilePath'), param('bool', 'activateLoss')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhyWithoutChannel(ns3::WimaxHelper::PhyType phyType) [member function]
cls.add_method('CreatePhyWithoutChannel',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhyWithoutChannel(ns3::WimaxHelper::PhyType phyType, char * SNRTraceFilePath, bool activateLoss) [member function]
cls.add_method('CreatePhyWithoutChannel',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType'), param('char *', 'SNRTraceFilePath'), param('bool', 'activateLoss')])
## wimax-helper.h (module 'wimax'): ns3::ServiceFlow ns3::WimaxHelper::CreateServiceFlow(ns3::ServiceFlow::Direction direction, ns3::ServiceFlow::SchedulingType schedulinType, ns3::IpcsClassifierRecord classifier) [member function]
cls.add_method('CreateServiceFlow',
'ns3::ServiceFlow',
[param('ns3::ServiceFlow::Direction', 'direction'), param('ns3::ServiceFlow::SchedulingType', 'schedulinType'), param('ns3::IpcsClassifierRecord', 'classifier')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::UplinkScheduler> ns3::WimaxHelper::CreateUplinkScheduler(ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('CreateUplinkScheduler',
'ns3::Ptr< ns3::UplinkScheduler >',
[param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): static void ns3::WimaxHelper::EnableAsciiForConnection(ns3::Ptr<ns3::OutputStreamWrapper> oss, uint32_t nodeid, uint32_t deviceid, char * netdevice, char * connection) [member function]
cls.add_method('EnableAsciiForConnection',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'oss'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('char *', 'netdevice'), param('char *', 'connection')],
is_static=True)
## wimax-helper.h (module 'wimax'): static void ns3::WimaxHelper::EnableLogComponents() [member function]
cls.add_method('EnableLogComponents',
'void',
[],
is_static=True)
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType type, ns3::WimaxHelper::PhyType phyType, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'type'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::Ptr<ns3::WimaxChannel> channel, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::Ptr< ns3::WimaxChannel >', 'channel'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::WimaxHelper::SchedulerType schedulerType, double frameDuration) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType'), param('double', 'frameDuration')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxNetDevice> ns3::WimaxHelper::Install(ns3::Ptr<ns3::Node> node, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::Ptr<ns3::WimaxChannel> channel, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::Ptr< ns3::WimaxNetDevice >',
[param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::Ptr< ns3::WimaxChannel >', 'channel'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::SetPropagationLossModel(ns3::SimpleOfdmWimaxChannel::PropModel propagationModel) [member function]
cls.add_method('SetPropagationLossModel',
'void',
[param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propagationModel')])
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename')],
visibility='private', is_virtual=True)
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename, bool promiscuous) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename'), param('bool', 'promiscuous')],
visibility='private', is_virtual=True)
return
def register_Ns3ZetaVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(ns3::ZetaVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ZetaVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(double alpha) [constructor]
cls.add_constructor([param('double', 'alpha')])
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable() [constructor]
cls.add_constructor([])
return
def register_Ns3ZipfVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(long int N, double alpha) [constructor]
cls.add_constructor([param('long int', 'N'), param('double', 'alpha')])
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable() [constructor]
cls.add_constructor([])
return
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]
cls.add_constructor([param('ns3::empty const &', 'arg0')])
return
def register_Ns3Int64x64_t_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', '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 &', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('>')
cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', 'right'))
cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', 'right'))
cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', '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(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_constructor([param('ns3::int64x64_t const &', 'o')])
## int64x64-double.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]
cls.add_method('GetHigh',
'int64_t',
[],
is_const=True)
## int64x64-double.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]
cls.add_method('Invert',
'ns3::int64x64_t',
[param('uint64_t', 'v')],
is_static=True)
## int64x64-double.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')])
return
def register_Ns3SimpleOfdmSendParam_methods(root_module, cls):
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(ns3::simpleOfdmSendParam const & arg0) [copy constructor]
cls.add_constructor([param('ns3::simpleOfdmSendParam const &', 'arg0')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam() [constructor]
cls.add_constructor([])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(ns3::bvec const & fecBlock, uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPowerDbm) [constructor]
cls.add_constructor([param('ns3::bvec const &', 'fecBlock'), param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'Frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPowerDbm')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPowerDbm, ns3::Ptr<ns3::PacketBurst> burst) [constructor]
cls.add_constructor([param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'Frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPowerDbm'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::simpleOfdmSendParam::GetBurst() [member function]
cls.add_method('GetBurst',
'ns3::Ptr< ns3::PacketBurst >',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint32_t ns3::simpleOfdmSendParam::GetBurstSize() [member function]
cls.add_method('GetBurstSize',
'uint32_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint8_t ns3::simpleOfdmSendParam::GetDirection() [member function]
cls.add_method('GetDirection',
'uint8_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): ns3::bvec ns3::simpleOfdmSendParam::GetFecBlock() [member function]
cls.add_method('GetFecBlock',
'ns3::bvec',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint64_t ns3::simpleOfdmSendParam::GetFrequency() [member function]
cls.add_method('GetFrequency',
'uint64_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): bool ns3::simpleOfdmSendParam::GetIsFirstBlock() [member function]
cls.add_method('GetIsFirstBlock',
'bool',
[])
## simple-ofdm-send-param.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::simpleOfdmSendParam::GetModulationType() [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[])
## simple-ofdm-send-param.h (module 'wimax'): double ns3::simpleOfdmSendParam::GetRxPowerDbm() [member function]
cls.add_method('GetRxPowerDbm',
'double',
[])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetBurstSize(uint32_t burstSize) [member function]
cls.add_method('SetBurstSize',
'void',
[param('uint32_t', 'burstSize')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetDirection(uint8_t direction) [member function]
cls.add_method('SetDirection',
'void',
[param('uint8_t', 'direction')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetFecBlock(ns3::bvec const & fecBlock) [member function]
cls.add_method('SetFecBlock',
'void',
[param('ns3::bvec const &', 'fecBlock')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetFrequency(uint64_t Frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint64_t', 'Frequency')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetIsFirstBlock(bool isFirstBlock) [member function]
cls.add_method('SetIsFirstBlock',
'void',
[param('bool', 'isFirstBlock')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetRxPowerDbm(double rxPowerDbm) [member function]
cls.add_method('SetRxPowerDbm',
'void',
[param('double', 'rxPowerDbm')])
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_virtual=True)
## chunk.h (module 'network'): static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## chunk.h (module 'network'): void ns3::Chunk::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3ClassificationRuleVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleVectorTlvValue(ns3::ClassificationRuleVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ClassificationRuleVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue * ns3::ClassificationRuleVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::ClassificationRuleVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ClassificationRuleVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3ConstantVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(double c) [constructor]
cls.add_constructor([param('double', 'c')])
## random-variable.h (module 'core'): void ns3::ConstantVariable::SetConstant(double c) [member function]
cls.add_method('SetConstant',
'void',
[param('double', 'c')])
return
def register_Ns3CsParamVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::CsParamVectorTlvValue(ns3::CsParamVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CsParamVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::CsParamVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue * ns3::CsParamVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::CsParamVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::CsParamVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3DeterministicVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
return
def register_Ns3EmpiricalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
cls.add_method('CDF',
'void',
[param('double', 'v'), param('double', 'c')])
return
def register_Ns3ErlangVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(ns3::ErlangVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ErlangVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(unsigned int k, double lambda) [constructor]
cls.add_constructor([param('unsigned int', 'k'), param('double', 'lambda')])
## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue(unsigned int k, double lambda) const [member function]
cls.add_method('GetValue',
'double',
[param('unsigned int', 'k'), param('double', 'lambda')],
is_const=True)
return
def register_Ns3ExponentialVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'b')])
return
def register_Ns3GammaVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(ns3::GammaVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GammaVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(double alpha, double beta) [constructor]
cls.add_constructor([param('double', 'alpha'), param('double', 'beta')])
## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue(double alpha, double beta) const [member function]
cls.add_method('GetValue',
'double',
[param('double', 'alpha'), param('double', 'beta')],
is_const=True)
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_virtual=True)
## header.h (module 'network'): uint32_t ns3::Header::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## header.h (module 'network'): static ns3::TypeId ns3::Header::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## header.h (module 'network'): void ns3::Header::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## header.h (module 'network'): void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
cls.add_constructor([])
return
def register_Ns3Ipv4AddressTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::Ipv4AddressTlvValue(ns3::Ipv4AddressTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ipv4AddressTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::Ipv4AddressTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::Ipv4AddressTlvValue::Add(ns3::Ipv4Address address, ns3::Ipv4Mask Mask) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ipv4Address', 'address'), param('ns3::Ipv4Mask', 'Mask')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::Ipv4AddressTlvValue::ipv4Addr*,std::vector<ns3::Ipv4AddressTlvValue::ipv4Addr, std::allocator<ns3::Ipv4AddressTlvValue::ipv4Addr> > > ns3::Ipv4AddressTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::Ipv4AddressTlvValue::ipv4Addr const *, std::vector< ns3::Ipv4AddressTlvValue::ipv4Addr > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue * ns3::Ipv4AddressTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ipv4AddressTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Ipv4AddressTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::Ipv4AddressTlvValue::ipv4Addr*,std::vector<ns3::Ipv4AddressTlvValue::ipv4Addr, std::allocator<ns3::Ipv4AddressTlvValue::ipv4Addr> > > ns3::Ipv4AddressTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::Ipv4AddressTlvValue::ipv4Addr const *, std::vector< ns3::Ipv4AddressTlvValue::ipv4Addr > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Ipv4AddressTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::Ipv4AddressTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3Ipv4AddressTlvValueIpv4Addr_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::ipv4Addr() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::ipv4Addr(ns3::Ipv4AddressTlvValue::ipv4Addr const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ipv4AddressTlvValue::ipv4Addr const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::Address [variable]
cls.add_instance_attribute('Address', 'ns3::Ipv4Address', is_const=False)
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::Mask [variable]
cls.add_instance_attribute('Mask', 'ns3::Ipv4Mask', is_const=False)
return
def register_Ns3LogNormalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
return
def register_Ns3MacHeaderType_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType(ns3::MacHeaderType const & arg0) [copy constructor]
cls.add_constructor([param('ns3::MacHeaderType const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType(uint8_t type) [constructor]
cls.add_constructor([param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::MacHeaderType::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::MacHeaderType::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::MacHeaderType::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::MacHeaderType::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::MacHeaderType::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::MacHeaderType::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
return
def register_Ns3ManagementMessageType_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType(ns3::ManagementMessageType const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ManagementMessageType const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType(uint8_t type) [constructor]
cls.add_constructor([param('uint8_t', 'type')])
## mac-messages.h (module 'wimax'): uint32_t ns3::ManagementMessageType::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::ManagementMessageType::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::ManagementMessageType::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::ManagementMessageType::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::ManagementMessageType::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::ManagementMessageType::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
return
def register_Ns3NormalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'v')])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
return
def register_Ns3Object_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::Object() [constructor]
cls.add_constructor([])
## object.h (module 'core'): void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
cls.add_method('AggregateObject',
'void',
[param('ns3::Ptr< ns3::Object >', 'other')])
## object.h (module 'core'): void ns3::Object::Dispose() [member function]
cls.add_method('Dispose',
'void',
[])
## object.h (module 'core'): ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
cls.add_method('GetAggregateIterator',
'ns3::Object::AggregateIterator',
[],
is_const=True)
## object.h (module 'core'): ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## object.h (module 'core'): void ns3::Object::Start() [member function]
cls.add_method('Start',
'void',
[])
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
## object.h (module 'core'): void ns3::Object::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='protected', is_virtual=True)
## object.h (module 'core'): void ns3::Object::DoStart() [member function]
cls.add_method('DoStart',
'void',
[],
visibility='protected', is_virtual=True)
## object.h (module 'core'): void ns3::Object::NotifyNewAggregate() [member function]
cls.add_method('NotifyNewAggregate',
'void',
[],
visibility='protected', is_virtual=True)
return
def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor]
cls.add_constructor([])
## object.h (module 'core'): bool ns3::Object::AggregateIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## object.h (module 'core'): ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
cls.add_method('Next',
'ns3::Ptr< ns3::Object const >',
[])
return
def register_Ns3OfdmDownlinkFramePrefix_methods(root_module, cls):
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix::OfdmDownlinkFramePrefix(ns3::OfdmDownlinkFramePrefix const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDownlinkFramePrefix const &', 'arg0')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix::OfdmDownlinkFramePrefix() [constructor]
cls.add_constructor([])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::AddDlFramePrefixElement(ns3::DlFramePrefixIe dlFramePrefixElement) [member function]
cls.add_method('AddDlFramePrefixElement',
'void',
[param('ns3::DlFramePrefixIe', 'dlFramePrefixElement')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Mac48Address ns3::OfdmDownlinkFramePrefix::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::OfdmDownlinkFramePrefix::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): std::vector<ns3::DlFramePrefixIe, std::allocator<ns3::DlFramePrefixIe> > ns3::OfdmDownlinkFramePrefix::GetDlFramePrefixElements() const [member function]
cls.add_method('GetDlFramePrefixElements',
'std::vector< ns3::DlFramePrefixIe >',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::OfdmDownlinkFramePrefix::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): std::string ns3::OfdmDownlinkFramePrefix::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetBaseStationId(ns3::Mac48Address baseStationId) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationId')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetConfigurationChangeCount(uint8_t configurationChangeCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'configurationChangeCount')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
return
def register_Ns3OfdmSendParams_methods(root_module, cls):
## send-params.h (module 'wimax'): ns3::OfdmSendParams::OfdmSendParams(ns3::OfdmSendParams const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmSendParams const &', 'arg0')])
## send-params.h (module 'wimax'): ns3::OfdmSendParams::OfdmSendParams(ns3::Ptr<ns3::PacketBurst> burst, uint8_t modulationType, uint8_t direction) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('uint8_t', 'modulationType'), param('uint8_t', 'direction')])
## send-params.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::OfdmSendParams::GetBurst() const [member function]
cls.add_method('GetBurst',
'ns3::Ptr< ns3::PacketBurst >',
[],
is_const=True)
## send-params.h (module 'wimax'): uint8_t ns3::OfdmSendParams::GetDirection() const [member function]
cls.add_method('GetDirection',
'uint8_t',
[],
is_const=True)
## send-params.h (module 'wimax'): uint8_t ns3::OfdmSendParams::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'uint8_t',
[],
is_const=True)
return
def register_Ns3OfdmUcdChannelEncodings_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings::OfdmUcdChannelEncodings(ns3::OfdmUcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUcdChannelEncodings const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings::OfdmUcdChannelEncodings() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUcdChannelEncodings::GetSbchnlFocContCodes() const [member function]
cls.add_method('GetSbchnlFocContCodes',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUcdChannelEncodings::GetSbchnlReqRegionFullParams() const [member function]
cls.add_method('GetSbchnlReqRegionFullParams',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUcdChannelEncodings::SetSbchnlFocContCodes(uint8_t sbchnlFocContCodes) [member function]
cls.add_method('SetSbchnlFocContCodes',
'void',
[param('uint8_t', 'sbchnlFocContCodes')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUcdChannelEncodings::SetSbchnlReqRegionFullParams(uint8_t sbchnlReqRegionFullParams) [member function]
cls.add_method('SetSbchnlReqRegionFullParams',
'void',
[param('uint8_t', 'sbchnlReqRegionFullParams')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
visibility='private', is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3PacketBurst_methods(root_module, cls):
## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')])
## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor]
cls.add_constructor([])
## packet-burst.h (module 'network'): void ns3::PacketBurst::AddPacket(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('AddPacket',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')])
## packet-burst.h (module 'network'): std::_List_const_iterator<ns3::Ptr<ns3::Packet> > ns3::PacketBurst::Begin() const [member function]
cls.add_method('Begin',
'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): ns3::Ptr<ns3::PacketBurst> ns3::PacketBurst::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::PacketBurst >',
[],
is_const=True)
## packet-burst.h (module 'network'): std::_List_const_iterator<ns3::Ptr<ns3::Packet> > ns3::PacketBurst::End() const [member function]
cls.add_method('End',
'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function]
cls.add_method('GetNPackets',
'uint32_t',
[],
is_const=True)
## packet-burst.h (module 'network'): std::list<ns3::Ptr<ns3::Packet>, std::allocator<ns3::Ptr<ns3::Packet> > > ns3::PacketBurst::GetPackets() const [member function]
cls.add_method('GetPackets',
'std::list< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## packet-burst.h (module 'network'): static ns3::TypeId ns3::PacketBurst::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## packet-burst.h (module 'network'): void ns3::PacketBurst::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3ParetoVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params) [constructor]
cls.add_constructor([param('std::pair< double, double >', 'params')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params, double b) [constructor]
cls.add_constructor([param('std::pair< double, double >', 'params'), param('double', 'b')])
return
def register_Ns3PcapFileWrapper_methods(root_module, cls):
## pcap-file-wrapper.h (module 'network'): static ns3::TypeId ns3::PcapFileWrapper::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## pcap-file-wrapper.h (module 'network'): ns3::PcapFileWrapper::PcapFileWrapper() [constructor]
cls.add_constructor([])
## pcap-file-wrapper.h (module 'network'): bool ns3::PcapFileWrapper::Fail() const [member function]
cls.add_method('Fail',
'bool',
[],
is_const=True)
## pcap-file-wrapper.h (module 'network'): bool ns3::PcapFileWrapper::Eof() const [member function]
cls.add_method('Eof',
'bool',
[],
is_const=True)
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Clear() [member function]
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]
cls.add_method('Open',
'void',
[param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Close() [member function]
cls.add_method('Close',
'void',
[])
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits<unsigned int>::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<unsigned int>::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<const ns3::Packet> 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 & header, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('Write',
'void',
[param('ns3::Time', 't'), param('ns3::Header &', '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')])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetMagic() [member function]
cls.add_method('GetMagic',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint16_t ns3::PcapFileWrapper::GetVersionMajor() [member function]
cls.add_method('GetVersionMajor',
'uint16_t',
[])
## pcap-file-wrapper.h (module 'network'): uint16_t ns3::PcapFileWrapper::GetVersionMinor() [member function]
cls.add_method('GetVersionMinor',
'uint16_t',
[])
## pcap-file-wrapper.h (module 'network'): int32_t ns3::PcapFileWrapper::GetTimeZoneOffset() [member function]
cls.add_method('GetTimeZoneOffset',
'int32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetSigFigs() [member function]
cls.add_method('GetSigFigs',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetSnapLen() [member function]
cls.add_method('GetSnapLen',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetDataLinkType() [member function]
cls.add_method('GetDataLinkType',
'uint32_t',
[])
return
def register_Ns3PortRangeTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRangeTlvValue(ns3::PortRangeTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PortRangeTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRangeTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::PortRangeTlvValue::Add(uint16_t portLow, uint16_t portHigh) [member function]
cls.add_method('Add',
'void',
[param('uint16_t', 'portLow'), param('uint16_t', 'portHigh')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::PortRangeTlvValue::PortRange*,std::vector<ns3::PortRangeTlvValue::PortRange, std::allocator<ns3::PortRangeTlvValue::PortRange> > > ns3::PortRangeTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::PortRangeTlvValue::PortRange const *, std::vector< ns3::PortRangeTlvValue::PortRange > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue * ns3::PortRangeTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::PortRangeTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::PortRangeTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::PortRangeTlvValue::PortRange*,std::vector<ns3::PortRangeTlvValue::PortRange, std::allocator<ns3::PortRangeTlvValue::PortRange> > > ns3::PortRangeTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::PortRangeTlvValue::PortRange const *, std::vector< ns3::PortRangeTlvValue::PortRange > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::PortRangeTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::PortRangeTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3PortRangeTlvValuePortRange_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortRange() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortRange(ns3::PortRangeTlvValue::PortRange const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PortRangeTlvValue::PortRange const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortHigh [variable]
cls.add_instance_attribute('PortHigh', 'uint16_t', is_const=False)
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortLow [variable]
cls.add_instance_attribute('PortLow', 'uint16_t', is_const=False)
return
def register_Ns3PriorityUlJob_methods(root_module, cls):
## ul-job.h (module 'wimax'): ns3::PriorityUlJob::PriorityUlJob(ns3::PriorityUlJob const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PriorityUlJob const &', 'arg0')])
## ul-job.h (module 'wimax'): ns3::PriorityUlJob::PriorityUlJob() [constructor]
cls.add_constructor([])
## ul-job.h (module 'wimax'): int ns3::PriorityUlJob::GetPriority() [member function]
cls.add_method('GetPriority',
'int',
[])
## ul-job.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::PriorityUlJob::GetUlJob() [member function]
cls.add_method('GetUlJob',
'ns3::Ptr< ns3::UlJob >',
[])
## ul-job.h (module 'wimax'): void ns3::PriorityUlJob::SetPriority(int priority) [member function]
cls.add_method('SetPriority',
'void',
[param('int', 'priority')])
## ul-job.h (module 'wimax'): void ns3::PriorityUlJob::SetUlJob(ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('SetUlJob',
'void',
[param('ns3::Ptr< ns3::UlJob >', 'job')])
return
def register_Ns3PropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel::PropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::PropagationLossModel::SetNext(ns3::Ptr<ns3::PropagationLossModel> next) [member function]
cls.add_method('SetNext',
'void',
[param('ns3::Ptr< ns3::PropagationLossModel >', 'next')])
## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::CalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('CalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3ProtocolTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue::ProtocolTlvValue(ns3::ProtocolTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ProtocolTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue::ProtocolTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::ProtocolTlvValue::Add(uint8_t protiocol) [member function]
cls.add_method('Add',
'void',
[param('uint8_t', 'protiocol')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const unsigned char*,std::vector<unsigned char, std::allocator<unsigned char> > > ns3::ProtocolTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< unsigned char const *, std::vector< unsigned char > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue * ns3::ProtocolTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::ProtocolTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ProtocolTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const unsigned char*,std::vector<unsigned char, std::allocator<unsigned char> > > ns3::ProtocolTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< unsigned char const *, std::vector< unsigned char > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ProtocolTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::ProtocolTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::RandomPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3RangePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RangePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel::RangePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::RangePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3RngReq_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::RngReq::RngReq(ns3::RngReq const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RngReq const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::RngReq::RngReq() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::RngReq::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::RngReq::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::RngReq::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## mac-messages.h (module 'wimax'): std::string ns3::RngReq::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngReq::GetRangingAnomalies() const [member function]
cls.add_method('GetRangingAnomalies',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngReq::GetReqDlBurstProfile() const [member function]
cls.add_method('GetReqDlBurstProfile',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngReq::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::RngReq::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::PrintDebug() const [member function]
cls.add_method('PrintDebug',
'void',
[],
is_const=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetRangingAnomalies(uint8_t rangingAnomalies) [member function]
cls.add_method('SetRangingAnomalies',
'void',
[param('uint8_t', 'rangingAnomalies')])
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetReqDlBurstProfile(uint8_t reqDlBurstProfile) [member function]
cls.add_method('SetReqDlBurstProfile',
'void',
[param('uint8_t', 'reqDlBurstProfile')])
return
def register_Ns3RngRsp_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::RngRsp::RngRsp(ns3::RngRsp const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RngRsp const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::RngRsp::RngRsp() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetAasBdcastPermission() const [member function]
cls.add_method('GetAasBdcastPermission',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::RngRsp::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetDlFreqOverride() const [member function]
cls.add_method('GetDlFreqOverride',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::RngRsp::GetDlOperBurstProfile() const [member function]
cls.add_method('GetDlOperBurstProfile',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetInitRangOppNumber() const [member function]
cls.add_method('GetInitRangOppNumber',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::RngRsp::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::RngRsp::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## mac-messages.h (module 'wimax'): std::string ns3::RngRsp::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetOffsetFreqAdjust() const [member function]
cls.add_method('GetOffsetFreqAdjust',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetPowerLevelAdjust() const [member function]
cls.add_method('GetPowerLevelAdjust',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::RngRsp::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetRangStatus() const [member function]
cls.add_method('GetRangStatus',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetRangSubchnl() const [member function]
cls.add_method('GetRangSubchnl',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetTimingAdjust() const [member function]
cls.add_method('GetTimingAdjust',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::RngRsp::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetUlChnlIdOverride() const [member function]
cls.add_method('GetUlChnlIdOverride',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetAasBdcastPermission(uint8_t aasBdcastPermission) [member function]
cls.add_method('SetAasBdcastPermission',
'void',
[param('uint8_t', 'aasBdcastPermission')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetBasicCid(ns3::Cid basicCid) [member function]
cls.add_method('SetBasicCid',
'void',
[param('ns3::Cid', 'basicCid')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetDlFreqOverride(uint32_t dlFreqOverride) [member function]
cls.add_method('SetDlFreqOverride',
'void',
[param('uint32_t', 'dlFreqOverride')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetDlOperBurstProfile(uint16_t dlOperBurstProfile) [member function]
cls.add_method('SetDlOperBurstProfile',
'void',
[param('uint16_t', 'dlOperBurstProfile')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetInitRangOppNumber(uint8_t initRangOppNumber) [member function]
cls.add_method('SetInitRangOppNumber',
'void',
[param('uint8_t', 'initRangOppNumber')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetOffsetFreqAdjust(uint32_t offsetFreqAdjust) [member function]
cls.add_method('SetOffsetFreqAdjust',
'void',
[param('uint32_t', 'offsetFreqAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetPowerLevelAdjust(uint8_t powerLevelAdjust) [member function]
cls.add_method('SetPowerLevelAdjust',
'void',
[param('uint8_t', 'powerLevelAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetPrimaryCid(ns3::Cid primaryCid) [member function]
cls.add_method('SetPrimaryCid',
'void',
[param('ns3::Cid', 'primaryCid')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetRangStatus(uint8_t rangStatus) [member function]
cls.add_method('SetRangStatus',
'void',
[param('uint8_t', 'rangStatus')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetRangSubchnl(uint8_t rangSubchnl) [member function]
cls.add_method('SetRangSubchnl',
'void',
[param('uint8_t', 'rangSubchnl')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetTimingAdjust(uint32_t timingAdjust) [member function]
cls.add_method('SetTimingAdjust',
'void',
[param('uint32_t', 'timingAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetUlChnlIdOverride(uint8_t ulChnlIdOverride) [member function]
cls.add_method('SetUlChnlIdOverride',
'void',
[param('uint8_t', 'ulChnlIdOverride')])
return
def register_Ns3SSManager_methods(root_module, cls):
## ss-manager.h (module 'wimax'): ns3::SSManager::SSManager(ns3::SSManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SSManager const &', 'arg0')])
## ss-manager.h (module 'wimax'): ns3::SSManager::SSManager() [constructor]
cls.add_constructor([])
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::CreateSSRecord(ns3::Mac48Address const & macAddress) [member function]
cls.add_method('CreateSSRecord',
'ns3::SSRecord *',
[param('ns3::Mac48Address const &', 'macAddress')])
## ss-manager.h (module 'wimax'): void ns3::SSManager::DeleteSSRecord(ns3::Cid cid) [member function]
cls.add_method('DeleteSSRecord',
'void',
[param('ns3::Cid', 'cid')])
## ss-manager.h (module 'wimax'): ns3::Mac48Address ns3::SSManager::GetMacAddress(ns3::Cid cid) const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[param('ns3::Cid', 'cid')],
is_const=True)
## ss-manager.h (module 'wimax'): uint32_t ns3::SSManager::GetNRegisteredSSs() const [member function]
cls.add_method('GetNRegisteredSSs',
'uint32_t',
[],
is_const=True)
## ss-manager.h (module 'wimax'): uint32_t ns3::SSManager::GetNSSs() const [member function]
cls.add_method('GetNSSs',
'uint32_t',
[],
is_const=True)
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::GetSSRecord(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('GetSSRecord',
'ns3::SSRecord *',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::GetSSRecord(ns3::Cid cid) const [member function]
cls.add_method('GetSSRecord',
'ns3::SSRecord *',
[param('ns3::Cid', 'cid')],
is_const=True)
## ss-manager.h (module 'wimax'): std::vector<ns3::SSRecord*,std::allocator<ns3::SSRecord*> > * ns3::SSManager::GetSSRecords() const [member function]
cls.add_method('GetSSRecords',
'std::vector< ns3::SSRecord * > *',
[],
is_const=True)
## ss-manager.h (module 'wimax'): static ns3::TypeId ns3::SSManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ss-manager.h (module 'wimax'): bool ns3::SSManager::IsInRecord(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('IsInRecord',
'bool',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
## ss-manager.h (module 'wimax'): bool ns3::SSManager::IsRegistered(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('IsRegistered',
'bool',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
return
def register_Ns3ServiceFlowManager_methods(root_module, cls):
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ServiceFlowManager(ns3::ServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlowManager const &', 'arg0')])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ServiceFlowManager() [constructor]
cls.add_constructor([])
## service-flow-manager.h (module 'wimax'): void ns3::ServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated() [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated(std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > * serviceFlows) [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[param('std::vector< ns3::ServiceFlow * > *', 'serviceFlows')])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated(std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > serviceFlows) [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[param('std::vector< ns3::ServiceFlow * >', 'serviceFlows')])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::DoClassify(ns3::Ipv4Address SrcAddress, ns3::Ipv4Address DstAddress, uint16_t SrcPort, uint16_t DstPort, uint8_t Proto, ns3::ServiceFlow::Direction dir) const [member function]
cls.add_method('DoClassify',
'ns3::ServiceFlow *',
[param('ns3::Ipv4Address', 'SrcAddress'), param('ns3::Ipv4Address', 'DstAddress'), param('uint16_t', 'SrcPort'), param('uint16_t', 'DstPort'), param('uint8_t', 'Proto'), param('ns3::ServiceFlow::Direction', 'dir')],
is_const=True)
## service-flow-manager.h (module 'wimax'): void ns3::ServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetNextServiceFlowToAllocate() [member function]
cls.add_method('GetNextServiceFlowToAllocate',
'ns3::ServiceFlow *',
[])
## service-flow-manager.h (module 'wimax'): uint32_t ns3::ServiceFlowManager::GetNrServiceFlows() const [member function]
cls.add_method('GetNrServiceFlows',
'uint32_t',
[],
is_const=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetServiceFlow(uint32_t sfid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('uint32_t', 'sfid')],
is_const=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetServiceFlow(ns3::Cid cid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('ns3::Cid', 'cid')],
is_const=True)
## service-flow-manager.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::ServiceFlowManager::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## service-flow-manager.h (module 'wimax'): static ns3::TypeId ns3::ServiceFlowManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
def register_Ns3SfVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::SfVectorTlvValue(ns3::SfVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SfVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::SfVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue * ns3::SfVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::SfVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::SfVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > const & o) [copy 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<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > const & o) [copy 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<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > const & o) [copy 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<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount(ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > const & o) [copy 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<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount(ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > const & o) [copy 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<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount(ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > const & o) [copy 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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount(ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > const & o) [copy 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<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount(ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > const & o) [copy 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<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > const & o) [copy 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<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SsServiceFlowManager_methods(root_module, cls):
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::SsServiceFlowManager(ns3::SsServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SsServiceFlowManager const &', 'arg0')])
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::SsServiceFlowManager(ns3::Ptr<ns3::SubscriberStationNetDevice> device) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::SubscriberStationNetDevice >', 'device')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::SsServiceFlowManager::CreateDsaAck() [member function]
cls.add_method('CreateDsaAck',
'ns3::Ptr< ns3::Packet >',
[])
## ss-service-flow-manager.h (module 'wimax'): ns3::DsaReq ns3::SsServiceFlowManager::CreateDsaReq(ns3::ServiceFlow const * serviceFlow) [member function]
cls.add_method('CreateDsaReq',
'ns3::DsaReq',
[param('ns3::ServiceFlow const *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## ss-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::SsServiceFlowManager::GetDsaAckTimeoutEvent() const [member function]
cls.add_method('GetDsaAckTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::SsServiceFlowManager::GetDsaRspTimeoutEvent() const [member function]
cls.add_method('GetDsaRspTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): uint8_t ns3::SsServiceFlowManager::GetMaxDsaReqRetries() const [member function]
cls.add_method('GetMaxDsaReqRetries',
'uint8_t',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::InitiateServiceFlows() [member function]
cls.add_method('InitiateServiceFlows',
'void',
[])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::ProcessDsaRsp(ns3::DsaRsp const & dsaRsp) [member function]
cls.add_method('ProcessDsaRsp',
'void',
[param('ns3::DsaRsp const &', 'dsaRsp')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::ScheduleDsaReq(ns3::ServiceFlow const * serviceFlow) [member function]
cls.add_method('ScheduleDsaReq',
'void',
[param('ns3::ServiceFlow const *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::SetMaxDsaReqRetries(uint8_t maxDsaReqRetries) [member function]
cls.add_method('SetMaxDsaReqRetries',
'void',
[param('uint8_t', 'maxDsaReqRetries')])
return
def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::ThreeLogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3Time_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('>')
cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', '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]
cls.add_constructor([param('ns3::Time const &', 'o')])
## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor]
cls.add_constructor([param('double', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(int v) [constructor]
cls.add_constructor([param('int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long int v) [constructor]
cls.add_constructor([param('long int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long long int v) [constructor]
cls.add_constructor([param('long long int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(unsigned int v) [constructor]
cls.add_constructor([param('unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long unsigned int v) [constructor]
cls.add_constructor([param('long unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long long unsigned int v) [constructor]
cls.add_constructor([param('long long unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(std::string const & s) [constructor]
cls.add_constructor([param('std::string const &', 's')])
## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor]
cls.add_constructor([param('ns3::int64x64_t const &', 'value')])
## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
cls.add_method('Compare',
'int',
[param('ns3::Time const &', 'o')],
is_const=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & from, ns3::Time::Unit timeUnit) [member function]
cls.add_method('From',
'ns3::Time',
[param('ns3::int64x64_t const &', 'from'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & value) [member function]
cls.add_method('From',
'ns3::Time',
[param('ns3::int64x64_t const &', 'value')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::FromDouble(double value, ns3::Time::Unit timeUnit) [member function]
cls.add_method('FromDouble',
'ns3::Time',
[param('double', 'value'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit timeUnit) [member function]
cls.add_method('FromInteger',
'ns3::Time',
[param('uint64_t', 'value'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): double ns3::Time::GetDouble() const [member function]
cls.add_method('GetDouble',
'double',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetFemtoSeconds() const [member function]
cls.add_method('GetFemtoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetInteger() const [member function]
cls.add_method('GetInteger',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetMicroSeconds() const [member function]
cls.add_method('GetMicroSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetMilliSeconds() const [member function]
cls.add_method('GetMilliSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetNanoSeconds() const [member function]
cls.add_method('GetNanoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetPicoSeconds() const [member function]
cls.add_method('GetPicoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): static ns3::Time::Unit ns3::Time::GetResolution() [member function]
cls.add_method('GetResolution',
'ns3::Time::Unit',
[],
is_static=True)
## nstime.h (module 'core'): double ns3::Time::GetSeconds() const [member function]
cls.add_method('GetSeconds',
'double',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetTimeStep() const [member function]
cls.add_method('GetTimeStep',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsNegative() const [member function]
cls.add_method('IsNegative',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsPositive() const [member function]
cls.add_method('IsPositive',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsStrictlyNegative() const [member function]
cls.add_method('IsStrictlyNegative',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsStrictlyPositive() const [member function]
cls.add_method('IsStrictlyPositive',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsZero() const [member function]
cls.add_method('IsZero',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): static void ns3::Time::SetResolution(ns3::Time::Unit resolution) [member function]
cls.add_method('SetResolution',
'void',
[param('ns3::Time::Unit', 'resolution')],
is_static=True)
## nstime.h (module 'core'): ns3::int64x64_t ns3::Time::To(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('To',
'ns3::int64x64_t',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
## nstime.h (module 'core'): double ns3::Time::ToDouble(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('ToDouble',
'double',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::ToInteger(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('ToInteger',
'int64_t',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
return
def register_Ns3Tlv_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv(uint8_t type, uint64_t length, ns3::TlvValue const & value) [constructor]
cls.add_constructor([param('uint8_t', 'type'), param('uint64_t', 'length'), param('ns3::TlvValue const &', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv(ns3::Tlv const & tlv) [copy constructor]
cls.add_constructor([param('ns3::Tlv const &', 'tlv')])
## wimax-tlv.h (module 'wimax'): ns3::Tlv * ns3::Tlv::Copy() const [member function]
cls.add_method('Copy',
'ns3::Tlv *',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::Tlv::CopyValue() const [member function]
cls.add_method('CopyValue',
'ns3::TlvValue *',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Tlv::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): ns3::TypeId ns3::Tlv::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint64_t ns3::Tlv::GetLength() const [member function]
cls.add_method('GetLength',
'uint64_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Tlv::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::Tlv::GetSizeOfLen() const [member function]
cls.add_method('GetSizeOfLen',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::Tlv::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::Tlv::PeekValue() [member function]
cls.add_method('PeekValue',
'ns3::TlvValue *',
[])
## wimax-tlv.h (module 'wimax'): void ns3::Tlv::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::Tlv::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3TraceSourceAccessor_methods(root_module, cls):
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
cls.add_constructor([])
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
cls.add_method('Connect',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
cls.add_method('ConnectWithoutContext',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
cls.add_method('Disconnect',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
cls.add_method('DisconnectWithoutContext',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'end')],
is_pure_virtual=True, is_virtual=True)
## trailer.h (module 'network'): uint32_t ns3::Trailer::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trailer.h (module 'network'): static ns3::TypeId ns3::Trailer::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## trailer.h (module 'network'): void ns3::Trailer::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trailer.h (module 'network'): void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::TwoRayGroundPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double frequency, double speed) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'frequency'), param('double', 'speed')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double lambda) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'lambda')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
cls.add_method('SetSystemLoss',
'void',
[param('double', 'systemLoss')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetMinDistance(double minDistance) [member function]
cls.add_method('SetMinDistance',
'void',
[param('double', 'minDistance')])
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetMinDistance() const [member function]
cls.add_method('GetMinDistance',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetLambda() const [member function]
cls.add_method('GetLambda',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetSystemLoss() const [member function]
cls.add_method('GetSystemLoss',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetHeightAboveZ(double heightAboveZ) [member function]
cls.add_method('SetHeightAboveZ',
'void',
[param('double', 'heightAboveZ')])
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3Ucd_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::Ucd::Ucd(ns3::Ucd const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ucd const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::Ucd::Ucd() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::AddUlBurstProfile(ns3::OfdmUlBurstProfile ulBurstProfile) [member function]
cls.add_method('AddUlBurstProfile',
'void',
[param('ns3::OfdmUlBurstProfile', 'ulBurstProfile')])
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::Ucd::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings ns3::Ucd::GetChannelEncodings() const [member function]
cls.add_method('GetChannelEncodings',
'ns3::OfdmUcdChannelEncodings',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::TypeId ns3::Ucd::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): std::string ns3::Ucd::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetNrUlBurstProfiles() const [member function]
cls.add_method('GetNrUlBurstProfiles',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRangingBackoffEnd() const [member function]
cls.add_method('GetRangingBackoffEnd',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRangingBackoffStart() const [member function]
cls.add_method('GetRangingBackoffStart',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRequestBackoffEnd() const [member function]
cls.add_method('GetRequestBackoffEnd',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRequestBackoffStart() const [member function]
cls.add_method('GetRequestBackoffStart',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::Ucd::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::Ucd::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ul-mac-messages.h (module 'wimax'): std::vector<ns3::OfdmUlBurstProfile, std::allocator<ns3::OfdmUlBurstProfile> > ns3::Ucd::GetUlBurstProfiles() const [member function]
cls.add_method('GetUlBurstProfiles',
'std::vector< ns3::OfdmUlBurstProfile >',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetChannelEncodings(ns3::OfdmUcdChannelEncodings channelEncodings) [member function]
cls.add_method('SetChannelEncodings',
'void',
[param('ns3::OfdmUcdChannelEncodings', 'channelEncodings')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetConfigurationChangeCount(uint8_t ucdCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'ucdCount')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetNrUlBurstProfiles(uint8_t nrUlBurstProfiles) [member function]
cls.add_method('SetNrUlBurstProfiles',
'void',
[param('uint8_t', 'nrUlBurstProfiles')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRangingBackoffEnd(uint8_t rangingBackoffEnd) [member function]
cls.add_method('SetRangingBackoffEnd',
'void',
[param('uint8_t', 'rangingBackoffEnd')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRangingBackoffStart(uint8_t rangingBackoffStart) [member function]
cls.add_method('SetRangingBackoffStart',
'void',
[param('uint8_t', 'rangingBackoffStart')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRequestBackoffEnd(uint8_t requestBackoffEnd) [member function]
cls.add_method('SetRequestBackoffEnd',
'void',
[param('uint8_t', 'requestBackoffEnd')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRequestBackoffStart(uint8_t requestBackoffStart) [member function]
cls.add_method('SetRequestBackoffStart',
'void',
[param('uint8_t', 'requestBackoffStart')])
return
def register_Ns3UlJob_methods(root_module, cls):
cls.add_binary_comparison_operator('==')
## ul-job.h (module 'wimax'): ns3::UlJob::UlJob(ns3::UlJob const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UlJob const &', 'arg0')])
## ul-job.h (module 'wimax'): ns3::UlJob::UlJob() [constructor]
cls.add_constructor([])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetDeadline() [member function]
cls.add_method('GetDeadline',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetPeriod() [member function]
cls.add_method('GetPeriod',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetReleaseTime() [member function]
cls.add_method('GetReleaseTime',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::UlJob::GetSchedulingType() [member function]
cls.add_method('GetSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[])
## ul-job.h (module 'wimax'): ns3::ServiceFlow * ns3::UlJob::GetServiceFlow() [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[])
## ul-job.h (module 'wimax'): uint32_t ns3::UlJob::GetSize() [member function]
cls.add_method('GetSize',
'uint32_t',
[])
## ul-job.h (module 'wimax'): ns3::SSRecord * ns3::UlJob::GetSsRecord() [member function]
cls.add_method('GetSsRecord',
'ns3::SSRecord *',
[])
## ul-job.h (module 'wimax'): ns3::ReqType ns3::UlJob::GetType() [member function]
cls.add_method('GetType',
'ns3::ReqType',
[])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetDeadline(ns3::Time deadline) [member function]
cls.add_method('SetDeadline',
'void',
[param('ns3::Time', 'deadline')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetPeriod(ns3::Time period) [member function]
cls.add_method('SetPeriod',
'void',
[param('ns3::Time', 'period')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetReleaseTime(ns3::Time releaseTime) [member function]
cls.add_method('SetReleaseTime',
'void',
[param('ns3::Time', 'releaseTime')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSchedulingType(ns3::ServiceFlow::SchedulingType schedulingType) [member function]
cls.add_method('SetSchedulingType',
'void',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSize(uint32_t size) [member function]
cls.add_method('SetSize',
'void',
[param('uint32_t', 'size')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSsRecord(ns3::SSRecord * ssRecord) [member function]
cls.add_method('SetSsRecord',
'void',
[param('ns3::SSRecord *', 'ssRecord')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetType(ns3::ReqType type) [member function]
cls.add_method('SetType',
'void',
[param('ns3::ReqType', 'type')])
return
def register_Ns3UlMap_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::UlMap::UlMap(ns3::UlMap const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UlMap const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::UlMap::UlMap() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::AddUlMapElement(ns3::OfdmUlMapIe ulMapElement) [member function]
cls.add_method('AddUlMapElement',
'void',
[param('ns3::OfdmUlMapIe', 'ulMapElement')])
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::GetAllocationStartTime() const [member function]
cls.add_method('GetAllocationStartTime',
'uint32_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::TypeId ns3::UlMap::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): std::string ns3::UlMap::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::UlMap::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::UlMap::GetUcdCount() const [member function]
cls.add_method('GetUcdCount',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UlMap::GetUlMapElements() const [member function]
cls.add_method('GetUlMapElements',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::SetAllocationStartTime(uint32_t allocationStartTime) [member function]
cls.add_method('SetAllocationStartTime',
'void',
[param('uint32_t', 'allocationStartTime')])
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::SetUcdCount(uint8_t ucdCount) [member function]
cls.add_method('SetUcdCount',
'void',
[param('uint8_t', 'ucdCount')])
return
def register_Ns3UplinkScheduler_methods(root_module, cls):
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler(ns3::UplinkScheduler const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkScheduler const &', 'arg0')])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): uint32_t ns3::UplinkScheduler::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Ptr<ns3::BaseStationNetDevice> ns3::UplinkScheduler::GetBs() [member function]
cls.add_method('GetBs',
'ns3::Ptr< ns3::BaseStationNetDevice >',
[],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetDcdTimeStamp() const [member function]
cls.add_method('GetDcdTimeStamp',
'ns3::Time',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::GetIsInvIrIntrvlAllocated() const [member function]
cls.add_method('GetIsInvIrIntrvlAllocated',
'bool',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::GetIsIrIntrvlAllocated() const [member function]
cls.add_method('GetIsIrIntrvlAllocated',
'bool',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): uint8_t ns3::UplinkScheduler::GetNrIrOppsAllocated() const [member function]
cls.add_method('GetNrIrOppsAllocated',
'uint8_t',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetTimeStampIrInterval() [member function]
cls.add_method('GetTimeStampIrInterval',
'ns3::Time',
[],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): static ns3::TypeId ns3::UplinkScheduler::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetUcdTimeStamp() const [member function]
cls.add_method('GetUcdTimeStamp',
'ns3::Time',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkScheduler::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetBs(ns3::Ptr<ns3::BaseStationNetDevice> bs) [member function]
cls.add_method('SetBs',
'void',
[param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetDcdTimeStamp(ns3::Time dcdTimeStamp) [member function]
cls.add_method('SetDcdTimeStamp',
'void',
[param('ns3::Time', 'dcdTimeStamp')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetIsInvIrIntrvlAllocated(bool isInvIrIntrvlAllocated) [member function]
cls.add_method('SetIsInvIrIntrvlAllocated',
'void',
[param('bool', 'isInvIrIntrvlAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetIsIrIntrvlAllocated(bool isIrIntrvlAllocated) [member function]
cls.add_method('SetIsIrIntrvlAllocated',
'void',
[param('bool', 'isIrIntrvlAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetNrIrOppsAllocated(uint8_t nrIrOppsAllocated) [member function]
cls.add_method('SetNrIrOppsAllocated',
'void',
[param('uint8_t', 'nrIrOppsAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetTimeStampIrInterval(ns3::Time timeStampIrInterval) [member function]
cls.add_method('SetTimeStampIrInterval',
'void',
[param('ns3::Time', 'timeStampIrInterval')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetUcdTimeStamp(ns3::Time ucdTimeStamp) [member function]
cls.add_method('SetUcdTimeStamp',
'void',
[param('ns3::Time', 'ucdTimeStamp')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3UplinkSchedulerMBQoS_methods(root_module, cls):
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS(ns3::UplinkSchedulerMBQoS const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerMBQoS const &', 'arg0')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS(ns3::Time time) [constructor]
cls.add_constructor([param('ns3::Time', 'time')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::CheckDeadline(uint32_t & availableSymbols) [member function]
cls.add_method('CheckDeadline',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::CheckMinimumBandwidth(uint32_t & availableSymbols) [member function]
cls.add_method('CheckMinimumBandwidth',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CountSymbolsJobs(ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('CountSymbolsJobs',
'uint32_t',
[param('ns3::Ptr< ns3::UlJob >', 'job')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CountSymbolsQueue(std::list<ns3::Ptr<ns3::UlJob>, std::allocator<ns3::Ptr<ns3::UlJob> > > jobs) [member function]
cls.add_method('CountSymbolsQueue',
'uint32_t',
[param('std::list< ns3::Ptr< ns3::UlJob > >', 'jobs')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::UplinkSchedulerMBQoS::CreateUlJob(ns3::SSRecord * ssRecord, ns3::ServiceFlow::SchedulingType schedType, ns3::ReqType reqType) [member function]
cls.add_method('CreateUlJob',
'ns3::Ptr< ns3::UlJob >',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedType'), param('ns3::ReqType', 'reqType')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::UplinkSchedulerMBQoS::DequeueJob(ns3::UlJob::JobPriority priority) [member function]
cls.add_method('DequeueJob',
'ns3::Ptr< ns3::UlJob >',
[param('ns3::UlJob::JobPriority', 'priority')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Time ns3::UplinkSchedulerMBQoS::DetermineDeadline(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('DetermineDeadline',
'ns3::Time',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::EnqueueJob(ns3::UlJob::JobPriority priority, ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('EnqueueJob',
'void',
[param('ns3::UlJob::JobPriority', 'priority'), param('ns3::Ptr< ns3::UlJob >', 'job')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::GetPendingSize(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('GetPendingSize',
'uint32_t',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerMBQoS::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerMBQoS::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): bool ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): bool ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequestsBytes(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols, uint32_t allocationSizeBytes) [member function]
cls.add_method('ServiceBandwidthRequestsBytes',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols'), param('uint32_t', 'allocationSizeBytes')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::UplinkSchedWindowTimer() [member function]
cls.add_method('UplinkSchedWindowTimer',
'void',
[])
return
def register_Ns3UplinkSchedulerRtps_methods(root_module, cls):
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps(ns3::UplinkSchedulerRtps const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerRtps const &', 'arg0')])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): uint32_t ns3::UplinkSchedulerRtps::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerRtps::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerRtps::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): bool ns3::UplinkSchedulerRtps::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ULSchedulerRTPSConnection(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ULSchedulerRTPSConnection',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')])
return
def register_Ns3UplinkSchedulerSimple_methods(root_module, cls):
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple(ns3::UplinkSchedulerSimple const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerSimple const &', 'arg0')])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): uint32_t ns3::UplinkSchedulerSimple::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerSimple::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerSimple::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): bool ns3::UplinkSchedulerSimple::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
return
def register_Ns3WimaxConnection_methods(root_module, cls):
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection::WimaxConnection(ns3::WimaxConnection const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxConnection const &', 'arg0')])
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection::WimaxConnection(ns3::Cid cid, ns3::Cid::Type type) [constructor]
cls.add_constructor([param('ns3::Cid', 'cid'), param('ns3::Cid::Type', 'type')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::ClearFragmentsQueue() [member function]
cls.add_method('ClearFragmentsQueue',
'void',
[])
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxConnection::Dequeue(ns3::MacHeaderType::HeaderType packetType=::ns3::MacHeaderType::HEADER_TYPE_GENERIC) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType', default_value='::ns3::MacHeaderType::HEADER_TYPE_GENERIC')])
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxConnection::Dequeue(ns3::MacHeaderType::HeaderType packetType, uint32_t availableByte) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'availableByte')])
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::GenericMacHeader const & hdr) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::GenericMacHeader const &', 'hdr')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::FragmentEnqueue(ns3::Ptr<const ns3::Packet> fragment) [member function]
cls.add_method('FragmentEnqueue',
'void',
[param('ns3::Ptr< ns3::Packet const >', 'fragment')])
## wimax-connection.h (module 'wimax'): ns3::Cid ns3::WimaxConnection::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): std::list<ns3::Ptr<ns3::Packet const>, std::allocator<ns3::Ptr<ns3::Packet const> > > const ns3::WimaxConnection::GetFragmentsQueue() const [member function]
cls.add_method('GetFragmentsQueue',
'std::list< ns3::Ptr< ns3::Packet const > > const',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::WimaxMacQueue> ns3::WimaxConnection::GetQueue() const [member function]
cls.add_method('GetQueue',
'ns3::Ptr< ns3::WimaxMacQueue >',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): uint8_t ns3::WimaxConnection::GetSchedulingType() const [member function]
cls.add_method('GetSchedulingType',
'uint8_t',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::ServiceFlow * ns3::WimaxConnection::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::Cid::Type ns3::WimaxConnection::GetType() const [member function]
cls.add_method('GetType',
'ns3::Cid::Type',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): static ns3::TypeId ns3::WimaxConnection::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-connection.h (module 'wimax'): std::string ns3::WimaxConnection::GetTypeStr() const [member function]
cls.add_method('GetTypeStr',
'std::string',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::HasPackets(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('HasPackets',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::SetServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3WimaxMacQueue_methods(root_module, cls):
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue(ns3::WimaxMacQueue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxMacQueue const &', 'arg0')])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue() [constructor]
cls.add_constructor([])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue(uint32_t maxSize) [constructor]
cls.add_constructor([param('uint32_t', 'maxSize')])
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::CheckForFragmentation(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('CheckForFragmentation',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Dequeue(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Dequeue(ns3::MacHeaderType::HeaderType packetType, uint32_t availableByte) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'availableByte')])
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::GenericMacHeader const & hdr) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::GenericMacHeader const &', 'hdr')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketHdrSize(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketHdrSize',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketPayloadSize(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketPayloadSize',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketRequiredByte(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketRequiredByte',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetMaxSize() const [member function]
cls.add_method('GetMaxSize',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetNBytes() const [member function]
cls.add_method('GetNBytes',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): std::deque<ns3::WimaxMacQueue::QueueElement, std::allocator<ns3::WimaxMacQueue::QueueElement> > const & ns3::WimaxMacQueue::GetPacketQueue() const [member function]
cls.add_method('GetPacketQueue',
'std::deque< ns3::WimaxMacQueue::QueueElement > const &',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetQueueLengthWithMACOverhead() [member function]
cls.add_method('GetQueueLengthWithMACOverhead',
'uint32_t',
[])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): static ns3::TypeId ns3::WimaxMacQueue::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::IsEmpty() const [member function]
cls.add_method('IsEmpty',
'bool',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::IsEmpty(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('IsEmpty',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::GenericMacHeader & hdr) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::GenericMacHeader &', 'hdr')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::GenericMacHeader & hdr, ns3::Time & timeStamp) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::GenericMacHeader &', 'hdr'), param('ns3::Time &', 'timeStamp')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::MacHeaderType::HeaderType packetType, ns3::Time & timeStamp) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('ns3::Time &', 'timeStamp')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentNumber(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('SetFragmentNumber',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentOffset(ns3::MacHeaderType::HeaderType packetType, uint32_t offset) [member function]
cls.add_method('SetFragmentOffset',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'offset')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentation(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('SetFragmentation',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetMaxSize(uint32_t maxSize) [member function]
cls.add_method('SetMaxSize',
'void',
[param('uint32_t', 'maxSize')])
return
def register_Ns3WimaxMacToMacHeader_methods(root_module, cls):
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader(ns3::WimaxMacToMacHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxMacToMacHeader const &', 'arg0')])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader() [constructor]
cls.add_constructor([])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader(uint32_t len) [constructor]
cls.add_constructor([param('uint32_t', 'len')])
## wimax-mac-to-mac-header.h (module 'wimax'): uint32_t ns3::WimaxMacToMacHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::TypeId ns3::WimaxMacToMacHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): uint32_t ns3::WimaxMacToMacHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): uint8_t ns3::WimaxMacToMacHeader::GetSizeOfLen() const [member function]
cls.add_method('GetSizeOfLen',
'uint8_t',
[],
is_const=True)
## wimax-mac-to-mac-header.h (module 'wimax'): static ns3::TypeId ns3::WimaxMacToMacHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-to-mac-header.h (module 'wimax'): void ns3::WimaxMacToMacHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): void ns3::WimaxMacToMacHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3WimaxPhy_methods(root_module, cls):
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::WimaxPhy(ns3::WimaxPhy const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxPhy const &', 'arg0')])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::WimaxPhy() [constructor]
cls.add_constructor([])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::Attach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::WimaxChannel> ns3::WimaxPhy::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::WimaxChannel >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetChannelBandwidth() const [member function]
cls.add_method('GetChannelBandwidth',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::EventId ns3::WimaxPhy::GetChnlSrchTimeoutEvent() const [member function]
cls.add_method('GetChnlSrchTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxPhy::GetDevice() const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDuration() const [member function]
cls.add_method('GetFrameDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('GetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::GetFrameDurationCode() const [member function]
cls.add_method('GetFrameDurationCode',
'uint8_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDurationSec() const [member function]
cls.add_method('GetFrameDurationSec',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetGValue() const [member function]
cls.add_method('GetGValue',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::Object> ns3::WimaxPhy::GetMobility() [member function]
cls.add_method('GetMobility',
'ns3::Ptr< ns3::Object >',
[],
is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetNfft() const [member function]
cls.add_method('GetNfft',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::GetNrCarriers() const [member function]
cls.add_method('GetNrCarriers',
'uint8_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType ns3::WimaxPhy::GetPhyType() const [member function]
cls.add_method('GetPhyType',
'ns3::WimaxPhy::PhyType',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetPsDuration() const [member function]
cls.add_method('GetPsDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetPsPerFrame() const [member function]
cls.add_method('GetPsPerFrame',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetPsPerSymbol() const [member function]
cls.add_method('GetPsPerSymbol',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Callback<void, ns3::Ptr<ns3::PacketBurst const>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::WimaxPhy::GetReceiveCallback() const [member function]
cls.add_method('GetReceiveCallback',
'ns3::Callback< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetRxFrequency() const [member function]
cls.add_method('GetRxFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetSamplingFactor() const [member function]
cls.add_method('GetSamplingFactor',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetSamplingFrequency() const [member function]
cls.add_method('GetSamplingFrequency',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetScanningFrequency() const [member function]
cls.add_method('GetScanningFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyState ns3::WimaxPhy::GetState() const [member function]
cls.add_method('GetState',
'ns3::WimaxPhy::PhyState',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetSymbolDuration() const [member function]
cls.add_method('GetSymbolDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetSymbolsPerFrame() const [member function]
cls.add_method('GetSymbolsPerFrame',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetTxFrequency() const [member function]
cls.add_method('GetTxFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): static ns3::TypeId ns3::WimaxPhy::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-phy.h (module 'wimax'): bool ns3::WimaxPhy::IsDuplex() const [member function]
cls.add_method('IsDuplex',
'bool',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::Send(ns3::SendParams * params) [member function]
cls.add_method('Send',
'void',
[param('ns3::SendParams *', 'params')],
is_pure_virtual=True, is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetChannelBandwidth(uint32_t channelBandwidth) [member function]
cls.add_method('SetChannelBandwidth',
'void',
[param('uint32_t', 'channelBandwidth')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDataRates() [member function]
cls.add_method('SetDataRates',
'void',
[])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDevice(ns3::Ptr<ns3::WimaxNetDevice> device) [member function]
cls.add_method('SetDevice',
'void',
[param('ns3::Ptr< ns3::WimaxNetDevice >', 'device')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDuplex(uint64_t rxFrequency, uint64_t txFrequency) [member function]
cls.add_method('SetDuplex',
'void',
[param('uint64_t', 'rxFrequency'), param('uint64_t', 'txFrequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetFrameDuration(ns3::Time frameDuration) [member function]
cls.add_method('SetFrameDuration',
'void',
[param('ns3::Time', 'frameDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetMobility(ns3::Ptr<ns3::Object> mobility) [member function]
cls.add_method('SetMobility',
'void',
[param('ns3::Ptr< ns3::Object >', 'mobility')],
is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetNrCarriers(uint8_t nrCarriers) [member function]
cls.add_method('SetNrCarriers',
'void',
[param('uint8_t', 'nrCarriers')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPhyParameters() [member function]
cls.add_method('SetPhyParameters',
'void',
[])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsDuration(ns3::Time psDuration) [member function]
cls.add_method('SetPsDuration',
'void',
[param('ns3::Time', 'psDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsPerFrame(uint16_t psPerFrame) [member function]
cls.add_method('SetPsPerFrame',
'void',
[param('uint16_t', 'psPerFrame')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsPerSymbol(uint16_t psPerSymbol) [member function]
cls.add_method('SetPsPerSymbol',
'void',
[param('uint16_t', 'psPerSymbol')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetReceiveCallback(ns3::Callback<void, ns3::Ptr<ns3::PacketBurst const>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('SetReceiveCallback',
'void',
[param('ns3::Callback< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetScanningCallback() const [member function]
cls.add_method('SetScanningCallback',
'void',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSimplex(uint64_t frequency) [member function]
cls.add_method('SetSimplex',
'void',
[param('uint64_t', 'frequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetState(ns3::WimaxPhy::PhyState state) [member function]
cls.add_method('SetState',
'void',
[param('ns3::WimaxPhy::PhyState', 'state')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSymbolDuration(ns3::Time symbolDuration) [member function]
cls.add_method('SetSymbolDuration',
'void',
[param('ns3::Time', 'symbolDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSymbolsPerFrame(uint32_t symbolsPerFrame) [member function]
cls.add_method('SetSymbolsPerFrame',
'void',
[param('uint32_t', 'symbolsPerFrame')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::StartScanning(uint64_t frequency, ns3::Time timeout, ns3::Callback<void, bool, unsigned long long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('StartScanning',
'void',
[param('uint64_t', 'frequency'), param('ns3::Time', 'timeout'), param('ns3::Callback< void, bool, unsigned long long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoAttach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::DoGetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::DoGetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('DoGetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::DoGetFrameDurationCode() const [member function]
cls.add_method('DoGetFrameDurationCode',
'uint8_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetGValue() const [member function]
cls.add_method('DoGetGValue',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetNfft() const [member function]
cls.add_method('DoGetNfft',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::DoGetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::DoGetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetRtg() const [member function]
cls.add_method('DoGetRtg',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetSamplingFactor() const [member function]
cls.add_method('DoGetSamplingFactor',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetSamplingFrequency() const [member function]
cls.add_method('DoGetSamplingFrequency',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::DoGetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetTtg() const [member function]
cls.add_method('DoGetTtg',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoSetDataRates() [member function]
cls.add_method('DoSetDataRates',
'void',
[],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoSetPhyParameters() [member function]
cls.add_method('DoSetPhyParameters',
'void',
[],
is_pure_virtual=True, visibility='private', is_virtual=True)
return
def register_Ns3AttributeAccessor_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
cls.add_method('Get',
'bool',
[param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function]
cls.add_method('HasGetter',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function]
cls.add_method('HasSetter',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
cls.add_method('Set',
'bool',
[param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3AttributeChecker_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
cls.add_method('Check',
'bool',
[param('ns3::AttributeValue const &', 'value')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
cls.add_method('Copy',
'bool',
[param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
cls.add_method('Create',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::CreateValidValue(ns3::AttributeValue const & value) const [member function]
cls.add_method('CreateValidValue',
'ns3::Ptr< ns3::AttributeValue >',
[param('ns3::AttributeValue const &', 'value')],
is_const=True)
## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
cls.add_method('GetUnderlyingTypeInformation',
'std::string',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
cls.add_method('GetValueTypeName',
'std::string',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
cls.add_method('HasUnderlyingTypeInformation',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3AttributeValue_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
cls.add_method('Copy',
'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<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> 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_Ns3BSScheduler_methods(root_module, cls):
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler(ns3::BSScheduler const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSScheduler const &', 'arg0')])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler() [constructor]
cls.add_constructor([])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): bool ns3::BSScheduler::CheckForFragmentation(ns3::Ptr<ns3::WimaxConnection> connection, int availableSymbols, ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('CheckForFragmentation',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('int', 'availableSymbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## bs-scheduler.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSScheduler::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): ns3::Ptr<ns3::BaseStationNetDevice> ns3::BSScheduler::GetBs() [member function]
cls.add_method('GetBs',
'ns3::Ptr< ns3::BaseStationNetDevice >',
[],
is_virtual=True)
## bs-scheduler.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSScheduler::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): static ns3::TypeId ns3::BSScheduler::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): bool ns3::BSScheduler::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::SetBs(ns3::Ptr<ns3::BaseStationNetDevice> bs) [member function]
cls.add_method('SetBs',
'void',
[param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')],
is_virtual=True)
return
def register_Ns3BSSchedulerRtps_methods(root_module, cls):
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps(ns3::BSSchedulerRtps const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSSchedulerRtps const &', 'arg0')])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps() [constructor]
cls.add_constructor([])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBEConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBEConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBasicConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBasicConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBroadcastConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBroadcastConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerInitialRangingConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerInitialRangingConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerNRTPSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerNRTPSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerPrimaryConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerPrimaryConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerRTPSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerRTPSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerUGSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerUGSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSSchedulerRtps::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSSchedulerRtps::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_const=True, is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): static ns3::TypeId ns3::BSSchedulerRtps::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectBEConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectBEConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectIRandBCConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectIRandBCConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectMenagementConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectMenagementConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectNRTPSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectNRTPSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectRTPSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectRTPSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectUGSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectUGSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
return
def register_Ns3BSSchedulerSimple_methods(root_module, cls):
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple(ns3::BSSchedulerSimple const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSSchedulerSimple const &', 'arg0')])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple() [constructor]
cls.add_constructor([])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler-simple.h (module 'wimax'): void ns3::BSSchedulerSimple::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSSchedulerSimple::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSSchedulerSimple::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_const=True, is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): static ns3::TypeId ns3::BSSchedulerSimple::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler-simple.h (module 'wimax'): void ns3::BSSchedulerSimple::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): bool ns3::BSSchedulerSimple::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_virtual=True)
return
def register_Ns3BandwidthRequestHeader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::BandwidthRequestHeader(ns3::BandwidthRequestHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BandwidthRequestHeader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::BandwidthRequestHeader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::GetBr() const [member function]
cls.add_method('GetBr',
'uint32_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::Cid ns3::BandwidthRequestHeader::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetEc() const [member function]
cls.add_method('GetEc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetHt() const [member function]
cls.add_method('GetHt',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::BandwidthRequestHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::BandwidthRequestHeader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::BandwidthRequestHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetBr(uint32_t br) [member function]
cls.add_method('SetBr',
'void',
[param('uint32_t', 'br')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetEc(uint8_t ec) [member function]
cls.add_method('SetEc',
'void',
[param('uint8_t', 'ec')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetHt(uint8_t HT) [member function]
cls.add_method('SetHt',
'void',
[param('uint8_t', 'HT')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): bool ns3::BandwidthRequestHeader::check_hcs() const [member function]
cls.add_method('check_hcs',
'bool',
[],
is_const=True)
return
def register_Ns3BsServiceFlowManager_methods(root_module, cls):
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::BsServiceFlowManager(ns3::BsServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BsServiceFlowManager const &', 'arg0')])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::BsServiceFlowManager(ns3::Ptr<ns3::BaseStationNetDevice> device) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'device')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AddMulticastServiceFlow(ns3::ServiceFlow sf, ns3::WimaxPhy::ModulationType modulation) [member function]
cls.add_method('AddMulticastServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf'), param('ns3::WimaxPhy::ModulationType', 'modulation')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AllocateServiceFlows(ns3::DsaReq const & dsaReq, ns3::Cid cid) [member function]
cls.add_method('AllocateServiceFlows',
'void',
[param('ns3::DsaReq const &', 'dsaReq'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::BsServiceFlowManager::GetDsaAckTimeoutEvent() const [member function]
cls.add_method('GetDsaAckTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::GetServiceFlow(uint32_t sfid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('uint32_t', 'sfid')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::GetServiceFlow(ns3::Cid cid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('ns3::Cid', 'cid')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::BsServiceFlowManager::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::ProcessDsaAck(ns3::DsaAck const & dsaAck, ns3::Cid cid) [member function]
cls.add_method('ProcessDsaAck',
'void',
[param('ns3::DsaAck const &', 'dsaAck'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::ProcessDsaReq(ns3::DsaReq const & dsaReq, ns3::Cid cid) [member function]
cls.add_method('ProcessDsaReq',
'ns3::ServiceFlow *',
[param('ns3::DsaReq const &', 'dsaReq'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::SetMaxDsaRspRetries(uint8_t maxDsaRspRetries) [member function]
cls.add_method('SetMaxDsaRspRetries',
'void',
[param('uint8_t', 'maxDsaRspRetries')])
return
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]
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]
cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3CallbackValue_methods(root_module, cls):
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor]
cls.add_constructor([])
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]
cls.add_constructor([param('ns3::CallbackBase const &', 'base')])
## callback.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_const=True, is_virtual=True)
## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## callback.h (module 'core'): void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]
cls.add_method('Set',
'void',
[param('ns3::CallbackBase', 'base')])
return
def register_Ns3Channel_methods(root_module, cls):
## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy 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::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[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',
'uint32_t',
[],
is_const=True)
## channel.h (module 'network'): uint32_t ns3::Channel::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## channel.h (module 'network'): static ns3::TypeId ns3::Channel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
def register_Ns3ConnectionManager_methods(root_module, cls):
## connection-manager.h (module 'wimax'): ns3::ConnectionManager::ConnectionManager(ns3::ConnectionManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ConnectionManager const &', 'arg0')])
## connection-manager.h (module 'wimax'): ns3::ConnectionManager::ConnectionManager() [constructor]
cls.add_constructor([])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::AddConnection(ns3::Ptr<ns3::WimaxConnection> connection, ns3::Cid::Type type) [member function]
cls.add_method('AddConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('ns3::Cid::Type', 'type')])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::AllocateManagementConnections(ns3::SSRecord * ssRecord, ns3::RngRsp * rngrsp) [member function]
cls.add_method('AllocateManagementConnections',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::RngRsp *', 'rngrsp')])
## connection-manager.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ConnectionManager::CreateConnection(ns3::Cid::Type type) [member function]
cls.add_method('CreateConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid::Type', 'type')])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## connection-manager.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ConnectionManager::GetConnection(ns3::Cid cid) [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid', 'cid')])
## connection-manager.h (module 'wimax'): std::vector<ns3::Ptr<ns3::WimaxConnection>, std::allocator<ns3::Ptr<ns3::WimaxConnection> > > ns3::ConnectionManager::GetConnections(ns3::Cid::Type type) const [member function]
cls.add_method('GetConnections',
'std::vector< ns3::Ptr< ns3::WimaxConnection > >',
[param('ns3::Cid::Type', 'type')],
is_const=True)
## connection-manager.h (module 'wimax'): uint32_t ns3::ConnectionManager::GetNPackets(ns3::Cid::Type type, ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetNPackets',
'uint32_t',
[param('ns3::Cid::Type', 'type'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## connection-manager.h (module 'wimax'): static ns3::TypeId ns3::ConnectionManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## connection-manager.h (module 'wimax'): bool ns3::ConnectionManager::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::SetCidFactory(ns3::CidFactory * cidFactory) [member function]
cls.add_method('SetCidFactory',
'void',
[param('ns3::CidFactory *', 'cidFactory')])
return
def register_Ns3Dcd_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::Dcd::Dcd(ns3::Dcd const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Dcd const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::Dcd::Dcd() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::AddDlBurstProfile(ns3::OfdmDlBurstProfile dlBurstProfile) [member function]
cls.add_method('AddDlBurstProfile',
'void',
[param('ns3::OfdmDlBurstProfile', 'dlBurstProfile')])
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::Dcd::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings ns3::Dcd::GetChannelEncodings() const [member function]
cls.add_method('GetChannelEncodings',
'ns3::OfdmDcdChannelEncodings',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::Dcd::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): std::vector<ns3::OfdmDlBurstProfile, std::allocator<ns3::OfdmDlBurstProfile> > ns3::Dcd::GetDlBurstProfiles() const [member function]
cls.add_method('GetDlBurstProfiles',
'std::vector< ns3::OfdmDlBurstProfile >',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::TypeId ns3::Dcd::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): std::string ns3::Dcd::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::Dcd::GetNrDlBurstProfiles() const [member function]
cls.add_method('GetNrDlBurstProfiles',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::Dcd::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::Dcd::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetChannelEncodings(ns3::OfdmDcdChannelEncodings channelEncodings) [member function]
cls.add_method('SetChannelEncodings',
'void',
[param('ns3::OfdmDcdChannelEncodings', 'channelEncodings')])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetConfigurationChangeCount(uint8_t configurationChangeCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'configurationChangeCount')])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetNrDlBurstProfiles(uint8_t nrDlBurstProfiles) [member function]
cls.add_method('SetNrDlBurstProfiles',
'void',
[param('uint8_t', 'nrDlBurstProfiles')])
return
def register_Ns3DlMap_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::DlMap::DlMap(ns3::DlMap const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DlMap const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::DlMap::DlMap() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::AddDlMapElement(ns3::OfdmDlMapIe dlMapElement) [member function]
cls.add_method('AddDlMapElement',
'void',
[param('ns3::OfdmDlMapIe', 'dlMapElement')])
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DlMap::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::DlMap::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::DlMap::GetDcdCount() const [member function]
cls.add_method('GetDcdCount',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): std::list<ns3::OfdmDlMapIe, std::allocator<ns3::OfdmDlMapIe> > ns3::DlMap::GetDlMapElements() const [member function]
cls.add_method('GetDlMapElements',
'std::list< ns3::OfdmDlMapIe >',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::TypeId ns3::DlMap::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): std::string ns3::DlMap::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DlMap::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DlMap::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::SetBaseStationId(ns3::Mac48Address baseStationID) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationID')])
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::SetDcdCount(uint8_t dcdCount) [member function]
cls.add_method('SetDcdCount',
'void',
[param('uint8_t', 'dcdCount')])
return
def register_Ns3DsaAck_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaAck::DsaAck(ns3::DsaAck const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaAck const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaAck::DsaAck() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaAck::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaAck::GetConfirmationCode() const [member function]
cls.add_method('GetConfirmationCode',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaAck::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaAck::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaAck::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaAck::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaAck::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::SetConfirmationCode(uint16_t confirmationCode) [member function]
cls.add_method('SetConfirmationCode',
'void',
[param('uint16_t', 'confirmationCode')])
## mac-messages.h (module 'wimax'): void ns3::DsaAck::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3DsaReq_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq(ns3::DsaReq const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaReq const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq(ns3::ServiceFlow sf) [constructor]
cls.add_constructor([param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::DsaReq::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaReq::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaReq::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::ServiceFlow ns3::DsaReq::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaReq::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaReq::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetSfid(uint32_t sfid) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'sfid')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3DsaRsp_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaRsp::DsaRsp(ns3::DsaRsp const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaRsp const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaRsp::DsaRsp() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::DsaRsp::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaRsp::GetConfirmationCode() const [member function]
cls.add_method('GetConfirmationCode',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaRsp::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaRsp::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::ServiceFlow ns3::DsaRsp::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaRsp::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaRsp::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetConfirmationCode(uint16_t confirmationCode) [member function]
cls.add_method('SetConfirmationCode',
'void',
[param('uint16_t', 'confirmationCode')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetSfid(uint32_t sfid) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'sfid')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3EmptyAttributeValue_methods(root_module, cls):
## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
cls.add_method('Copy',
'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<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3EventImpl_methods(root_module, cls):
## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor]
cls.add_constructor([])
## event-impl.h (module 'core'): void ns3::EventImpl::Cancel() [member function]
cls.add_method('Cancel',
'void',
[])
## event-impl.h (module 'core'): void ns3::EventImpl::Invoke() [member function]
cls.add_method('Invoke',
'void',
[])
## event-impl.h (module 'core'): bool ns3::EventImpl::IsCancelled() [member function]
cls.add_method('IsCancelled',
'bool',
[])
## event-impl.h (module 'core'): void ns3::EventImpl::Notify() [member function]
cls.add_method('Notify',
'void',
[],
is_pure_virtual=True, visibility='protected', is_virtual=True)
return
def register_Ns3FixedRssLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::FixedRssLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel::FixedRssLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::FixedRssLossModel::SetRss(double rss) [member function]
cls.add_method('SetRss',
'void',
[param('double', 'rss')])
## propagation-loss-model.h (module 'propagation'): double ns3::FixedRssLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3FragmentationSubheader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader::FragmentationSubheader(ns3::FragmentationSubheader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::FragmentationSubheader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader::FragmentationSubheader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::FragmentationSubheader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::FragmentationSubheader::GetFc() const [member function]
cls.add_method('GetFc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::FragmentationSubheader::GetFsn() const [member function]
cls.add_method('GetFsn',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::FragmentationSubheader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::FragmentationSubheader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::FragmentationSubheader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::FragmentationSubheader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::SetFc(uint8_t fc) [member function]
cls.add_method('SetFc',
'void',
[param('uint8_t', 'fc')])
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::SetFsn(uint8_t fsn) [member function]
cls.add_method('SetFsn',
'void',
[param('uint8_t', 'fsn')])
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',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'frequency'), param('double', 'speed')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'lambda')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
cls.add_method('SetSystemLoss',
'void',
[param('double', 'systemLoss')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetMinDistance(double minDistance) [member function]
cls.add_method('SetMinDistance',
'void',
[param('double', 'minDistance')])
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetMinDistance() const [member function]
cls.add_method('GetMinDistance',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetLambda() const [member function]
cls.add_method('GetLambda',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function]
cls.add_method('GetSystemLoss',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3GenericMacHeader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader::GenericMacHeader(ns3::GenericMacHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GenericMacHeader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader::GenericMacHeader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GenericMacHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetCi() const [member function]
cls.add_method('GetCi',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::Cid ns3::GenericMacHeader::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetEc() const [member function]
cls.add_method('GetEc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetEks() const [member function]
cls.add_method('GetEks',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetHt() const [member function]
cls.add_method('GetHt',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::GenericMacHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint16_t ns3::GenericMacHeader::GetLen() const [member function]
cls.add_method('GetLen',
'uint16_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::GenericMacHeader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GenericMacHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::GenericMacHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetCi(uint8_t ci) [member function]
cls.add_method('SetCi',
'void',
[param('uint8_t', 'ci')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetEc(uint8_t ec) [member function]
cls.add_method('SetEc',
'void',
[param('uint8_t', 'ec')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetEks(uint8_t eks) [member function]
cls.add_method('SetEks',
'void',
[param('uint8_t', 'eks')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetHt(uint8_t HT) [member function]
cls.add_method('SetHt',
'void',
[param('uint8_t', 'HT')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetLen(uint16_t len) [member function]
cls.add_method('SetLen',
'void',
[param('uint16_t', 'len')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): bool ns3::GenericMacHeader::check_hcs() const [member function]
cls.add_method('check_hcs',
'bool',
[],
is_const=True)
return
def register_Ns3GrantManagementSubheader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader::GrantManagementSubheader(ns3::GrantManagementSubheader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GrantManagementSubheader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader::GrantManagementSubheader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GrantManagementSubheader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::GrantManagementSubheader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::GrantManagementSubheader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint16_t ns3::GrantManagementSubheader::GetPbr() const [member function]
cls.add_method('GetPbr',
'uint16_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GrantManagementSubheader::GetPm() const [member function]
cls.add_method('GetPm',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GrantManagementSubheader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GrantManagementSubheader::GetSi() const [member function]
cls.add_method('GetSi',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::GrantManagementSubheader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetPbr(uint16_t pbr) [member function]
cls.add_method('SetPbr',
'void',
[param('uint16_t', 'pbr')])
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetPm(uint8_t pm) [member function]
cls.add_method('SetPm',
'void',
[param('uint8_t', 'pm')])
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetSi(uint8_t si) [member function]
cls.add_method('SetSi',
'void',
[param('uint8_t', 'si')])
return
def register_Ns3IpcsClassifier_methods(root_module, cls):
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier::IpcsClassifier(ns3::IpcsClassifier const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IpcsClassifier const &', 'arg0')])
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier::IpcsClassifier() [constructor]
cls.add_constructor([])
## ipcs-classifier.h (module 'wimax'): ns3::ServiceFlow * ns3::IpcsClassifier::Classify(ns3::Ptr<const ns3::Packet> packet, ns3::Ptr<ns3::ServiceFlowManager> sfm, ns3::ServiceFlow::Direction dir) [member function]
cls.add_method('Classify',
'ns3::ServiceFlow *',
[param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::ServiceFlowManager >', 'sfm'), param('ns3::ServiceFlow::Direction', 'dir')])
## ipcs-classifier.h (module 'wimax'): static ns3::TypeId ns3::IpcsClassifier::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv4Address',
[],
is_const=True)
## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv4Address const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv4Mask',
[],
is_const=True)
## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv4Mask const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv6Address',
[],
is_const=True)
## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6AddressValue::Set(ns3::Ipv6Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv6Address const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix ns3::Ipv6PrefixValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv6Prefix',
[],
is_const=True)
## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6PrefixValue::Set(ns3::Ipv6Prefix const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv6Prefix const &', 'value')])
return
def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
cls.add_method('SetPathLossExponent',
'void',
[param('double', 'n')])
## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
cls.add_method('GetPathLossExponent',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
cls.add_method('SetReference',
'void',
[param('double', 'referenceDistance'), param('double', 'referenceLoss')])
## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## mac48-address.h (module 'network'): ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Mac48Address',
[],
is_const=True)
## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## mac48-address.h (module 'network'): void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Mac48Address const &', 'value')])
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',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel::MatrixPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b, double loss, bool symmetric=true) [member function]
cls.add_method('SetLoss',
'void',
[param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('double', 'loss'), param('bool', 'symmetric', default_value='true')])
## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetDefaultLoss(double arg0) [member function]
cls.add_method('SetDefaultLoss',
'void',
[param('double', 'arg0')])
## propagation-loss-model.h (module 'propagation'): double ns3::MatrixPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::NakagamiPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel::NakagamiPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::NakagamiPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=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]
cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('AddLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetAddress() const [member function]
cls.add_method('GetAddress',
'ns3::Address',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
cls.add_method('GetBroadcast',
'ns3::Address',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): uint32_t ns3::NetDevice::GetIfIndex() const [member function]
cls.add_method('GetIfIndex',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): uint16_t ns3::NetDevice::GetMtu() const [member function]
cls.add_method('GetMtu',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv6Address', 'addr')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
cls.add_method('GetNode',
'ns3::Ptr< ns3::Node >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsBridge() const [member function]
cls.add_method('IsBridge',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsLinkUp() const [member function]
cls.add_method('IsLinkUp',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsPointToPoint() const [member function]
cls.add_method('IsPointToPoint',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::NeedsArp() const [member function]
cls.add_method('NeedsArp',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> 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')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> 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')],
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',
'void',
[param('ns3::Address', 'address')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
cls.add_method('SetIfIndex',
'void',
[param('uint32_t const', 'index')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
cls.add_method('SetMtu',
'bool',
[param('uint16_t const', 'mtu')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('SetNode',
'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<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) [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<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) [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_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SupportsSendFrom() const [member function]
cls.add_method('SupportsSendFrom',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
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]
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')])
## 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')],
is_const=True)
## nix-vector.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::NixVector::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::NixVector >',
[],
is_const=True)
## 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')])
## 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')])
## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetRemainingBits() [member function]
cls.add_method('GetRemainingBits',
'uint32_t',
[])
## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## 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')],
is_const=True)
return
def register_Ns3Node_methods(root_module, cls):
## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Node const &', 'arg0')])
## node.h (module 'network'): ns3::Node::Node() [constructor]
cls.add_constructor([])
## node.h (module 'network'): ns3::Node::Node(uint32_t systemId) [constructor]
cls.add_constructor([param('uint32_t', 'systemId')])
## node.h (module 'network'): uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
cls.add_method('AddApplication',
'uint32_t',
[param('ns3::Ptr< ns3::Application >', 'application')])
## node.h (module 'network'): uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
cls.add_method('AddDevice',
'uint32_t',
[param('ns3::Ptr< ns3::NetDevice >', 'device')])
## node.h (module 'network'): static bool ns3::Node::ChecksumEnabled() [member function]
cls.add_method('ChecksumEnabled',
'bool',
[],
is_static=True)
## node.h (module 'network'): ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
cls.add_method('GetApplication',
'ns3::Ptr< ns3::Application >',
[param('uint32_t', 'index')],
is_const=True)
## node.h (module 'network'): ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'index')],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetId() const [member function]
cls.add_method('GetId',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetNApplications() const [member function]
cls.add_method('GetNApplications',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetSystemId() const [member function]
cls.add_method('GetSystemId',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): static ns3::TypeId ns3::Node::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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<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, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> 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<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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<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) [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')])
## node.h (module 'network'): void ns3::Node::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='protected', is_virtual=True)
## node.h (module 'network'): void ns3::Node::DoStart() [member function]
cls.add_method('DoStart',
'void',
[],
visibility='protected', is_virtual=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## object-factory.h (module 'core'): ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
cls.add_method('Get',
'ns3::ObjectFactory',
[],
is_const=True)
## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## object-factory.h (module 'core'): void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::ObjectFactory const &', 'value')])
return
def register_Ns3OutputStreamWrapper_methods(root_module, cls):
## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy 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::ostream * os) [constructor]
cls.add_constructor([param('std::ostream *', 'os')])
## output-stream-wrapper.h (module 'network'): std::ostream * ns3::OutputStreamWrapper::GetStream() [member function]
cls.add_method('GetStream',
'std::ostream *',
[])
return
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]
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')])
## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size, bool magic) [constructor]
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<const ns3::Packet> packet) [member function]
cls.add_method('AddAtEnd',
'void',
[param('ns3::Ptr< ns3::Packet const >', 'packet')])
## packet.h (module 'network'): void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
cls.add_method('AddByteTag',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
cls.add_method('AddHeader',
'void',
[param('ns3::Header const &', 'header')])
## packet.h (module 'network'): void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
cls.add_method('AddPacketTag',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
cls.add_method('AddPaddingAtEnd',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
cls.add_method('AddTrailer',
'void',
[param('ns3::Trailer const &', 'trailer')])
## packet.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
cls.add_method('BeginItem',
'ns3::PacketMetadata::ItemIterator',
[],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::Packet >',
[],
is_const=True)
## 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')],
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')],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::Packet> 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')],
is_const=True)
## packet.h (module 'network'): static void ns3::Packet::EnableChecking() [member function]
cls.add_method('EnableChecking',
'void',
[],
is_static=True)
## packet.h (module 'network'): static void ns3::Packet::EnablePrinting() [member function]
cls.add_method('EnablePrinting',
'void',
[],
is_static=True)
## packet.h (module 'network'): bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
cls.add_method('FindFirstMatchingByteTag',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
cls.add_method('GetByteTagIterator',
'ns3::ByteTagIterator',
[],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
cls.add_method('GetNixVector',
'ns3::Ptr< ns3::NixVector >',
[],
is_const=True)
## packet.h (module 'network'): ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
cls.add_method('GetPacketTagIterator',
'ns3::PacketTagIterator',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint64_t ns3::Packet::GetUid() const [member function]
cls.add_method('GetUid',
'uint64_t',
[],
is_const=True)
## packet.h (module 'network'): uint8_t const * ns3::Packet::PeekData() const [member function]
cls.add_method('PeekData',
'uint8_t const *',
[],
deprecated=True, is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
cls.add_method('PeekHeader',
'uint32_t',
[param('ns3::Header &', 'header')],
is_const=True)
## packet.h (module 'network'): bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
cls.add_method('PeekPacketTag',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
cls.add_method('PeekTrailer',
'uint32_t',
[param('ns3::Trailer &', 'trailer')])
## packet.h (module 'network'): void ns3::Packet::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
cls.add_method('PrintByteTags',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
cls.add_method('PrintPacketTags',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::RemoveAllByteTags() [member function]
cls.add_method('RemoveAllByteTags',
'void',
[])
## packet.h (module 'network'): void ns3::Packet::RemoveAllPacketTags() [member function]
cls.add_method('RemoveAllPacketTags',
'void',
[])
## packet.h (module 'network'): void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
cls.add_method('RemoveAtEnd',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
cls.add_method('RemoveAtStart',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
cls.add_method('RemoveHeader',
'uint32_t',
[param('ns3::Header &', 'header')])
## packet.h (module 'network'): bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
cls.add_method('RemovePacketTag',
'bool',
[param('ns3::Tag &', 'tag')])
## packet.h (module 'network'): uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
cls.add_method('RemoveTrailer',
'uint32_t',
[param('ns3::Trailer &', 'trailer')])
## 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')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
cls.add_method('SetNixVector',
'void',
[param('ns3::Ptr< ns3::NixVector >', 'arg0')])
return
def register_Ns3RandomVariableChecker_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
return
def register_Ns3RandomVariableValue_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
## random-variable.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_const=True, is_virtual=True)
## random-variable.h (module 'core'): bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## random-variable.h (module 'core'): ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
cls.add_method('Get',
'ns3::RandomVariable',
[],
is_const=True)
## random-variable.h (module 'core'): std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## random-variable.h (module 'core'): void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::RandomVariable const &', 'value')])
return
def register_Ns3SimpleOfdmWimaxPhy_methods(root_module, cls):
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy(ns3::SimpleOfdmWimaxPhy const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxPhy const &', 'arg0')])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy() [constructor]
cls.add_constructor([])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy(char * tracesPath) [constructor]
cls.add_constructor([param('char *', 'tracesPath')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::ActivateLoss(bool loss) [member function]
cls.add_method('ActivateLoss',
'void',
[param('bool', 'loss')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoAttach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')],
is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxPhy::GetBandwidth() const [member function]
cls.add_method('GetBandwidth',
'uint32_t',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::GetNoiseFigure() const [member function]
cls.add_method('GetNoiseFigure',
'double',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType ns3::SimpleOfdmWimaxPhy::GetPhyType() const [member function]
cls.add_method('GetPhyType',
'ns3::WimaxPhy::PhyType',
[],
is_const=True, is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::GetTxPower() const [member function]
cls.add_method('GetTxPower',
'double',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): static ns3::TypeId ns3::SimpleOfdmWimaxPhy::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxBegin(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxBegin',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxDrop(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxDrop',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxEnd(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxEnd',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxBegin(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxBegin',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxDrop(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxDrop',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxEnd(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxEnd',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::Send(ns3::Ptr<ns3::PacketBurst> burst, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction) [member function]
cls.add_method('Send',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::Send(ns3::SendParams * params) [member function]
cls.add_method('Send',
'void',
[param('ns3::SendParams *', 'params')],
is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetBandwidth(uint32_t BW) [member function]
cls.add_method('SetBandwidth',
'void',
[param('uint32_t', 'BW')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetNoiseFigure(double nf) [member function]
cls.add_method('SetNoiseFigure',
'void',
[param('double', 'nf')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetReceiveCallback(ns3::Callback<void,ns3::Ptr<ns3::PacketBurst>,ns3::Ptr<ns3::WimaxConnection>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> callback) [member function]
cls.add_method('SetReceiveCallback',
'void',
[param('ns3::Callback< void, ns3::Ptr< ns3::PacketBurst >, ns3::Ptr< ns3::WimaxConnection >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetSNRToBlockErrorRateTracesPath(char * tracesPath) [member function]
cls.add_method('SetSNRToBlockErrorRateTracesPath',
'void',
[param('char *', 'tracesPath')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetTxPower(double txPower) [member function]
cls.add_method('SetTxPower',
'void',
[param('double', 'txPower')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::StartReceive(uint32_t burstSize, bool isFirstBlock, uint64_t frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPower, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('StartReceive',
'void',
[param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPower'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxPhy::DoGetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::Time ns3::SimpleOfdmWimaxPhy::DoGetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('DoGetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint8_t ns3::SimpleOfdmWimaxPhy::DoGetFrameDurationCode() const [member function]
cls.add_method('DoGetFrameDurationCode',
'uint8_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetGValue() const [member function]
cls.add_method('DoGetGValue',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetNfft() const [member function]
cls.add_method('DoGetNfft',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint64_t ns3::SimpleOfdmWimaxPhy::DoGetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint64_t ns3::SimpleOfdmWimaxPhy::DoGetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetRtg() const [member function]
cls.add_method('DoGetRtg',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetSamplingFactor() const [member function]
cls.add_method('DoGetSamplingFactor',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetSamplingFrequency() const [member function]
cls.add_method('DoGetSamplingFrequency',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::Time ns3::SimpleOfdmWimaxPhy::DoGetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetTtg() const [member function]
cls.add_method('DoGetTtg',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoSetDataRates() [member function]
cls.add_method('DoSetDataRates',
'void',
[],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoSetPhyParameters() [member function]
cls.add_method('DoSetPhyParameters',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3TimeChecker_methods(root_module, cls):
## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker() [constructor]
cls.add_constructor([])
## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
return
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## nstime.h (module 'core'): ns3::Time ns3::TimeValue::Get() const [member function]
cls.add_method('Get',
'ns3::Time',
[],
is_const=True)
## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## nstime.h (module 'core'): void ns3::TimeValue::Set(ns3::Time const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Time const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeIdValue::Get() const [member function]
cls.add_method('Get',
'ns3::TypeId',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## type-id.h (module 'core'): void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::TypeId const &', 'value')])
return
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## uinteger.h (module 'core'): uint64_t ns3::UintegerValue::Get() const [member function]
cls.add_method('Get',
'uint64_t',
[],
is_const=True)
## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## uinteger.h (module 'core'): void ns3::UintegerValue::Set(uint64_t const & value) [member function]
cls.add_method('Set',
'void',
[param('uint64_t const &', 'value')])
return
def register_Ns3WimaxChannel_methods(root_module, cls):
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel::WimaxChannel(ns3::WimaxChannel const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxChannel const &', 'arg0')])
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel::WimaxChannel() [constructor]
cls.add_constructor([])
## wimax-channel.h (module 'wimax'): void ns3::WimaxChannel::Attach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxChannel::GetDevice(uint32_t i) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_const=True, is_virtual=True)
## wimax-channel.h (module 'wimax'): uint32_t ns3::WimaxChannel::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-channel.h (module 'wimax'): static ns3::TypeId ns3::WimaxChannel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-channel.h (module 'wimax'): void ns3::WimaxChannel::DoAttach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxChannel::DoGetDevice(uint32_t i) const [member function]
cls.add_method('DoGetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-channel.h (module 'wimax'): uint32_t ns3::WimaxChannel::DoGetNDevices() const [member function]
cls.add_method('DoGetNDevices',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3WimaxNetDevice_methods(root_module, cls):
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_direction [variable]
cls.add_static_attribute('m_direction', 'uint8_t', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_frameStartTime [variable]
cls.add_static_attribute('m_frameStartTime', 'ns3::Time', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_traceRx [variable]
cls.add_instance_attribute('m_traceRx', 'ns3::TracedCallback< ns3::Ptr< ns3::Packet const >, ns3::Mac48Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_traceTx [variable]
cls.add_instance_attribute('m_traceTx', 'ns3::TracedCallback< ns3::Ptr< ns3::Packet const >, ns3::Mac48Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', is_const=False)
## wimax-net-device.h (module 'wimax'): static ns3::TypeId ns3::WimaxNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::WimaxNetDevice() [constructor]
cls.add_constructor([])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetTtg(uint16_t ttg) [member function]
cls.add_method('SetTtg',
'void',
[param('uint16_t', 'ttg')])
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint16_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetRtg(uint16_t rtg) [member function]
cls.add_method('SetRtg',
'void',
[param('uint16_t', 'rtg')])
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint16_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Attach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetPhy(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('SetPhy',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxNetDevice::GetPhy() const [member function]
cls.add_method('GetPhy',
'ns3::Ptr< ns3::WimaxPhy >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetChannel(ns3::Ptr<ns3::WimaxChannel> wimaxChannel) [member function]
cls.add_method('SetChannel',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'wimaxChannel')])
## wimax-net-device.h (module 'wimax'): uint64_t ns3::WimaxNetDevice::GetChannel(uint8_t index) const [member function]
cls.add_method('GetChannel',
'uint64_t',
[param('uint8_t', 'index')],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetNrFrames(uint32_t nrFrames) [member function]
cls.add_method('SetNrFrames',
'void',
[param('uint32_t', 'nrFrames')])
## wimax-net-device.h (module 'wimax'): uint32_t ns3::WimaxNetDevice::GetNrFrames() const [member function]
cls.add_method('GetNrFrames',
'uint32_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetMacAddress(ns3::Mac48Address address) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'address')])
## wimax-net-device.h (module 'wimax'): ns3::Mac48Address ns3::WimaxNetDevice::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetState(uint8_t state) [member function]
cls.add_method('SetState',
'void',
[param('uint8_t', 'state')])
## wimax-net-device.h (module 'wimax'): uint8_t ns3::WimaxNetDevice::GetState() const [member function]
cls.add_method('GetState',
'uint8_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::WimaxNetDevice::GetInitialRangingConnection() const [member function]
cls.add_method('GetInitialRangingConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::WimaxNetDevice::GetBroadcastConnection() const [member function]
cls.add_method('GetBroadcastConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetCurrentDcd(ns3::Dcd dcd) [member function]
cls.add_method('SetCurrentDcd',
'void',
[param('ns3::Dcd', 'dcd')])
## wimax-net-device.h (module 'wimax'): ns3::Dcd ns3::WimaxNetDevice::GetCurrentDcd() const [member function]
cls.add_method('GetCurrentDcd',
'ns3::Dcd',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetCurrentUcd(ns3::Ucd ucd) [member function]
cls.add_method('SetCurrentUcd',
'void',
[param('ns3::Ucd', 'ucd')])
## wimax-net-device.h (module 'wimax'): ns3::Ucd ns3::WimaxNetDevice::GetCurrentUcd() const [member function]
cls.add_method('GetCurrentUcd',
'ns3::Ucd',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::ConnectionManager> ns3::WimaxNetDevice::GetConnectionManager() const [member function]
cls.add_method('GetConnectionManager',
'ns3::Ptr< ns3::ConnectionManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetConnectionManager(ns3::Ptr<ns3::ConnectionManager> connectionManager) [member function]
cls.add_method('SetConnectionManager',
'void',
[param('ns3::Ptr< ns3::ConnectionManager >', 'connectionManager')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::BurstProfileManager> ns3::WimaxNetDevice::GetBurstProfileManager() const [member function]
cls.add_method('GetBurstProfileManager',
'ns3::Ptr< ns3::BurstProfileManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetBurstProfileManager(ns3::Ptr<ns3::BurstProfileManager> burstProfileManager) [member function]
cls.add_method('SetBurstProfileManager',
'void',
[param('ns3::Ptr< ns3::BurstProfileManager >', 'burstProfileManager')])
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::BandwidthManager> ns3::WimaxNetDevice::GetBandwidthManager() const [member function]
cls.add_method('GetBandwidthManager',
'ns3::Ptr< ns3::BandwidthManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetBandwidthManager(ns3::Ptr<ns3::BandwidthManager> bandwidthManager) [member function]
cls.add_method('SetBandwidthManager',
'void',
[param('ns3::Ptr< ns3::BandwidthManager >', 'bandwidthManager')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::CreateDefaultConnections() [member function]
cls.add_method('CreateDefaultConnections',
'void',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetReceiveCallback() [member function]
cls.add_method('SetReceiveCallback',
'void',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::ForwardUp(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest) [member function]
cls.add_method('ForwardUp',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest')])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::ForwardDown(ns3::Ptr<ns3::PacketBurst> burst, ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('ForwardDown',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetName(std::string const name) [member function]
cls.add_method('SetName',
'void',
[param('std::string const', 'name')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): std::string ns3::WimaxNetDevice::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetIfIndex(uint32_t const index) [member function]
cls.add_method('SetIfIndex',
'void',
[param('uint32_t const', 'index')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): uint32_t ns3::WimaxNetDevice::GetIfIndex() const [member function]
cls.add_method('GetIfIndex',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Channel> ns3::WimaxNetDevice::GetPhyChannel() const [member function]
cls.add_method('GetPhyChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Channel> ns3::WimaxNetDevice::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetAddress(ns3::Address address) [member function]
cls.add_method('SetAddress',
'void',
[param('ns3::Address', 'address')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetAddress() const [member function]
cls.add_method('GetAddress',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SetMtu(uint16_t const mtu) [member function]
cls.add_method('SetMtu',
'bool',
[param('uint16_t const', 'mtu')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetMtu() const [member function]
cls.add_method('GetMtu',
'uint16_t',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsLinkUp() const [member function]
cls.add_method('IsLinkUp',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('SetLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetBroadcast() const [member function]
cls.add_method('GetBroadcast',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast() const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('MakeMulticastAddress',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsPointToPoint() const [member function]
cls.add_method('IsPointToPoint',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::Send(ns3::Ptr<ns3::Packet> 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')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('SetNode',
'void',
[param('ns3::Ptr< ns3::Node >', 'node')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Node> ns3::WimaxNetDevice::GetNode() const [member function]
cls.add_method('GetNode',
'ns3::Ptr< ns3::Node >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::NeedsArp() const [member function]
cls.add_method('NeedsArp',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetReceiveCallback(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) [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)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::AddLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('AddLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SendFrom(ns3::Ptr<ns3::Packet> 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')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetPromiscReceiveCallback(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) [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)
## wimax-net-device.h (module 'wimax'): 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> ns3::WimaxNetDevice::GetPromiscReceiveCallback() [member function]
cls.add_method('GetPromiscReceiveCallback',
'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 >',
[])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SupportsSendFrom() const [member function]
cls.add_method('SupportsSendFrom',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv6Address', 'addr')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsBridge() const [member function]
cls.add_method('IsBridge',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsPromisc() [member function]
cls.add_method('IsPromisc',
'bool',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::NotifyPromiscTrace(ns3::Ptr<ns3::Packet> p) [member function]
cls.add_method('NotifyPromiscTrace',
'void',
[param('ns3::Ptr< ns3::Packet >', 'p')])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxChannel> ns3::WimaxNetDevice::DoGetChannel() const [member function]
cls.add_method('DoGetChannel',
'ns3::Ptr< ns3::WimaxChannel >',
[],
is_const=True, visibility='private', is_virtual=True)
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## address.h (module 'network'): ns3::Address ns3::AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Address',
[],
is_const=True)
## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## address.h (module 'network'): void ns3::AddressValue::Set(ns3::Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Address const &', 'value')])
return
def register_Ns3BaseStationNetDevice_methods(root_module, cls):
## bs-net-device.h (module 'wimax'): static ns3::TypeId ns3::BaseStationNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice() [constructor]
cls.add_constructor([])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice(ns3::Ptr<ns3::Node> node, ns3::Ptr<ns3::WimaxPhy> phy) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice(ns3::Ptr<ns3::Node> node, ns3::Ptr<ns3::WimaxPhy> phy, ns3::Ptr<ns3::UplinkScheduler> uplinkScheduler, ns3::Ptr<ns3::BSScheduler> bsScheduler) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy'), param('ns3::Ptr< ns3::UplinkScheduler >', 'uplinkScheduler'), param('ns3::Ptr< ns3::BSScheduler >', 'bsScheduler')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetInitialRangingInterval(ns3::Time initialRangInterval) [member function]
cls.add_method('SetInitialRangingInterval',
'void',
[param('ns3::Time', 'initialRangInterval')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::InitBaseStationNetDevice() [member function]
cls.add_method('InitBaseStationNetDevice',
'void',
[])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetInitialRangingInterval() const [member function]
cls.add_method('GetInitialRangingInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetDcdInterval(ns3::Time dcdInterval) [member function]
cls.add_method('SetDcdInterval',
'void',
[param('ns3::Time', 'dcdInterval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetDcdInterval() const [member function]
cls.add_method('GetDcdInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetUcdInterval(ns3::Time ucdInterval) [member function]
cls.add_method('SetUcdInterval',
'void',
[param('ns3::Time', 'ucdInterval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetUcdInterval() const [member function]
cls.add_method('GetUcdInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetIntervalT8(ns3::Time interval) [member function]
cls.add_method('SetIntervalT8',
'void',
[param('ns3::Time', 'interval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetIntervalT8() const [member function]
cls.add_method('GetIntervalT8',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetMaxRangingCorrectionRetries(uint8_t maxRangCorrectionRetries) [member function]
cls.add_method('SetMaxRangingCorrectionRetries',
'void',
[param('uint8_t', 'maxRangCorrectionRetries')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetMaxRangingCorrectionRetries() const [member function]
cls.add_method('GetMaxRangingCorrectionRetries',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetMaxInvitedRangRetries(uint8_t maxInvitedRangRetries) [member function]
cls.add_method('SetMaxInvitedRangRetries',
'void',
[param('uint8_t', 'maxInvitedRangRetries')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetMaxInvitedRangRetries() const [member function]
cls.add_method('GetMaxInvitedRangRetries',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetRangReqOppSize(uint8_t rangReqOppSize) [member function]
cls.add_method('SetRangReqOppSize',
'void',
[param('uint8_t', 'rangReqOppSize')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetRangReqOppSize() const [member function]
cls.add_method('GetRangReqOppSize',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBwReqOppSize(uint8_t bwReqOppSize) [member function]
cls.add_method('SetBwReqOppSize',
'void',
[param('uint8_t', 'bwReqOppSize')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetBwReqOppSize() const [member function]
cls.add_method('GetBwReqOppSize',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetNrDlSymbols(uint32_t dlSymbols) [member function]
cls.add_method('SetNrDlSymbols',
'void',
[param('uint32_t', 'dlSymbols')])
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrDlSymbols() const [member function]
cls.add_method('GetNrDlSymbols',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetNrUlSymbols(uint32_t ulSymbols) [member function]
cls.add_method('SetNrUlSymbols',
'void',
[param('uint32_t', 'ulSymbols')])
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrUlSymbols() const [member function]
cls.add_method('GetNrUlSymbols',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrDcdSent() const [member function]
cls.add_method('GetNrDcdSent',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrUcdSent() const [member function]
cls.add_method('GetNrUcdSent',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetDlSubframeStartTime() const [member function]
cls.add_method('GetDlSubframeStartTime',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetUlSubframeStartTime() const [member function]
cls.add_method('GetUlSubframeStartTime',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetRangingOppNumber() const [member function]
cls.add_method('GetRangingOppNumber',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSManager> ns3::BaseStationNetDevice::GetSSManager() const [member function]
cls.add_method('GetSSManager',
'ns3::Ptr< ns3::SSManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetSSManager(ns3::Ptr<ns3::SSManager> ssManager) [member function]
cls.add_method('SetSSManager',
'void',
[param('ns3::Ptr< ns3::SSManager >', 'ssManager')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::UplinkScheduler> ns3::BaseStationNetDevice::GetUplinkScheduler() const [member function]
cls.add_method('GetUplinkScheduler',
'ns3::Ptr< ns3::UplinkScheduler >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetUplinkScheduler(ns3::Ptr<ns3::UplinkScheduler> ulScheduler) [member function]
cls.add_method('SetUplinkScheduler',
'void',
[param('ns3::Ptr< ns3::UplinkScheduler >', 'ulScheduler')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BSLinkManager> ns3::BaseStationNetDevice::GetLinkManager() const [member function]
cls.add_method('GetLinkManager',
'ns3::Ptr< ns3::BSLinkManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBSScheduler(ns3::Ptr<ns3::BSScheduler> bsSchedule) [member function]
cls.add_method('SetBSScheduler',
'void',
[param('ns3::Ptr< ns3::BSScheduler >', 'bsSchedule')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BSScheduler> ns3::BaseStationNetDevice::GetBSScheduler() const [member function]
cls.add_method('GetBSScheduler',
'ns3::Ptr< ns3::BSScheduler >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetLinkManager(ns3::Ptr<ns3::BSLinkManager> linkManager) [member function]
cls.add_method('SetLinkManager',
'void',
[param('ns3::Ptr< ns3::BSLinkManager >', 'linkManager')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::IpcsClassifier> ns3::BaseStationNetDevice::GetBsClassifier() const [member function]
cls.add_method('GetBsClassifier',
'ns3::Ptr< ns3::IpcsClassifier >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBsClassifier(ns3::Ptr<ns3::IpcsClassifier> classifier) [member function]
cls.add_method('SetBsClassifier',
'void',
[param('ns3::Ptr< ns3::IpcsClassifier >', 'classifier')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetPsDuration() const [member function]
cls.add_method('GetPsDuration',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetSymbolDuration() const [member function]
cls.add_method('GetSymbolDuration',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_virtual=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_virtual=True)
## bs-net-device.h (module 'wimax'): bool ns3::BaseStationNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_virtual=True)
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::BaseStationNetDevice::GetConnection(ns3::Cid cid) [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid', 'cid')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::MarkUplinkAllocations() [member function]
cls.add_method('MarkUplinkAllocations',
'void',
[])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::MarkRangingOppStart(ns3::Time rangingOppStartTime) [member function]
cls.add_method('MarkRangingOppStart',
'void',
[param('ns3::Time', 'rangingOppStartTime')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BsServiceFlowManager> ns3::BaseStationNetDevice::GetServiceFlowManager() const [member function]
cls.add_method('GetServiceFlowManager',
'ns3::Ptr< ns3::BsServiceFlowManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetServiceFlowManager(ns3::Ptr<ns3::BsServiceFlowManager> arg0) [member function]
cls.add_method('SetServiceFlowManager',
'void',
[param('ns3::Ptr< ns3::BsServiceFlowManager >', 'arg0')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## bs-net-device.h (module 'wimax'): bool ns3::BaseStationNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
visibility='private', is_virtual=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
visibility='private', is_virtual=True)
return
def register_Ns3SimpleOfdmWimaxChannel_methods(root_module, cls):
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel(ns3::SimpleOfdmWimaxChannel const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxChannel const &', 'arg0')])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel() [constructor]
cls.add_constructor([])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel(ns3::SimpleOfdmWimaxChannel::PropModel propModel) [constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propModel')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::Send(ns3::Time BlockTime, uint32_t burstSize, ns3::Ptr<ns3::WimaxPhy> phy, bool isFirstBlock, bool isLastBlock, uint64_t frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double txPowerDbm, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('Send',
'void',
[param('ns3::Time', 'BlockTime'), param('uint32_t', 'burstSize'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy'), param('bool', 'isFirstBlock'), param('bool', 'isLastBlock'), param('uint64_t', 'frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::SetPropagationModel(ns3::SimpleOfdmWimaxChannel::PropModel propModel) [member function]
cls.add_method('SetPropagationModel',
'void',
[param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propModel')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::DoAttach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::SimpleOfdmWimaxChannel::DoGetDevice(uint32_t i) const [member function]
cls.add_method('DoGetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-channel.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxChannel::DoGetNDevices() const [member function]
cls.add_method('DoGetNDevices',
'uint32_t',
[],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3SubscriberStationNetDevice_methods(root_module, cls):
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::m_linkManager [variable]
cls.add_instance_attribute('m_linkManager', 'ns3::Ptr< ns3::SSLinkManager >', is_const=False)
## ss-net-device.h (module 'wimax'): static ns3::TypeId ns3::SubscriberStationNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::SubscriberStationNetDevice() [constructor]
cls.add_constructor([])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::SubscriberStationNetDevice(ns3::Ptr<ns3::Node> arg0, ns3::Ptr<ns3::WimaxPhy> arg1) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'arg0'), param('ns3::Ptr< ns3::WimaxPhy >', 'arg1')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::InitSubscriberStationNetDevice() [member function]
cls.add_method('InitSubscriberStationNetDevice',
'void',
[])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLostDlMapInterval(ns3::Time lostDlMapInterval) [member function]
cls.add_method('SetLostDlMapInterval',
'void',
[param('ns3::Time', 'lostDlMapInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetLostDlMapInterval() const [member function]
cls.add_method('GetLostDlMapInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLostUlMapInterval(ns3::Time lostUlMapInterval) [member function]
cls.add_method('SetLostUlMapInterval',
'void',
[param('ns3::Time', 'lostUlMapInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetLostUlMapInterval() const [member function]
cls.add_method('GetLostUlMapInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxDcdInterval(ns3::Time maxDcdInterval) [member function]
cls.add_method('SetMaxDcdInterval',
'void',
[param('ns3::Time', 'maxDcdInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetMaxDcdInterval() const [member function]
cls.add_method('GetMaxDcdInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxUcdInterval(ns3::Time maxUcdInterval) [member function]
cls.add_method('SetMaxUcdInterval',
'void',
[param('ns3::Time', 'maxUcdInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetMaxUcdInterval() const [member function]
cls.add_method('GetMaxUcdInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT1(ns3::Time interval1) [member function]
cls.add_method('SetIntervalT1',
'void',
[param('ns3::Time', 'interval1')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT1() const [member function]
cls.add_method('GetIntervalT1',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT2(ns3::Time interval2) [member function]
cls.add_method('SetIntervalT2',
'void',
[param('ns3::Time', 'interval2')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT2() const [member function]
cls.add_method('GetIntervalT2',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT3(ns3::Time interval3) [member function]
cls.add_method('SetIntervalT3',
'void',
[param('ns3::Time', 'interval3')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT3() const [member function]
cls.add_method('GetIntervalT3',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT7(ns3::Time interval7) [member function]
cls.add_method('SetIntervalT7',
'void',
[param('ns3::Time', 'interval7')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT7() const [member function]
cls.add_method('GetIntervalT7',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT12(ns3::Time interval12) [member function]
cls.add_method('SetIntervalT12',
'void',
[param('ns3::Time', 'interval12')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT12() const [member function]
cls.add_method('GetIntervalT12',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT20(ns3::Time interval20) [member function]
cls.add_method('SetIntervalT20',
'void',
[param('ns3::Time', 'interval20')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT20() const [member function]
cls.add_method('GetIntervalT20',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT21(ns3::Time interval21) [member function]
cls.add_method('SetIntervalT21',
'void',
[param('ns3::Time', 'interval21')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT21() const [member function]
cls.add_method('GetIntervalT21',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxContentionRangingRetries(uint8_t maxContentionRangingRetries) [member function]
cls.add_method('SetMaxContentionRangingRetries',
'void',
[param('uint8_t', 'maxContentionRangingRetries')])
## ss-net-device.h (module 'wimax'): uint8_t ns3::SubscriberStationNetDevice::GetMaxContentionRangingRetries() const [member function]
cls.add_method('GetMaxContentionRangingRetries',
'uint8_t',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetBasicConnection(ns3::Ptr<ns3::WimaxConnection> basicConnection) [member function]
cls.add_method('SetBasicConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'basicConnection')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::SubscriberStationNetDevice::GetBasicConnection() const [member function]
cls.add_method('GetBasicConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetPrimaryConnection(ns3::Ptr<ns3::WimaxConnection> primaryConnection) [member function]
cls.add_method('SetPrimaryConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'primaryConnection')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::SubscriberStationNetDevice::GetPrimaryConnection() const [member function]
cls.add_method('GetPrimaryConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Cid ns3::SubscriberStationNetDevice::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Cid ns3::SubscriberStationNetDevice::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## ss-net-device.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::SubscriberStationNetDevice::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetAreManagementConnectionsAllocated(bool areManagementConnectionsAllocated) [member function]
cls.add_method('SetAreManagementConnectionsAllocated',
'void',
[param('bool', 'areManagementConnectionsAllocated')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::GetAreManagementConnectionsAllocated() const [member function]
cls.add_method('GetAreManagementConnectionsAllocated',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetAreServiceFlowsAllocated(bool areServiceFlowsAllocated) [member function]
cls.add_method('SetAreServiceFlowsAllocated',
'void',
[param('bool', 'areServiceFlowsAllocated')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::GetAreServiceFlowsAllocated() const [member function]
cls.add_method('GetAreServiceFlowsAllocated',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSScheduler> ns3::SubscriberStationNetDevice::GetScheduler() const [member function]
cls.add_method('GetScheduler',
'ns3::Ptr< ns3::SSScheduler >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetScheduler(ns3::Ptr<ns3::SSScheduler> ssScheduler) [member function]
cls.add_method('SetScheduler',
'void',
[param('ns3::Ptr< ns3::SSScheduler >', 'ssScheduler')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::HasServiceFlows() const [member function]
cls.add_method('HasServiceFlows',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SendBurst(uint8_t uiuc, uint16_t nrSymbols, ns3::Ptr<ns3::WimaxConnection> connection, ns3::MacHeaderType::HeaderType packetType=::ns3::MacHeaderType::HEADER_TYPE_GENERIC) [member function]
cls.add_method('SendBurst',
'void',
[param('uint8_t', 'uiuc'), param('uint16_t', 'nrSymbols'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('ns3::MacHeaderType::HeaderType', 'packetType', default_value='::ns3::MacHeaderType::HEADER_TYPE_GENERIC')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::AddServiceFlow(ns3::ServiceFlow * sf) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'sf')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::AddServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetTimer(ns3::EventId eventId, ns3::EventId & event) [member function]
cls.add_method('SetTimer',
'void',
[param('ns3::EventId', 'eventId'), param('ns3::EventId &', 'event')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::IsRegistered() const [member function]
cls.add_method('IsRegistered',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetTimeToAllocation(ns3::Time defferTime) [member function]
cls.add_method('GetTimeToAllocation',
'ns3::Time',
[param('ns3::Time', 'defferTime')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::IpcsClassifier> ns3::SubscriberStationNetDevice::GetIpcsClassifier() const [member function]
cls.add_method('GetIpcsClassifier',
'ns3::Ptr< ns3::IpcsClassifier >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIpcsPacketClassifier(ns3::Ptr<ns3::IpcsClassifier> arg0) [member function]
cls.add_method('SetIpcsPacketClassifier',
'void',
[param('ns3::Ptr< ns3::IpcsClassifier >', 'arg0')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSLinkManager> ns3::SubscriberStationNetDevice::GetLinkManager() const [member function]
cls.add_method('GetLinkManager',
'ns3::Ptr< ns3::SSLinkManager >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLinkManager(ns3::Ptr<ns3::SSLinkManager> arg0) [member function]
cls.add_method('SetLinkManager',
'void',
[param('ns3::Ptr< ns3::SSLinkManager >', 'arg0')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SsServiceFlowManager> ns3::SubscriberStationNetDevice::GetServiceFlowManager() const [member function]
cls.add_method('GetServiceFlowManager',
'ns3::Ptr< ns3::SsServiceFlowManager >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetServiceFlowManager(ns3::Ptr<ns3::SsServiceFlowManager> arg0) [member function]
cls.add_method('SetServiceFlowManager',
'void',
[param('ns3::Ptr< ns3::SsServiceFlowManager >', 'arg0')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
visibility='private', is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
visibility='private', is_virtual=True)
return
def register_functions(root_module):
module = root_module
## crc8.h (module 'wimax'): extern uint8_t ns3::CRC8Calculate(uint8_t const * data, int length) [free function]
module.add_function('CRC8Calculate',
'uint8_t',
[param('uint8_t const *', 'data'), param('int', 'length')])
register_functions_ns3_FatalImpl(module.get_submodule('FatalImpl'), root_module)
register_functions_ns3_internal(module.get_submodule('internal'), root_module)
return
def register_functions_ns3_FatalImpl(module, root_module):
return
def register_functions_ns3_internal(module, root_module):
return
def main():
out = FileCodeSink(sys.stdout)
root_module = module_init()
register_types(root_module)
register_methods(root_module)
register_functions(root_module)
root_module.generate(out)
if __name__ == '__main__':
main()
| zy901002-gpsr | src/wimax/bindings/modulegen__gcc_ILP32.py | Python | gpl2 | 734,604 |
from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
import pybindgen.settings
import warnings
class ErrorHandler(pybindgen.settings.ErrorHandler):
def handle_error(self, wrapper, exception, traceback_):
warnings.warn("exception %r in wrapper %s" % (exception, wrapper))
return True
pybindgen.settings.error_handler = ErrorHandler()
import sys
def module_init():
root_module = Module('ns.wimax', cpp_namespace='::ns3')
return root_module
def register_types(module):
root_module = module.get_root()
## ul-job.h (module 'wimax'): ns3::ReqType [enumeration]
module.add_enum('ReqType', ['DATA', 'UNICAST_POLLING'])
## 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'], import_from_module='ns.core')
## 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]
module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'], import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::AsciiTraceHelper [class]
module.add_class('AsciiTraceHelper', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice [class]
module.add_class('AsciiTraceHelperForDevice', allow_subclassing=True, import_from_module='ns.network')
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class]
module.add_class('AttributeConstructionList', import_from_module='ns.core')
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct]
module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList'])
## buffer.h (module 'network'): ns3::Buffer [class]
module.add_class('Buffer', import_from_module='ns.network')
## buffer.h (module 'network'): ns3::Buffer::Iterator [class]
module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::Buffer'])
## packet.h (module 'network'): ns3::ByteTagIterator [class]
module.add_class('ByteTagIterator', import_from_module='ns.network')
## packet.h (module 'network'): ns3::ByteTagIterator::Item [class]
module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagIterator'])
## byte-tag-list.h (module 'network'): ns3::ByteTagList [class]
module.add_class('ByteTagList', import_from_module='ns.network')
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator [class]
module.add_class('Iterator', import_from_module='ns.network', outer_class=root_module['ns3::ByteTagList'])
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item [struct]
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')
## cid.h (module 'wimax'): ns3::Cid [class]
module.add_class('Cid')
## cid.h (module 'wimax'): ns3::Cid::Type [enumeration]
module.add_enum('Type', ['BROADCAST', 'INITIAL_RANGING', 'BASIC', 'PRIMARY', 'TRANSPORT', 'MULTICAST', 'PADDING'], outer_class=root_module['ns3::Cid'])
## cid-factory.h (module 'wimax'): ns3::CidFactory [class]
module.add_class('CidFactory')
## cs-parameters.h (module 'wimax'): ns3::CsParameters [class]
module.add_class('CsParameters')
## cs-parameters.h (module 'wimax'): ns3::CsParameters::Action [enumeration]
module.add_enum('Action', ['ADD', 'REPLACE', 'DELETE'], outer_class=root_module['ns3::CsParameters'])
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings [class]
module.add_class('DcdChannelEncodings', allow_subclassing=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe [class]
module.add_class('DlFramePrefixIe')
## event-id.h (module 'core'): ns3::EventId [class]
module.add_class('EventId', import_from_module='ns.core')
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord [class]
module.add_class('IpcsClassifierRecord')
## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
module.add_class('Ipv4Address', import_from_module='ns.network')
## ipv4-address.h (module 'network'): ns3::Ipv4Address [class]
root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask [class]
module.add_class('Ipv4Mask', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
module.add_class('Ipv6Address', import_from_module='ns.network')
## ipv6-address.h (module 'network'): ns3::Ipv6Address [class]
root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix [class]
module.add_class('Ipv6Prefix', import_from_module='ns.network')
## log.h (module 'core'): ns3::LogComponent [class]
module.add_class('LogComponent', import_from_module='ns.core')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
module.add_class('Mac48Address', import_from_module='ns.network')
## mac48-address.h (module 'network'): ns3::Mac48Address [class]
root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer [class]
module.add_class('NetDeviceContainer', import_from_module='ns.network')
## node-container.h (module 'network'): ns3::NodeContainer [class]
module.add_class('NodeContainer', import_from_module='ns.network')
## object-base.h (module 'core'): ns3::ObjectBase [class]
module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')
## object.h (module 'core'): ns3::ObjectDeleter [struct]
module.add_class('ObjectDeleter', import_from_module='ns.core')
## object-factory.h (module 'core'): ns3::ObjectFactory [class]
module.add_class('ObjectFactory', import_from_module='ns.core')
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings [class]
module.add_class('OfdmDcdChannelEncodings', parent=root_module['ns3::DcdChannelEncodings'])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile [class]
module.add_class('OfdmDlBurstProfile')
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::Diuc [enumeration]
module.add_enum('Diuc', ['DIUC_STC_ZONE', 'DIUC_BURST_PROFILE_1', 'DIUC_BURST_PROFILE_2', 'DIUC_BURST_PROFILE_3', 'DIUC_BURST_PROFILE_4', 'DIUC_BURST_PROFILE_5', 'DIUC_BURST_PROFILE_6', 'DIUC_BURST_PROFILE_7', 'DIUC_BURST_PROFILE_8', 'DIUC_BURST_PROFILE_9', 'DIUC_BURST_PROFILE_10', 'DIUC_BURST_PROFILE_11', 'DIUC_GAP', 'DIUC_END_OF_MAP'], outer_class=root_module['ns3::OfdmDlBurstProfile'])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe [class]
module.add_class('OfdmDlMapIe')
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile [class]
module.add_class('OfdmUlBurstProfile')
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::Uiuc [enumeration]
module.add_enum('Uiuc', ['UIUC_INITIAL_RANGING', 'UIUC_REQ_REGION_FULL', 'UIUC_REQ_REGION_FOCUSED', 'UIUC_FOCUSED_CONTENTION_IE', 'UIUC_BURST_PROFILE_5', 'UIUC_BURST_PROFILE_6', 'UIUC_BURST_PROFILE_7', 'UIUC_BURST_PROFILE_8', 'UIUC_BURST_PROFILE_9', 'UIUC_BURST_PROFILE_10', 'UIUC_BURST_PROFILE_11', 'UIUC_BURST_PROFILE_12', 'UIUC_SUBCH_NETWORK_ENTRY', 'UIUC_END_OF_MAP'], outer_class=root_module['ns3::OfdmUlBurstProfile'])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe [class]
module.add_class('OfdmUlMapIe')
## packet-metadata.h (module 'network'): ns3::PacketMetadata [class]
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::ItemIterator [class]
module.add_class('ItemIterator', import_from_module='ns.network', outer_class=root_module['ns3::PacketMetadata'])
## packet.h (module 'network'): ns3::PacketTagIterator [class]
module.add_class('PacketTagIterator', import_from_module='ns.network')
## packet.h (module 'network'): ns3::PacketTagIterator::Item [class]
module.add_class('Item', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagIterator'])
## packet-tag-list.h (module 'network'): ns3::PacketTagList [class]
module.add_class('PacketTagList', import_from_module='ns.network')
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData [struct]
module.add_class('TagData', import_from_module='ns.network', outer_class=root_module['ns3::PacketTagList'])
## pcap-file.h (module 'network'): ns3::PcapFile [class]
module.add_class('PcapFile', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelper [class]
module.add_class('PcapHelper', import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelper [enumeration]
module.add_enum('', ['DLT_NULL', 'DLT_EN10MB', 'DLT_PPP', 'DLT_RAW', 'DLT_IEEE802_11', 'DLT_PRISM_HEADER', 'DLT_IEEE802_11_RADIO'], outer_class=root_module['ns3::PcapHelper'], import_from_module='ns.network')
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice [class]
module.add_class('PcapHelperForDevice', allow_subclassing=True, import_from_module='ns.network')
## random-variable.h (module 'core'): ns3::RandomVariable [class]
module.add_class('RandomVariable', import_from_module='ns.core')
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager [class]
module.add_class('SNRToBlockErrorRateManager')
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord [class]
module.add_class('SNRToBlockErrorRateRecord')
## ss-record.h (module 'wimax'): ns3::SSRecord [class]
module.add_class('SSRecord')
## random-variable.h (module 'core'): ns3::SeedManager [class]
module.add_class('SeedManager', import_from_module='ns.core')
## send-params.h (module 'wimax'): ns3::SendParams [class]
module.add_class('SendParams')
## random-variable.h (module 'core'): ns3::SequentialVariable [class]
module.add_class('SequentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow [class]
module.add_class('ServiceFlow')
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Direction [enumeration]
module.add_enum('Direction', ['SF_DIRECTION_DOWN', 'SF_DIRECTION_UP'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Type [enumeration]
module.add_enum('Type', ['SF_TYPE_PROVISIONED', 'SF_TYPE_ADMITTED', 'SF_TYPE_ACTIVE'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType [enumeration]
module.add_enum('SchedulingType', ['SF_TYPE_NONE', 'SF_TYPE_UNDEF', 'SF_TYPE_BE', 'SF_TYPE_NRTPS', 'SF_TYPE_RTPS', 'SF_TYPE_UGS', 'SF_TYPE_ALL'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::CsSpecification [enumeration]
module.add_enum('CsSpecification', ['ATM', 'IPV4', 'IPV6', 'ETHERNET', 'VLAN', 'IPV4_OVER_ETHERNET', 'IPV6_OVER_ETHERNET', 'IPV4_OVER_VLAN', 'IPV6_OVER_VLAN'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ModulationType [enumeration]
module.add_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'], outer_class=root_module['ns3::ServiceFlow'])
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord [class]
module.add_class('ServiceFlowRecord')
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
## simulator.h (module 'core'): ns3::Simulator [class]
module.add_class('Simulator', destructor_visibility='private', import_from_module='ns.core')
## tag.h (module 'network'): ns3::Tag [class]
module.add_class('Tag', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## tag-buffer.h (module 'network'): ns3::TagBuffer [class]
module.add_class('TagBuffer', import_from_module='ns.network')
## wimax-tlv.h (module 'wimax'): ns3::TlvValue [class]
module.add_class('TlvValue', allow_subclassing=True)
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue [class]
module.add_class('TosTlvValue', parent=root_module['ns3::TlvValue'])
## random-variable.h (module 'core'): ns3::TriangularVariable [class]
module.add_class('TriangularVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## type-id.h (module 'core'): ns3::TypeId [class]
module.add_class('TypeId', import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]
module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core')
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation [struct]
module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct]
module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue [class]
module.add_class('U16TlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue [class]
module.add_class('U32TlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue [class]
module.add_class('U8TlvValue', parent=root_module['ns3::TlvValue'])
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings [class]
module.add_class('UcdChannelEncodings', allow_subclassing=True)
## random-variable.h (module 'core'): ns3::UniformVariable [class]
module.add_class('UniformVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue [class]
module.add_class('VectorTlvValue', parent=root_module['ns3::TlvValue'])
## random-variable.h (module 'core'): ns3::WeibullVariable [class]
module.add_class('WeibullVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper [class]
module.add_class('WimaxHelper', parent=[root_module['ns3::PcapHelperForDevice'], root_module['ns3::AsciiTraceHelperForDevice']])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::NetDeviceType [enumeration]
module.add_enum('NetDeviceType', ['DEVICE_TYPE_SUBSCRIBER_STATION', 'DEVICE_TYPE_BASE_STATION'], outer_class=root_module['ns3::WimaxHelper'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::PhyType [enumeration]
module.add_enum('PhyType', ['SIMPLE_PHY_TYPE_OFDM'], outer_class=root_module['ns3::WimaxHelper'])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::SchedulerType [enumeration]
module.add_enum('SchedulerType', ['SCHED_TYPE_SIMPLE', 'SCHED_TYPE_RTPS', 'SCHED_TYPE_MBQOS'], outer_class=root_module['ns3::WimaxHelper'])
## random-variable.h (module 'core'): ns3::ZetaVariable [class]
module.add_class('ZetaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ZipfVariable [class]
module.add_class('ZipfVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## 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]
module.add_class('int64x64_t', import_from_module='ns.core')
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam [class]
module.add_class('simpleOfdmSendParam')
## chunk.h (module 'network'): ns3::Chunk [class]
module.add_class('Chunk', import_from_module='ns.network', parent=root_module['ns3::ObjectBase'])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue [class]
module.add_class('ClassificationRuleVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleTlvType [enumeration]
module.add_enum('ClassificationRuleTlvType', ['Priority', 'ToS', 'Protocol', 'IP_src', 'IP_dst', 'Port_src', 'Port_dst', 'Index'], outer_class=root_module['ns3::ClassificationRuleVectorTlvValue'])
## random-variable.h (module 'core'): ns3::ConstantVariable [class]
module.add_class('ConstantVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue [class]
module.add_class('CsParamVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::Type [enumeration]
module.add_enum('Type', ['Classifier_DSC_Action', 'Packet_Classification_Rule'], outer_class=root_module['ns3::CsParamVectorTlvValue'])
## random-variable.h (module 'core'): ns3::DeterministicVariable [class]
module.add_class('DeterministicVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::EmpiricalVariable [class]
module.add_class('EmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ErlangVariable [class]
module.add_class('ErlangVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::ExponentialVariable [class]
module.add_class('ExponentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## random-variable.h (module 'core'): ns3::GammaVariable [class]
module.add_class('GammaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## header.h (module 'network'): ns3::Header [class]
module.add_class('Header', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable [class]
module.add_class('IntEmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::EmpiricalVariable'])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue [class]
module.add_class('Ipv4AddressTlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr [struct]
module.add_class('ipv4Addr', outer_class=root_module['ns3::Ipv4AddressTlvValue'])
## random-variable.h (module 'core'): ns3::LogNormalVariable [class]
module.add_class('LogNormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType [class]
module.add_class('MacHeaderType', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::HeaderType [enumeration]
module.add_enum('HeaderType', ['HEADER_TYPE_GENERIC', 'HEADER_TYPE_BANDWIDTH'], outer_class=root_module['ns3::MacHeaderType'])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType [class]
module.add_class('ManagementMessageType', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::MessageType [enumeration]
module.add_enum('MessageType', ['MESSAGE_TYPE_UCD', 'MESSAGE_TYPE_DCD', 'MESSAGE_TYPE_DL_MAP', 'MESSAGE_TYPE_UL_MAP', 'MESSAGE_TYPE_RNG_REQ', 'MESSAGE_TYPE_RNG_RSP', 'MESSAGE_TYPE_REG_REQ', 'MESSAGE_TYPE_REG_RSP', 'MESSAGE_TYPE_DSA_REQ', 'MESSAGE_TYPE_DSA_RSP', 'MESSAGE_TYPE_DSA_ACK'], outer_class=root_module['ns3::ManagementMessageType'])
## random-variable.h (module 'core'): ns3::NormalVariable [class]
module.add_class('NormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## object.h (module 'core'): ns3::Object [class]
module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
## object.h (module 'core'): ns3::Object::AggregateIterator [class]
module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix [class]
module.add_class('OfdmDownlinkFramePrefix', parent=root_module['ns3::Header'])
## send-params.h (module 'wimax'): ns3::OfdmSendParams [class]
module.add_class('OfdmSendParams', parent=root_module['ns3::SendParams'])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings [class]
module.add_class('OfdmUcdChannelEncodings', parent=root_module['ns3::UcdChannelEncodings'])
## packet-burst.h (module 'network'): ns3::PacketBurst [class]
module.add_class('PacketBurst', import_from_module='ns.network', parent=root_module['ns3::Object'])
## random-variable.h (module 'core'): ns3::ParetoVariable [class]
module.add_class('ParetoVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])
## pcap-file-wrapper.h (module 'network'): ns3::PcapFileWrapper [class]
module.add_class('PcapFileWrapper', import_from_module='ns.network', parent=root_module['ns3::Object'])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue [class]
module.add_class('PortRangeTlvValue', parent=root_module['ns3::TlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange [struct]
module.add_class('PortRange', outer_class=root_module['ns3::PortRangeTlvValue'])
## ul-job.h (module 'wimax'): ns3::PriorityUlJob [class]
module.add_class('PriorityUlJob', parent=root_module['ns3::Object'])
## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel [class]
module.add_class('PropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::Object'])
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue [class]
module.add_class('ProtocolTlvValue', parent=root_module['ns3::TlvValue'])
## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel [class]
module.add_class('RandomPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel [class]
module.add_class('RangePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## mac-messages.h (module 'wimax'): ns3::RngReq [class]
module.add_class('RngReq', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::RngRsp [class]
module.add_class('RngRsp', parent=root_module['ns3::Header'])
## ss-manager.h (module 'wimax'): ns3::SSManager [class]
module.add_class('SSManager', parent=root_module['ns3::Object'])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager [class]
module.add_class('ServiceFlowManager', parent=root_module['ns3::Object'])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::ServiceFlowManager'])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue [class]
module.add_class('SfVectorTlvValue', parent=root_module['ns3::VectorTlvValue'])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::Type [enumeration]
module.add_enum('Type', ['SFID', 'CID', 'Service_Class_Name', 'reserved1', 'QoS_Parameter_Set_Type', 'Traffic_Priority', 'Maximum_Sustained_Traffic_Rate', 'Maximum_Traffic_Burst', 'Minimum_Reserved_Traffic_Rate', 'Minimum_Tolerable_Traffic_Rate', 'Service_Flow_Scheduling_Type', 'Request_Transmission_Policy', 'Tolerated_Jitter', 'Maximum_Latency', 'Fixed_length_versus_Variable_length_SDU_Indicator', 'SDU_Size', 'Target_SAID', 'ARQ_Enable', 'ARQ_WINDOW_SIZE', 'ARQ_RETRY_TIMEOUT_Transmitter_Delay', 'ARQ_RETRY_TIMEOUT_Receiver_Delay', 'ARQ_BLOCK_LIFETIME', 'ARQ_SYNC_LOSS', 'ARQ_DELIVER_IN_ORDER', 'ARQ_PURGE_TIMEOUT', 'ARQ_BLOCK_SIZE', 'reserved2', 'CS_Specification', 'IPV4_CS_Parameters'], outer_class=root_module['ns3::SfVectorTlvValue'])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeAccessor>'], 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<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeChecker', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeChecker>'], 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<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::AttributeValue', 'ns3::empty', 'ns3::DefaultDeleter<ns3::AttributeValue>'], 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<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::CallbackImplBase', 'ns3::empty', 'ns3::DefaultDeleter<ns3::CallbackImplBase>'], 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<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::EventImpl', 'ns3::empty', 'ns3::DefaultDeleter<ns3::EventImpl>'], 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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::NixVector', 'ns3::empty', 'ns3::DefaultDeleter<ns3::NixVector>'], 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<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::OutputStreamWrapper', 'ns3::empty', 'ns3::DefaultDeleter<ns3::OutputStreamWrapper>'], 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<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Packet', 'ns3::empty', 'ns3::DefaultDeleter<ns3::Packet>'], 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<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > [class]
module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::TraceSourceAccessor', 'ns3::empty', 'ns3::DefaultDeleter<ns3::TraceSourceAccessor>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager [class]
module.add_class('SsServiceFlowManager', parent=root_module['ns3::ServiceFlowManager'])
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::SsServiceFlowManager'])
## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel [class]
module.add_class('ThreeLogDistancePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## nstime.h (module 'core'): ns3::Time [class]
module.add_class('Time', import_from_module='ns.core')
## nstime.h (module 'core'): ns3::Time::Unit [enumeration]
module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')
## nstime.h (module 'core'): ns3::Time [class]
root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t'])
## wimax-tlv.h (module 'wimax'): ns3::Tlv [class]
module.add_class('Tlv', parent=root_module['ns3::Header'])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::CommonTypes [enumeration]
module.add_enum('CommonTypes', ['HMAC_TUPLE', 'MAC_VERSION_ENCODING', 'CURRENT_TRANSMIT_POWER', 'DOWNLINK_SERVICE_FLOW', 'UPLINK_SERVICE_FLOW', 'VENDOR_ID_EMCODING', 'VENDOR_SPECIFIC_INFORMATION'], outer_class=root_module['ns3::Tlv'])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]
module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
## trailer.h (module 'network'): ns3::Trailer [class]
module.add_class('Trailer', import_from_module='ns.network', parent=root_module['ns3::Chunk'])
## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel [class]
module.add_class('TwoRayGroundPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## ul-mac-messages.h (module 'wimax'): ns3::Ucd [class]
module.add_class('Ucd', parent=root_module['ns3::Header'])
## ul-job.h (module 'wimax'): ns3::UlJob [class]
module.add_class('UlJob', parent=root_module['ns3::Object'])
## ul-job.h (module 'wimax'): ns3::UlJob::JobPriority [enumeration]
module.add_enum('JobPriority', ['LOW', 'INTERMEDIATE', 'HIGH'], outer_class=root_module['ns3::UlJob'])
## ul-mac-messages.h (module 'wimax'): ns3::UlMap [class]
module.add_class('UlMap', parent=root_module['ns3::Header'])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler [class]
module.add_class('UplinkScheduler', parent=root_module['ns3::Object'])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS [class]
module.add_class('UplinkSchedulerMBQoS', parent=root_module['ns3::UplinkScheduler'])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps [class]
module.add_class('UplinkSchedulerRtps', parent=root_module['ns3::UplinkScheduler'])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple [class]
module.add_class('UplinkSchedulerSimple', parent=root_module['ns3::UplinkScheduler'])
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection [class]
module.add_class('WimaxConnection', parent=root_module['ns3::Object'])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue [class]
module.add_class('WimaxMacQueue', parent=root_module['ns3::Object'])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader [class]
module.add_class('WimaxMacToMacHeader', parent=root_module['ns3::Header'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy [class]
module.add_class('WimaxPhy', parent=root_module['ns3::Object'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::ModulationType [enumeration]
module.add_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'], outer_class=root_module['ns3::WimaxPhy'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyState [enumeration]
module.add_enum('PhyState', ['PHY_STATE_IDLE', 'PHY_STATE_SCANNING', 'PHY_STATE_TX', 'PHY_STATE_RX'], outer_class=root_module['ns3::WimaxPhy'])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType [enumeration]
module.add_enum('PhyType', ['SimpleWimaxPhy', 'simpleOfdmWimaxPhy'], outer_class=root_module['ns3::WimaxPhy'])
## attribute.h (module 'core'): ns3::AttributeAccessor [class]
module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
## attribute.h (module 'core'): ns3::AttributeChecker [class]
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<ns3::AttributeChecker> >'])
## 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<ns3::AttributeValue> >'])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler [class]
module.add_class('BSScheduler', parent=root_module['ns3::Object'])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps [class]
module.add_class('BSSchedulerRtps', parent=root_module['ns3::BSScheduler'])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple [class]
module.add_class('BSSchedulerSimple', parent=root_module['ns3::BSScheduler'])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader [class]
module.add_class('BandwidthRequestHeader', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::HeaderType [enumeration]
module.add_enum('HeaderType', ['HEADER_TYPE_INCREMENTAL', 'HEADER_TYPE_AGGREGATE'], outer_class=root_module['ns3::BandwidthRequestHeader'])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager [class]
module.add_class('BsServiceFlowManager', parent=root_module['ns3::ServiceFlowManager'])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::ConfirmationCode [enumeration]
module.add_enum('ConfirmationCode', ['CONFIRMATION_CODE_SUCCESS', 'CONFIRMATION_CODE_REJECT'], outer_class=root_module['ns3::BsServiceFlowManager'])
## callback.h (module 'core'): ns3::CallbackChecker [class]
module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## callback.h (module 'core'): ns3::CallbackImplBase [class]
module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
## callback.h (module 'core'): ns3::CallbackValue [class]
module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## channel.h (module 'network'): ns3::Channel [class]
module.add_class('Channel', import_from_module='ns.network', parent=root_module['ns3::Object'])
## connection-manager.h (module 'wimax'): ns3::ConnectionManager [class]
module.add_class('ConnectionManager', parent=root_module['ns3::Object'])
## dl-mac-messages.h (module 'wimax'): ns3::Dcd [class]
module.add_class('Dcd', parent=root_module['ns3::Header'])
## dl-mac-messages.h (module 'wimax'): ns3::DlMap [class]
module.add_class('DlMap', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaAck [class]
module.add_class('DsaAck', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaReq [class]
module.add_class('DsaReq', parent=root_module['ns3::Header'])
## mac-messages.h (module 'wimax'): ns3::DsaRsp [class]
module.add_class('DsaRsp', parent=root_module['ns3::Header'])
## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]
module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## event-impl.h (module 'core'): ns3::EventImpl [class]
module.add_class('EventImpl', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel [class]
module.add_class('FixedRssLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader [class]
module.add_class('FragmentationSubheader', parent=root_module['ns3::Header'])
## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel [class]
module.add_class('FriisPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader [class]
module.add_class('GenericMacHeader', parent=root_module['ns3::Header'])
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader [class]
module.add_class('GrantManagementSubheader', parent=root_module['ns3::Header'])
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier [class]
module.add_class('IpcsClassifier', parent=root_module['ns3::Object'])
## ipv4-address.h (module 'network'): ns3::Ipv4AddressChecker [class]
module.add_class('Ipv4AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv4-address.h (module 'network'): ns3::Ipv4AddressValue [class]
module.add_class('Ipv4AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv4-address.h (module 'network'): ns3::Ipv4MaskChecker [class]
module.add_class('Ipv4MaskChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv4-address.h (module 'network'): ns3::Ipv4MaskValue [class]
module.add_class('Ipv4MaskValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressChecker [class]
module.add_class('Ipv6AddressChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6AddressValue [class]
module.add_class('Ipv6AddressValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixChecker [class]
module.add_class('Ipv6PrefixChecker', import_from_module='ns.network', parent=root_module['ns3::AttributeChecker'])
## ipv6-address.h (module 'network'): ns3::Ipv6PrefixValue [class]
module.add_class('Ipv6PrefixValue', import_from_module='ns.network', parent=root_module['ns3::AttributeValue'])
## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel [class]
module.add_class('LogDistancePropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## mac48-address.h (module 'network'): ns3::Mac48AddressChecker [class]
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'])
## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class]
module.add_class('MatrixPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel [class]
module.add_class('NakagamiPropagationLossModel', import_from_module='ns.propagation', parent=root_module['ns3::PropagationLossModel'])
## 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]
module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'], import_from_module='ns.network')
## nix-vector.h (module 'network'): ns3::NixVector [class]
module.add_class('NixVector', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
## node.h (module 'network'): ns3::Node [class]
module.add_class('Node', import_from_module='ns.network', parent=root_module['ns3::Object'])
## object-factory.h (module 'core'): ns3::ObjectFactoryChecker [class]
module.add_class('ObjectFactoryChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## object-factory.h (module 'core'): ns3::ObjectFactoryValue [class]
module.add_class('ObjectFactoryValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper [class]
module.add_class('OutputStreamWrapper', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
## packet.h (module 'network'): ns3::Packet [class]
module.add_class('Packet', import_from_module='ns.network', parent=root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
## random-variable.h (module 'core'): ns3::RandomVariableChecker [class]
module.add_class('RandomVariableChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## random-variable.h (module 'core'): ns3::RandomVariableValue [class]
module.add_class('RandomVariableValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy [class]
module.add_class('SimpleOfdmWimaxPhy', parent=root_module['ns3::WimaxPhy'])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::FrameDurationCode [enumeration]
module.add_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'], outer_class=root_module['ns3::SimpleOfdmWimaxPhy'])
## nstime.h (module 'core'): ns3::TimeChecker [class]
module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## nstime.h (module 'core'): ns3::TimeValue [class]
module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## type-id.h (module 'core'): ns3::TypeIdChecker [class]
module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])
## type-id.h (module 'core'): ns3::TypeIdValue [class]
module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## uinteger.h (module 'core'): ns3::UintegerValue [class]
module.add_class('UintegerValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel [class]
module.add_class('WimaxChannel', parent=root_module['ns3::Channel'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice [class]
module.add_class('WimaxNetDevice', parent=root_module['ns3::NetDevice'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::Direction [enumeration]
module.add_enum('Direction', ['DIRECTION_DOWNLINK', 'DIRECTION_UPLINK'], outer_class=root_module['ns3::WimaxNetDevice'])
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::RangingStatus [enumeration]
module.add_enum('RangingStatus', ['RANGING_STATUS_EXPIRED', 'RANGING_STATUS_CONTINUE', 'RANGING_STATUS_ABORT', 'RANGING_STATUS_SUCCESS'], outer_class=root_module['ns3::WimaxNetDevice'])
## address.h (module 'network'): ns3::AddressChecker [class]
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'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice [class]
module.add_class('BaseStationNetDevice', parent=root_module['ns3::WimaxNetDevice'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::State [enumeration]
module.add_enum('State', ['BS_STATE_DL_SUB_FRAME', 'BS_STATE_UL_SUB_FRAME', 'BS_STATE_TTG', 'BS_STATE_RTG'], outer_class=root_module['ns3::BaseStationNetDevice'])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::MacPreamble [enumeration]
module.add_enum('MacPreamble', ['SHORT_PREAMBLE', 'LONG_PREAMBLE'], outer_class=root_module['ns3::BaseStationNetDevice'])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel [class]
module.add_class('SimpleOfdmWimaxChannel', parent=root_module['ns3::WimaxChannel'])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::PropModel [enumeration]
module.add_enum('PropModel', ['RANDOM_PROPAGATION', 'FRIIS_PROPAGATION', 'LOG_DISTANCE_PROPAGATION', 'COST231_PROPAGATION'], outer_class=root_module['ns3::SimpleOfdmWimaxChannel'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice [class]
module.add_class('SubscriberStationNetDevice', parent=root_module['ns3::WimaxNetDevice'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::State [enumeration]
module.add_enum('State', ['SS_STATE_IDLE', 'SS_STATE_SCANNING', 'SS_STATE_SYNCHRONIZING', 'SS_STATE_ACQUIRING_PARAMETERS', 'SS_STATE_WAITING_REG_RANG_INTRVL', 'SS_STATE_WAITING_INV_RANG_INTRVL', 'SS_STATE_WAITING_RNG_RSP', 'SS_STATE_ADJUSTING_PARAMETERS', 'SS_STATE_REGISTERED', 'SS_STATE_TRANSMITTING', 'SS_STATE_STOPPED'], outer_class=root_module['ns3::SubscriberStationNetDevice'])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::EventType [enumeration]
module.add_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'], outer_class=root_module['ns3::SubscriberStationNetDevice'])
module.add_container('std::vector< ns3::ServiceFlow * >', 'ns3::ServiceFlow *', container_type='vector')
module.add_container('std::vector< bool >', 'bool', container_type='vector')
module.add_container('ns3::bvec', 'bool', container_type='vector')
module.add_container('std::vector< ns3::DlFramePrefixIe >', 'ns3::DlFramePrefixIe', container_type='vector')
module.add_container('std::list< ns3::Ptr< ns3::Packet > >', 'ns3::Ptr< ns3::Packet >', container_type='list')
module.add_container('std::vector< ns3::SSRecord * >', 'ns3::SSRecord *', container_type='vector')
module.add_container('std::vector< ns3::OfdmUlBurstProfile >', 'ns3::OfdmUlBurstProfile', container_type='vector')
module.add_container('std::list< ns3::OfdmUlMapIe >', 'ns3::OfdmUlMapIe', container_type='list')
module.add_container('std::list< ns3::Ptr< ns3::UlJob > >', 'ns3::Ptr< ns3::UlJob >', container_type='list')
module.add_container('std::list< ns3::Ptr< ns3::Packet const > >', 'ns3::Ptr< ns3::Packet const >', container_type='list')
module.add_container('std::deque< ns3::WimaxMacQueue::QueueElement >', 'ns3::WimaxMacQueue::QueueElement', container_type='dequeue')
module.add_container('std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > >', 'std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > >', container_type='list')
module.add_container('std::vector< ns3::Ptr< ns3::WimaxConnection > >', 'ns3::Ptr< ns3::WimaxConnection >', container_type='vector')
module.add_container('std::vector< ns3::OfdmDlBurstProfile >', 'ns3::OfdmDlBurstProfile', container_type='vector')
module.add_container('std::list< ns3::OfdmDlMapIe >', 'ns3::OfdmDlMapIe', container_type='list')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogNodePrinter')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogNodePrinter*')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogNodePrinter&')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *', 'ns3::LogTimePrinter')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) **', 'ns3::LogTimePrinter*')
typehandlers.add_type_alias('void ( * ) ( std::ostream & ) *&', 'ns3::LogTimePrinter&')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >', 'ns3::bvec')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >*', 'ns3::bvec*')
typehandlers.add_type_alias('std::vector< bool, std::allocator< bool > >&', 'ns3::bvec&')
## Register a nested module for the namespace FatalImpl
nested_module = module.add_cpp_namespace('FatalImpl')
register_types_ns3_FatalImpl(nested_module)
## Register a nested module for the namespace internal
nested_module = module.add_cpp_namespace('internal')
register_types_ns3_internal(nested_module)
def register_types_ns3_FatalImpl(module):
root_module = module.get_root()
def register_types_ns3_internal(module):
root_module = module.get_root()
def register_methods(root_module):
register_Ns3Address_methods(root_module, root_module['ns3::Address'])
register_Ns3AsciiTraceHelper_methods(root_module, root_module['ns3::AsciiTraceHelper'])
register_Ns3AsciiTraceHelperForDevice_methods(root_module, root_module['ns3::AsciiTraceHelperForDevice'])
register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])
register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])
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'])
register_Ns3ByteTagIteratorItem_methods(root_module, root_module['ns3::ByteTagIterator::Item'])
register_Ns3ByteTagList_methods(root_module, root_module['ns3::ByteTagList'])
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_Ns3Cid_methods(root_module, root_module['ns3::Cid'])
register_Ns3CidFactory_methods(root_module, root_module['ns3::CidFactory'])
register_Ns3CsParameters_methods(root_module, root_module['ns3::CsParameters'])
register_Ns3DcdChannelEncodings_methods(root_module, root_module['ns3::DcdChannelEncodings'])
register_Ns3DlFramePrefixIe_methods(root_module, root_module['ns3::DlFramePrefixIe'])
register_Ns3EventId_methods(root_module, root_module['ns3::EventId'])
register_Ns3IpcsClassifierRecord_methods(root_module, root_module['ns3::IpcsClassifierRecord'])
register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])
register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])
register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])
register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])
register_Ns3LogComponent_methods(root_module, root_module['ns3::LogComponent'])
register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])
register_Ns3NetDeviceContainer_methods(root_module, root_module['ns3::NetDeviceContainer'])
register_Ns3NodeContainer_methods(root_module, root_module['ns3::NodeContainer'])
register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])
register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])
register_Ns3ObjectFactory_methods(root_module, root_module['ns3::ObjectFactory'])
register_Ns3OfdmDcdChannelEncodings_methods(root_module, root_module['ns3::OfdmDcdChannelEncodings'])
register_Ns3OfdmDlBurstProfile_methods(root_module, root_module['ns3::OfdmDlBurstProfile'])
register_Ns3OfdmDlMapIe_methods(root_module, root_module['ns3::OfdmDlMapIe'])
register_Ns3OfdmUlBurstProfile_methods(root_module, root_module['ns3::OfdmUlBurstProfile'])
register_Ns3OfdmUlMapIe_methods(root_module, root_module['ns3::OfdmUlMapIe'])
register_Ns3PacketMetadata_methods(root_module, root_module['ns3::PacketMetadata'])
register_Ns3PacketMetadataItem_methods(root_module, root_module['ns3::PacketMetadata::Item'])
register_Ns3PacketMetadataItemIterator_methods(root_module, root_module['ns3::PacketMetadata::ItemIterator'])
register_Ns3PacketTagIterator_methods(root_module, root_module['ns3::PacketTagIterator'])
register_Ns3PacketTagIteratorItem_methods(root_module, root_module['ns3::PacketTagIterator::Item'])
register_Ns3PacketTagList_methods(root_module, root_module['ns3::PacketTagList'])
register_Ns3PacketTagListTagData_methods(root_module, root_module['ns3::PacketTagList::TagData'])
register_Ns3PcapFile_methods(root_module, root_module['ns3::PcapFile'])
register_Ns3PcapHelper_methods(root_module, root_module['ns3::PcapHelper'])
register_Ns3PcapHelperForDevice_methods(root_module, root_module['ns3::PcapHelperForDevice'])
register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])
register_Ns3SNRToBlockErrorRateManager_methods(root_module, root_module['ns3::SNRToBlockErrorRateManager'])
register_Ns3SNRToBlockErrorRateRecord_methods(root_module, root_module['ns3::SNRToBlockErrorRateRecord'])
register_Ns3SSRecord_methods(root_module, root_module['ns3::SSRecord'])
register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])
register_Ns3SendParams_methods(root_module, root_module['ns3::SendParams'])
register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])
register_Ns3ServiceFlow_methods(root_module, root_module['ns3::ServiceFlow'])
register_Ns3ServiceFlowRecord_methods(root_module, root_module['ns3::ServiceFlowRecord'])
register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])
register_Ns3Simulator_methods(root_module, root_module['ns3::Simulator'])
register_Ns3Tag_methods(root_module, root_module['ns3::Tag'])
register_Ns3TagBuffer_methods(root_module, root_module['ns3::TagBuffer'])
register_Ns3TlvValue_methods(root_module, root_module['ns3::TlvValue'])
register_Ns3TosTlvValue_methods(root_module, root_module['ns3::TosTlvValue'])
register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])
register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])
register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])
register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])
register_Ns3U16TlvValue_methods(root_module, root_module['ns3::U16TlvValue'])
register_Ns3U32TlvValue_methods(root_module, root_module['ns3::U32TlvValue'])
register_Ns3U8TlvValue_methods(root_module, root_module['ns3::U8TlvValue'])
register_Ns3UcdChannelEncodings_methods(root_module, root_module['ns3::UcdChannelEncodings'])
register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])
register_Ns3VectorTlvValue_methods(root_module, root_module['ns3::VectorTlvValue'])
register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])
register_Ns3WimaxHelper_methods(root_module, root_module['ns3::WimaxHelper'])
register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])
register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])
register_Ns3Empty_methods(root_module, root_module['ns3::empty'])
register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])
register_Ns3SimpleOfdmSendParam_methods(root_module, root_module['ns3::simpleOfdmSendParam'])
register_Ns3Chunk_methods(root_module, root_module['ns3::Chunk'])
register_Ns3ClassificationRuleVectorTlvValue_methods(root_module, root_module['ns3::ClassificationRuleVectorTlvValue'])
register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])
register_Ns3CsParamVectorTlvValue_methods(root_module, root_module['ns3::CsParamVectorTlvValue'])
register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])
register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])
register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])
register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])
register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])
register_Ns3Header_methods(root_module, root_module['ns3::Header'])
register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])
register_Ns3Ipv4AddressTlvValue_methods(root_module, root_module['ns3::Ipv4AddressTlvValue'])
register_Ns3Ipv4AddressTlvValueIpv4Addr_methods(root_module, root_module['ns3::Ipv4AddressTlvValue::ipv4Addr'])
register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])
register_Ns3MacHeaderType_methods(root_module, root_module['ns3::MacHeaderType'])
register_Ns3ManagementMessageType_methods(root_module, root_module['ns3::ManagementMessageType'])
register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])
register_Ns3Object_methods(root_module, root_module['ns3::Object'])
register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])
register_Ns3OfdmDownlinkFramePrefix_methods(root_module, root_module['ns3::OfdmDownlinkFramePrefix'])
register_Ns3OfdmSendParams_methods(root_module, root_module['ns3::OfdmSendParams'])
register_Ns3OfdmUcdChannelEncodings_methods(root_module, root_module['ns3::OfdmUcdChannelEncodings'])
register_Ns3PacketBurst_methods(root_module, root_module['ns3::PacketBurst'])
register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])
register_Ns3PcapFileWrapper_methods(root_module, root_module['ns3::PcapFileWrapper'])
register_Ns3PortRangeTlvValue_methods(root_module, root_module['ns3::PortRangeTlvValue'])
register_Ns3PortRangeTlvValuePortRange_methods(root_module, root_module['ns3::PortRangeTlvValue::PortRange'])
register_Ns3PriorityUlJob_methods(root_module, root_module['ns3::PriorityUlJob'])
register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])
register_Ns3ProtocolTlvValue_methods(root_module, root_module['ns3::ProtocolTlvValue'])
register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])
register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])
register_Ns3RngReq_methods(root_module, root_module['ns3::RngReq'])
register_Ns3RngRsp_methods(root_module, root_module['ns3::RngRsp'])
register_Ns3SSManager_methods(root_module, root_module['ns3::SSManager'])
register_Ns3ServiceFlowManager_methods(root_module, root_module['ns3::ServiceFlowManager'])
register_Ns3SfVectorTlvValue_methods(root_module, root_module['ns3::SfVectorTlvValue'])
register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])
register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])
register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])
register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])
register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >'])
register_Ns3SimpleRefCount__Ns3NixVector_Ns3Empty_Ns3DefaultDeleter__lt__ns3NixVector__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >'])
register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >'])
register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >'])
register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])
register_Ns3SsServiceFlowManager_methods(root_module, root_module['ns3::SsServiceFlowManager'])
register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])
register_Ns3Time_methods(root_module, root_module['ns3::Time'])
register_Ns3Tlv_methods(root_module, root_module['ns3::Tlv'])
register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])
register_Ns3Trailer_methods(root_module, root_module['ns3::Trailer'])
register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])
register_Ns3Ucd_methods(root_module, root_module['ns3::Ucd'])
register_Ns3UlJob_methods(root_module, root_module['ns3::UlJob'])
register_Ns3UlMap_methods(root_module, root_module['ns3::UlMap'])
register_Ns3UplinkScheduler_methods(root_module, root_module['ns3::UplinkScheduler'])
register_Ns3UplinkSchedulerMBQoS_methods(root_module, root_module['ns3::UplinkSchedulerMBQoS'])
register_Ns3UplinkSchedulerRtps_methods(root_module, root_module['ns3::UplinkSchedulerRtps'])
register_Ns3UplinkSchedulerSimple_methods(root_module, root_module['ns3::UplinkSchedulerSimple'])
register_Ns3WimaxConnection_methods(root_module, root_module['ns3::WimaxConnection'])
register_Ns3WimaxMacQueue_methods(root_module, root_module['ns3::WimaxMacQueue'])
register_Ns3WimaxMacToMacHeader_methods(root_module, root_module['ns3::WimaxMacToMacHeader'])
register_Ns3WimaxPhy_methods(root_module, root_module['ns3::WimaxPhy'])
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_Ns3BSScheduler_methods(root_module, root_module['ns3::BSScheduler'])
register_Ns3BSSchedulerRtps_methods(root_module, root_module['ns3::BSSchedulerRtps'])
register_Ns3BSSchedulerSimple_methods(root_module, root_module['ns3::BSSchedulerSimple'])
register_Ns3BandwidthRequestHeader_methods(root_module, root_module['ns3::BandwidthRequestHeader'])
register_Ns3BsServiceFlowManager_methods(root_module, root_module['ns3::BsServiceFlowManager'])
register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])
register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])
register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])
register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])
register_Ns3ConnectionManager_methods(root_module, root_module['ns3::ConnectionManager'])
register_Ns3Dcd_methods(root_module, root_module['ns3::Dcd'])
register_Ns3DlMap_methods(root_module, root_module['ns3::DlMap'])
register_Ns3DsaAck_methods(root_module, root_module['ns3::DsaAck'])
register_Ns3DsaReq_methods(root_module, root_module['ns3::DsaReq'])
register_Ns3DsaRsp_methods(root_module, root_module['ns3::DsaRsp'])
register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])
register_Ns3EventImpl_methods(root_module, root_module['ns3::EventImpl'])
register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])
register_Ns3FragmentationSubheader_methods(root_module, root_module['ns3::FragmentationSubheader'])
register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])
register_Ns3GenericMacHeader_methods(root_module, root_module['ns3::GenericMacHeader'])
register_Ns3GrantManagementSubheader_methods(root_module, root_module['ns3::GrantManagementSubheader'])
register_Ns3IpcsClassifier_methods(root_module, root_module['ns3::IpcsClassifier'])
register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])
register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])
register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])
register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])
register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])
register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])
register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])
register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])
register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])
register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])
register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])
register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])
register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])
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'])
register_Ns3ObjectFactoryChecker_methods(root_module, root_module['ns3::ObjectFactoryChecker'])
register_Ns3ObjectFactoryValue_methods(root_module, root_module['ns3::ObjectFactoryValue'])
register_Ns3OutputStreamWrapper_methods(root_module, root_module['ns3::OutputStreamWrapper'])
register_Ns3Packet_methods(root_module, root_module['ns3::Packet'])
register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])
register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])
register_Ns3SimpleOfdmWimaxPhy_methods(root_module, root_module['ns3::SimpleOfdmWimaxPhy'])
register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])
register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])
register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])
register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])
register_Ns3UintegerValue_methods(root_module, root_module['ns3::UintegerValue'])
register_Ns3WimaxChannel_methods(root_module, root_module['ns3::WimaxChannel'])
register_Ns3WimaxNetDevice_methods(root_module, root_module['ns3::WimaxNetDevice'])
register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])
register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])
register_Ns3BaseStationNetDevice_methods(root_module, root_module['ns3::BaseStationNetDevice'])
register_Ns3SimpleOfdmWimaxChannel_methods(root_module, root_module['ns3::SimpleOfdmWimaxChannel'])
register_Ns3SubscriberStationNetDevice_methods(root_module, root_module['ns3::SubscriberStationNetDevice'])
return
def register_Ns3Address_methods(root_module, cls):
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]
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')],
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')])
## 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')],
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')])
## address.h (module 'network'): uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]
cls.add_method('CopyTo',
'uint32_t',
[param('uint8_t *', 'buffer')],
is_const=True)
## address.h (module 'network'): void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]
cls.add_method('Deserialize',
'void',
[param('ns3::TagBuffer', 'buffer')])
## address.h (module 'network'): uint8_t ns3::Address::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## address.h (module 'network'): uint32_t ns3::Address::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## address.h (module 'network'): bool ns3::Address::IsInvalid() const [member function]
cls.add_method('IsInvalid',
'bool',
[],
is_const=True)
## address.h (module 'network'): bool ns3::Address::IsMatchingType(uint8_t type) const [member function]
cls.add_method('IsMatchingType',
'bool',
[param('uint8_t', 'type')],
is_const=True)
## address.h (module 'network'): static uint8_t ns3::Address::Register() [member function]
cls.add_method('Register',
'uint8_t',
[],
is_static=True)
## address.h (module 'network'): void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::TagBuffer', 'buffer')],
is_const=True)
return
def register_Ns3AsciiTraceHelper_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::AsciiTraceHelper::AsciiTraceHelper(ns3::AsciiTraceHelper const & arg0) [copy 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::OutputStreamWrapper> ns3::AsciiTraceHelper::CreateFileStream(std::string filename, std::_Ios_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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, std::string context, ns3::Ptr<const ns3::Packet> 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<ns3::OutputStreamWrapper> file, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('DefaultReceiveSinkWithoutContext',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'file'), param('ns3::Ptr< ns3::Packet const >', 'p')],
is_static=True)
## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## trace-helper.h (module 'network'): std::string ns3::AsciiTraceHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> 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')])
return
def register_Ns3AsciiTraceHelperForDevice_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice(ns3::AsciiTraceHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AsciiTraceHelperForDevice const &', 'arg0')])
## trace-helper.h (module 'network'): ns3::AsciiTraceHelperForDevice::AsciiTraceHelperForDevice() [constructor]
cls.add_constructor([])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename=false) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::Ptr<ns3::NetDevice> nd) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::Ptr< ns3::NetDevice >', 'nd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, std::string ndName, bool explicitFilename=false) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string ndName) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'ndName')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::NetDeviceContainer d) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::NetDeviceContainer', 'd')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(std::string prefix, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> stream, ns3::NodeContainer n) [member function]
cls.add_method('EnableAscii',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('ns3::NodeContainer', 'n')])
## 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')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAscii(ns3::Ptr<ns3::OutputStreamWrapper> 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')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(std::string prefix) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('std::string', 'prefix')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiAll(ns3::Ptr<ns3::OutputStreamWrapper> stream) [member function]
cls.add_method('EnableAsciiAll',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream')])
## trace-helper.h (module 'network'): void ns3::AsciiTraceHelperForDevice::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3AttributeConstructionList_methods(root_module, cls):
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy 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<ns3::AttributeChecker const> checker, ns3::Ptr<ns3::AttributeValue> 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::Item> ns3::AttributeConstructionList::Begin() const [member function]
cls.add_method('Begin',
'std::_List_const_iterator< ns3::AttributeConstructionList::Item >',
[],
is_const=True)
## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::End() const [member function]
cls.add_method('End',
'std::_List_const_iterator< ns3::AttributeConstructionList::Item >',
[],
is_const=True)
## attribute-construction-list.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeConstructionList::Find(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('Find',
'ns3::Ptr< ns3::AttributeValue >',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True)
return
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]
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)
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable]
cls.add_instance_attribute('value', 'ns3::Ptr< ns3::AttributeValue >', is_const=False)
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'): bool ns3::Buffer::AddAtEnd(uint32_t end) [member function]
cls.add_method('AddAtEnd',
'bool',
[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'): bool ns3::Buffer::AddAtStart(uint32_t start) [member function]
cls.add_method('AddAtStart',
'bool',
[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'): ns3::Buffer ns3::Buffer::CreateFullCopy() const [member function]
cls.add_method('CreateFullCopy',
'ns3::Buffer',
[],
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'): int32_t ns3::Buffer::GetCurrentEndOffset() const [member function]
cls.add_method('GetCurrentEndOffset',
'int32_t',
[],
is_const=True)
## buffer.h (module 'network'): int32_t ns3::Buffer::GetCurrentStartOffset() const [member function]
cls.add_method('GetCurrentStartOffset',
'int32_t',
[],
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',
'void',
[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('uint32_t', '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]
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')])
## 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')])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetDistanceFrom(ns3::Buffer::Iterator const & o) const [member function]
cls.add_method('GetDistanceFrom',
'uint32_t',
[param('ns3::Buffer::Iterator const &', 'o')],
is_const=True)
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsEnd() const [member function]
cls.add_method('IsEnd',
'bool',
[],
is_const=True)
## buffer.h (module 'network'): bool ns3::Buffer::Iterator::IsStart() const [member function]
cls.add_method('IsStart',
'bool',
[],
is_const=True)
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next() [member function]
cls.add_method('Next',
'void',
[])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Next(uint32_t delta) [member function]
cls.add_method('Next',
'void',
[param('uint32_t', 'delta')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev() [member function]
cls.add_method('Prev',
'void',
[])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Prev(uint32_t delta) [member function]
cls.add_method('Prev',
'void',
[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('uint32_t', 'size')])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadLsbtohU16() [member function]
cls.add_method('ReadLsbtohU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadLsbtohU32() [member function]
cls.add_method('ReadLsbtohU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadLsbtohU64() [member function]
cls.add_method('ReadLsbtohU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadNtohU16() [member function]
cls.add_method('ReadNtohU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadNtohU32() [member function]
cls.add_method('ReadNtohU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadNtohU64() [member function]
cls.add_method('ReadNtohU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint16_t ns3::Buffer::Iterator::ReadU16() [member function]
cls.add_method('ReadU16',
'uint16_t',
[])
## buffer.h (module 'network'): uint32_t ns3::Buffer::Iterator::ReadU32() [member function]
cls.add_method('ReadU32',
'uint32_t',
[])
## buffer.h (module 'network'): uint64_t ns3::Buffer::Iterator::ReadU64() [member function]
cls.add_method('ReadU64',
'uint64_t',
[])
## buffer.h (module 'network'): uint8_t ns3::Buffer::Iterator::ReadU8() [member function]
cls.add_method('ReadU8',
'uint8_t',
[])
## 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')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::Write(ns3::Buffer::Iterator start, ns3::Buffer::Iterator end) [member function]
cls.add_method('Write',
'void',
[param('ns3::Buffer::Iterator', 'start'), param('ns3::Buffer::Iterator', 'end')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU16(uint16_t data) [member function]
cls.add_method('WriteHtolsbU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU32(uint32_t data) [member function]
cls.add_method('WriteHtolsbU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtolsbU64(uint64_t data) [member function]
cls.add_method('WriteHtolsbU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU16(uint16_t data) [member function]
cls.add_method('WriteHtonU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU32(uint32_t data) [member function]
cls.add_method('WriteHtonU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteHtonU64(uint64_t data) [member function]
cls.add_method('WriteHtonU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU16(uint16_t data) [member function]
cls.add_method('WriteU16',
'void',
[param('uint16_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU32(uint32_t data) [member function]
cls.add_method('WriteU32',
'void',
[param('uint32_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU64(uint64_t data) [member function]
cls.add_method('WriteU64',
'void',
[param('uint64_t', 'data')])
## buffer.h (module 'network'): void ns3::Buffer::Iterator::WriteU8(uint8_t data) [member function]
cls.add_method('WriteU8',
'void',
[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('uint8_t', 'data'), param('uint32_t', 'len')])
return
def register_Ns3ByteTagIterator_methods(root_module, cls):
## packet.h (module 'network'): ns3::ByteTagIterator::ByteTagIterator(ns3::ByteTagIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ByteTagIterator const &', 'arg0')])
## packet.h (module 'network'): bool ns3::ByteTagIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet.h (module 'network'): ns3::ByteTagIterator::Item ns3::ByteTagIterator::Next() [member function]
cls.add_method('Next',
'ns3::ByteTagIterator::Item',
[])
return
def register_Ns3ByteTagIteratorItem_methods(root_module, cls):
## packet.h (module 'network'): ns3::ByteTagIterator::Item::Item(ns3::ByteTagIterator::Item const & arg0) [copy 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',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::ByteTagIterator::Item::GetStart() const [member function]
cls.add_method('GetStart',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): void ns3::ByteTagIterator::Item::GetTag(ns3::Tag & tag) const [member function]
cls.add_method('GetTag',
'void',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::TypeId ns3::ByteTagIterator::Item::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
return
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]
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')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::Add(ns3::ByteTagList const & o) [member function]
cls.add_method('Add',
'void',
[param('ns3::ByteTagList const &', 'o')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtEnd(int32_t adjustment, int32_t appendOffset) [member function]
cls.add_method('AddAtEnd',
'void',
[param('int32_t', 'adjustment'), param('int32_t', 'appendOffset')])
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::AddAtStart(int32_t adjustment, int32_t prependOffset) [member function]
cls.add_method('AddAtStart',
'void',
[param('int32_t', 'adjustment'), param('int32_t', 'prependOffset')])
## 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')],
is_const=True)
## byte-tag-list.h (module 'network'): void ns3::ByteTagList::RemoveAll() [member function]
cls.add_method('RemoveAll',
'void',
[])
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]
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',
'uint32_t',
[],
is_const=True)
## byte-tag-list.h (module 'network'): bool ns3::ByteTagList::Iterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item ns3::ByteTagList::Iterator::Next() [member function]
cls.add_method('Next',
'ns3::ByteTagList::Iterator::Item',
[])
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]
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')])
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::buf [variable]
cls.add_instance_attribute('buf', 'ns3::TagBuffer', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::end [variable]
cls.add_instance_attribute('end', 'int32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::size [variable]
cls.add_instance_attribute('size', 'uint32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::start [variable]
cls.add_instance_attribute('start', 'int32_t', is_const=False)
## byte-tag-list.h (module 'network'): ns3::ByteTagList::Iterator::Item::tid [variable]
cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
return
def register_Ns3CallbackBase_methods(root_module, cls):
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CallbackBase const &', 'arg0')])
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor]
cls.add_constructor([])
## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]
cls.add_method('GetImpl',
'ns3::Ptr< ns3::CallbackImplBase >',
[],
is_const=True)
## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')],
visibility='protected')
## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]
cls.add_method('Demangle',
'std::string',
[param('std::string const &', 'mangled')],
is_static=True, visibility='protected')
return
def register_Ns3Cid_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_operator()
cls.add_binary_comparison_operator('==')
## cid.h (module 'wimax'): ns3::Cid::Cid(ns3::Cid const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Cid const &', 'arg0')])
## cid.h (module 'wimax'): ns3::Cid::Cid() [constructor]
cls.add_constructor([])
## cid.h (module 'wimax'): ns3::Cid::Cid(uint16_t cid) [constructor]
cls.add_constructor([param('uint16_t', 'cid')])
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::Broadcast() [member function]
cls.add_method('Broadcast',
'ns3::Cid',
[],
is_static=True)
## cid.h (module 'wimax'): uint16_t ns3::Cid::GetIdentifier() const [member function]
cls.add_method('GetIdentifier',
'uint16_t',
[],
is_const=True)
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::InitialRanging() [member function]
cls.add_method('InitialRanging',
'ns3::Cid',
[],
is_static=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsInitialRanging() const [member function]
cls.add_method('IsInitialRanging',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): bool ns3::Cid::IsPadding() const [member function]
cls.add_method('IsPadding',
'bool',
[],
is_const=True)
## cid.h (module 'wimax'): static ns3::Cid ns3::Cid::Padding() [member function]
cls.add_method('Padding',
'ns3::Cid',
[],
is_static=True)
return
def register_Ns3CidFactory_methods(root_module, cls):
## cid-factory.h (module 'wimax'): ns3::CidFactory::CidFactory(ns3::CidFactory const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CidFactory const &', 'arg0')])
## cid-factory.h (module 'wimax'): ns3::CidFactory::CidFactory() [constructor]
cls.add_constructor([])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::Allocate(ns3::Cid::Type type) [member function]
cls.add_method('Allocate',
'ns3::Cid',
[param('ns3::Cid::Type', 'type')])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateBasic() [member function]
cls.add_method('AllocateBasic',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateMulticast() [member function]
cls.add_method('AllocateMulticast',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocatePrimary() [member function]
cls.add_method('AllocatePrimary',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): ns3::Cid ns3::CidFactory::AllocateTransportOrSecondary() [member function]
cls.add_method('AllocateTransportOrSecondary',
'ns3::Cid',
[])
## cid-factory.h (module 'wimax'): void ns3::CidFactory::FreeCid(ns3::Cid cid) [member function]
cls.add_method('FreeCid',
'void',
[param('ns3::Cid', 'cid')])
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsBasic(ns3::Cid cid) const [member function]
cls.add_method('IsBasic',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsPrimary(ns3::Cid cid) const [member function]
cls.add_method('IsPrimary',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
## cid-factory.h (module 'wimax'): bool ns3::CidFactory::IsTransport(ns3::Cid cid) const [member function]
cls.add_method('IsTransport',
'bool',
[param('ns3::Cid', 'cid')],
is_const=True)
return
def register_Ns3CsParameters_methods(root_module, cls):
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::CsParameters const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CsParameters const &', 'arg0')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters() [constructor]
cls.add_constructor([])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::CsParameters(ns3::CsParameters::Action classifierDscAction, ns3::IpcsClassifierRecord classifier) [constructor]
cls.add_constructor([param('ns3::CsParameters::Action', 'classifierDscAction'), param('ns3::IpcsClassifierRecord', 'classifier')])
## cs-parameters.h (module 'wimax'): ns3::CsParameters::Action ns3::CsParameters::GetClassifierDscAction() const [member function]
cls.add_method('GetClassifierDscAction',
'ns3::CsParameters::Action',
[],
is_const=True)
## cs-parameters.h (module 'wimax'): ns3::IpcsClassifierRecord ns3::CsParameters::GetPacketClassifierRule() const [member function]
cls.add_method('GetPacketClassifierRule',
'ns3::IpcsClassifierRecord',
[],
is_const=True)
## cs-parameters.h (module 'wimax'): void ns3::CsParameters::SetClassifierDscAction(ns3::CsParameters::Action action) [member function]
cls.add_method('SetClassifierDscAction',
'void',
[param('ns3::CsParameters::Action', 'action')])
## cs-parameters.h (module 'wimax'): void ns3::CsParameters::SetPacketClassifierRule(ns3::IpcsClassifierRecord packetClassifierRule) [member function]
cls.add_method('SetPacketClassifierRule',
'void',
[param('ns3::IpcsClassifierRecord', 'packetClassifierRule')])
## cs-parameters.h (module 'wimax'): ns3::Tlv ns3::CsParameters::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
return
def register_Ns3DcdChannelEncodings_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings::DcdChannelEncodings(ns3::DcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DcdChannelEncodings const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::DcdChannelEncodings::DcdChannelEncodings() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetBsEirp() const [member function]
cls.add_method('GetBsEirp',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetEirxPIrMax() const [member function]
cls.add_method('GetEirxPIrMax',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DcdChannelEncodings::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::DcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetBsEirp(uint16_t bs_eirp) [member function]
cls.add_method('SetBsEirp',
'void',
[param('uint16_t', 'bs_eirp')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetEirxPIrMax(uint16_t rss_ir_max) [member function]
cls.add_method('SetEirxPIrMax',
'void',
[param('uint16_t', 'rss_ir_max')])
## dl-mac-messages.h (module 'wimax'): void ns3::DcdChannelEncodings::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::DcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3DlFramePrefixIe_methods(root_module, cls):
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe::DlFramePrefixIe(ns3::DlFramePrefixIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DlFramePrefixIe const &', 'arg0')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::DlFramePrefixIe::DlFramePrefixIe() [constructor]
cls.add_constructor([])
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetLength() const [member function]
cls.add_method('GetLength',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetPreamblePresent() const [member function]
cls.add_method('GetPreamblePresent',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::DlFramePrefixIe::GetRateId() const [member function]
cls.add_method('GetRateId',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint16_t ns3::DlFramePrefixIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Buffer::Iterator ns3::DlFramePrefixIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetLength(uint16_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint16_t', 'length')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetPreamblePresent(uint8_t preamblePresent) [member function]
cls.add_method('SetPreamblePresent',
'void',
[param('uint8_t', 'preamblePresent')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetRateId(uint8_t rateId) [member function]
cls.add_method('SetRateId',
'void',
[param('uint8_t', 'rateId')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::DlFramePrefixIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Buffer::Iterator ns3::DlFramePrefixIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
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_constructor([param('ns3::EventId const &', 'arg0')])
## event-id.h (module 'core'): ns3::EventId::EventId() [constructor]
cls.add_constructor([])
## event-id.h (module 'core'): ns3::EventId::EventId(ns3::Ptr<ns3::EventImpl> const & impl, uint64_t ts, uint32_t context, uint32_t uid) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::EventImpl > const &', 'impl'), param('uint64_t', 'ts'), param('uint32_t', 'context'), param('uint32_t', 'uid')])
## event-id.h (module 'core'): void ns3::EventId::Cancel() [member function]
cls.add_method('Cancel',
'void',
[])
## event-id.h (module 'core'): uint32_t ns3::EventId::GetContext() const [member function]
cls.add_method('GetContext',
'uint32_t',
[],
is_const=True)
## event-id.h (module 'core'): uint64_t ns3::EventId::GetTs() const [member function]
cls.add_method('GetTs',
'uint64_t',
[],
is_const=True)
## event-id.h (module 'core'): uint32_t ns3::EventId::GetUid() const [member function]
cls.add_method('GetUid',
'uint32_t',
[],
is_const=True)
## event-id.h (module 'core'): bool ns3::EventId::IsExpired() const [member function]
cls.add_method('IsExpired',
'bool',
[],
is_const=True)
## event-id.h (module 'core'): bool ns3::EventId::IsRunning() const [member function]
cls.add_method('IsRunning',
'bool',
[],
is_const=True)
## event-id.h (module 'core'): ns3::EventImpl * ns3::EventId::PeekEventImpl() const [member function]
cls.add_method('PeekEventImpl',
'ns3::EventImpl *',
[],
is_const=True)
return
def register_Ns3IpcsClassifierRecord_methods(root_module, cls):
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::IpcsClassifierRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IpcsClassifierRecord const &', 'arg0')])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord() [constructor]
cls.add_constructor([])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::Ipv4Address srcAddress, ns3::Ipv4Mask srcMask, ns3::Ipv4Address dstAddress, ns3::Ipv4Mask dstMask, uint16_t srcPortLow, uint16_t srcPortHigh, uint16_t dstPortLow, uint16_t dstPortHigh, uint8_t protocol, uint8_t priority) [constructor]
cls.add_constructor([param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Mask', 'srcMask'), param('ns3::Ipv4Address', 'dstAddress'), param('ns3::Ipv4Mask', 'dstMask'), param('uint16_t', 'srcPortLow'), param('uint16_t', 'srcPortHigh'), param('uint16_t', 'dstPortLow'), param('uint16_t', 'dstPortHigh'), param('uint8_t', 'protocol'), param('uint8_t', 'priority')])
## ipcs-classifier-record.h (module 'wimax'): ns3::IpcsClassifierRecord::IpcsClassifierRecord(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddDstAddr(ns3::Ipv4Address dstAddress, ns3::Ipv4Mask dstMask) [member function]
cls.add_method('AddDstAddr',
'void',
[param('ns3::Ipv4Address', 'dstAddress'), param('ns3::Ipv4Mask', 'dstMask')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddDstPortRange(uint16_t dstPortLow, uint16_t dstPortHigh) [member function]
cls.add_method('AddDstPortRange',
'void',
[param('uint16_t', 'dstPortLow'), param('uint16_t', 'dstPortHigh')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddProtocol(uint8_t proto) [member function]
cls.add_method('AddProtocol',
'void',
[param('uint8_t', 'proto')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddSrcAddr(ns3::Ipv4Address srcAddress, ns3::Ipv4Mask srcMask) [member function]
cls.add_method('AddSrcAddr',
'void',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Mask', 'srcMask')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::AddSrcPortRange(uint16_t srcPortLow, uint16_t srcPortHigh) [member function]
cls.add_method('AddSrcPortRange',
'void',
[param('uint16_t', 'srcPortLow'), param('uint16_t', 'srcPortHigh')])
## ipcs-classifier-record.h (module 'wimax'): bool ns3::IpcsClassifierRecord::CheckMatch(ns3::Ipv4Address srcAddress, ns3::Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const [member function]
cls.add_method('CheckMatch',
'bool',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Address', 'dstAddress'), param('uint16_t', 'srcPort'), param('uint16_t', 'dstPort'), param('uint8_t', 'proto')],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint16_t ns3::IpcsClassifierRecord::GetCid() const [member function]
cls.add_method('GetCid',
'uint16_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint16_t ns3::IpcsClassifierRecord::GetIndex() const [member function]
cls.add_method('GetIndex',
'uint16_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): uint8_t ns3::IpcsClassifierRecord::GetPriority() const [member function]
cls.add_method('GetPriority',
'uint8_t',
[],
is_const=True)
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetCid(uint16_t cid) [member function]
cls.add_method('SetCid',
'void',
[param('uint16_t', 'cid')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetIndex(uint16_t index) [member function]
cls.add_method('SetIndex',
'void',
[param('uint16_t', 'index')])
## ipcs-classifier-record.h (module 'wimax'): void ns3::IpcsClassifierRecord::SetPriority(uint8_t prio) [member function]
cls.add_method('SetPriority',
'void',
[param('uint8_t', 'prio')])
## ipcs-classifier-record.h (module 'wimax'): ns3::Tlv ns3::IpcsClassifierRecord::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
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_constructor([param('ns3::Ipv4Address const &', 'arg0')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address() [constructor]
cls.add_constructor([])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(uint32_t address) [constructor]
cls.add_constructor([param('uint32_t', 'address')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address::Ipv4Address(char const * address) [constructor]
cls.add_constructor([param('char const *', 'address')])
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::CombineMask(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('CombineMask',
'ns3::Ipv4Address',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Ipv4Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::Deserialize(uint8_t const * buf) [member function]
cls.add_method('Deserialize',
'ns3::Ipv4Address',
[param('uint8_t const *', 'buf')],
is_static=True)
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Address::Get() const [member function]
cls.add_method('Get',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetAny() [member function]
cls.add_method('GetAny',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetBroadcast() [member function]
cls.add_method('GetBroadcast',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4Address::GetSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('GetSubnetDirectedBroadcast',
'ns3::Ipv4Address',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Address ns3::Ipv4Address::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv4Address',
[],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsEqual(ns3::Ipv4Address const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv4Address const &', 'other')],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsLocalMulticast() const [member function]
cls.add_method('IsLocalMulticast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): static bool ns3::Ipv4Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Address::IsSubnetDirectedBroadcast(ns3::Ipv4Mask const & mask) const [member function]
cls.add_method('IsSubnetDirectedBroadcast',
'bool',
[param('ns3::Ipv4Mask const &', 'mask')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Serialize(uint8_t * buf) const [member function]
cls.add_method('Serialize',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(uint32_t address) [member function]
cls.add_method('Set',
'void',
[param('uint32_t', 'address')])
## ipv4-address.h (module 'network'): void ns3::Ipv4Address::Set(char const * address) [member function]
cls.add_method('Set',
'void',
[param('char const *', 'address')])
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_constructor([param('ns3::Ipv4Mask const &', 'arg0')])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask() [constructor]
cls.add_constructor([])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(uint32_t mask) [constructor]
cls.add_constructor([param('uint32_t', 'mask')])
## ipv4-address.h (module 'network'): ns3::Ipv4Mask::Ipv4Mask(char const * mask) [constructor]
cls.add_constructor([param('char const *', 'mask')])
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::Get() const [member function]
cls.add_method('Get',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): uint32_t ns3::Ipv4Mask::GetInverse() const [member function]
cls.add_method('GetInverse',
'uint32_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): uint16_t ns3::Ipv4Mask::GetPrefixLength() const [member function]
cls.add_method('GetPrefixLength',
'uint16_t',
[],
is_const=True)
## ipv4-address.h (module 'network'): static ns3::Ipv4Mask ns3::Ipv4Mask::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv4Mask',
[],
is_static=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsEqual(ns3::Ipv4Mask other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv4Mask', 'other')],
is_const=True)
## ipv4-address.h (module 'network'): bool ns3::Ipv4Mask::IsMatch(ns3::Ipv4Address a, ns3::Ipv4Address b) const [member function]
cls.add_method('IsMatch',
'bool',
[param('ns3::Ipv4Address', 'a'), param('ns3::Ipv4Address', 'b')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4Mask::Set(uint32_t mask) [member function]
cls.add_method('Set',
'void',
[param('uint32_t', '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('==')
## 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]
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')])
## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6Address::CombinePrefix(ns3::Ipv6Prefix const & prefix) [member function]
cls.add_method('CombinePrefix',
'ns3::Ipv6Address',
[param('ns3::Ipv6Prefix const &', 'prefix')])
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Ipv6Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::Deserialize(uint8_t const * buf) [member function]
cls.add_method('Deserialize',
'ns3::Ipv6Address',
[param('uint8_t const *', 'buf')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllHostsMulticast() [member function]
cls.add_method('GetAllHostsMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllNodesMulticast() [member function]
cls.add_method('GetAllNodesMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAllRoutersMulticast() [member function]
cls.add_method('GetAllRoutersMulticast',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetAny() [member function]
cls.add_method('GetAny',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::GetBytes(uint8_t * buf) const [member function]
cls.add_method('GetBytes',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv6Address',
[],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllHostsMulticast() const [member function]
cls.add_method('IsAllHostsMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllNodesMulticast() const [member function]
cls.add_method('IsAllNodesMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAllRoutersMulticast() const [member function]
cls.add_method('IsAllRoutersMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsAny() const [member function]
cls.add_method('IsAny',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsEqual(ns3::Ipv6Address const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv6Address const &', 'other')],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLinkLocal() const [member function]
cls.add_method('IsLinkLocal',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsLocalhost() const [member function]
cls.add_method('IsLocalhost',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): static bool ns3::Ipv6Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Address::IsSolicitedMulticast() const [member function]
cls.add_method('IsSolicitedMulticast',
'bool',
[],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredAddress(ns3::Mac48Address addr, ns3::Ipv6Address prefix) [member function]
cls.add_method('MakeAutoconfiguredAddress',
'ns3::Ipv6Address',
[param('ns3::Mac48Address', 'addr'), param('ns3::Ipv6Address', 'prefix')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeAutoconfiguredLinkLocalAddress(ns3::Mac48Address mac) [member function]
cls.add_method('MakeAutoconfiguredLinkLocalAddress',
'ns3::Ipv6Address',
[param('ns3::Mac48Address', 'mac')],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Address ns3::Ipv6Address::MakeSolicitedAddress(ns3::Ipv6Address addr) [member function]
cls.add_method('MakeSolicitedAddress',
'ns3::Ipv6Address',
[param('ns3::Ipv6Address', 'addr')],
is_static=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Serialize(uint8_t * buf) const [member function]
cls.add_method('Serialize',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(char const * address) [member function]
cls.add_method('Set',
'void',
[param('char const *', 'address')])
## ipv6-address.h (module 'network'): void ns3::Ipv6Address::Set(uint8_t * address) [member function]
cls.add_method('Set',
'void',
[param('uint8_t *', 'address')])
return
def register_Ns3Ipv6Prefix_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_output_stream_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]
cls.add_constructor([param('uint8_t *', 'prefix')])
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix::Ipv6Prefix(char const * prefix) [constructor]
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]
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')])
## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::GetBytes(uint8_t * buf) const [member function]
cls.add_method('GetBytes',
'void',
[param('uint8_t *', 'buf')],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetLoopback() [member function]
cls.add_method('GetLoopback',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetOnes() [member function]
cls.add_method('GetOnes',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): uint8_t ns3::Ipv6Prefix::GetPrefixLength() const [member function]
cls.add_method('GetPrefixLength',
'uint8_t',
[],
is_const=True)
## ipv6-address.h (module 'network'): static ns3::Ipv6Prefix ns3::Ipv6Prefix::GetZero() [member function]
cls.add_method('GetZero',
'ns3::Ipv6Prefix',
[],
is_static=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsEqual(ns3::Ipv6Prefix const & other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ipv6Prefix const &', 'other')],
is_const=True)
## ipv6-address.h (module 'network'): bool ns3::Ipv6Prefix::IsMatch(ns3::Ipv6Address a, ns3::Ipv6Address b) const [member function]
cls.add_method('IsMatch',
'bool',
[param('ns3::Ipv6Address', 'a'), param('ns3::Ipv6Address', 'b')],
is_const=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6Prefix::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
return
def register_Ns3LogComponent_methods(root_module, cls):
## log.h (module 'core'): ns3::LogComponent::LogComponent(ns3::LogComponent const & arg0) [copy constructor]
cls.add_constructor([param('ns3::LogComponent const &', 'arg0')])
## log.h (module 'core'): ns3::LogComponent::LogComponent(char const * name) [constructor]
cls.add_constructor([param('char const *', 'name')])
## log.h (module 'core'): void ns3::LogComponent::Disable(ns3::LogLevel level) [member function]
cls.add_method('Disable',
'void',
[param('ns3::LogLevel', 'level')])
## log.h (module 'core'): void ns3::LogComponent::Enable(ns3::LogLevel level) [member function]
cls.add_method('Enable',
'void',
[param('ns3::LogLevel', 'level')])
## log.h (module 'core'): void ns3::LogComponent::EnvVarCheck(char const * name) [member function]
cls.add_method('EnvVarCheck',
'void',
[param('char const *', 'name')])
## log.h (module 'core'): bool ns3::LogComponent::IsEnabled(ns3::LogLevel level) const [member function]
cls.add_method('IsEnabled',
'bool',
[param('ns3::LogLevel', 'level')],
is_const=True)
## log.h (module 'core'): bool ns3::LogComponent::IsNoneEnabled() const [member function]
cls.add_method('IsNoneEnabled',
'bool',
[],
is_const=True)
## log.h (module 'core'): char const * ns3::LogComponent::Name() const [member function]
cls.add_method('Name',
'char const *',
[],
is_const=True)
return
def register_Ns3Mac48Address_methods(root_module, cls):
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]
cls.add_constructor([param('ns3::Mac48Address const &', 'arg0')])
## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address() [constructor]
cls.add_constructor([])
## mac48-address.h (module 'network'): ns3::Mac48Address::Mac48Address(char const * str) [constructor]
cls.add_constructor([param('char const *', 'str')])
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::Allocate() [member function]
cls.add_method('Allocate',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::ConvertFrom(ns3::Address const & address) [member function]
cls.add_method('ConvertFrom',
'ns3::Mac48Address',
[param('ns3::Address const &', 'address')],
is_static=True)
## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyFrom(uint8_t const * buffer) [member function]
cls.add_method('CopyFrom',
'void',
[param('uint8_t const *', 'buffer')])
## mac48-address.h (module 'network'): void ns3::Mac48Address::CopyTo(uint8_t * buffer) const [member function]
cls.add_method('CopyTo',
'void',
[param('uint8_t *', 'buffer')],
is_const=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetBroadcast() [member function]
cls.add_method('GetBroadcast',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv4Address address) [member function]
cls.add_method('GetMulticast',
'ns3::Mac48Address',
[param('ns3::Ipv4Address', 'address')],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast(ns3::Ipv6Address address) [member function]
cls.add_method('GetMulticast',
'ns3::Mac48Address',
[param('ns3::Ipv6Address', 'address')],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticast6Prefix() [member function]
cls.add_method('GetMulticast6Prefix',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): static ns3::Mac48Address ns3::Mac48Address::GetMulticastPrefix() [member function]
cls.add_method('GetMulticastPrefix',
'ns3::Mac48Address',
[],
is_static=True)
## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True)
## mac48-address.h (module 'network'): bool ns3::Mac48Address::IsGroup() const [member function]
cls.add_method('IsGroup',
'bool',
[],
is_const=True)
## mac48-address.h (module 'network'): static bool ns3::Mac48Address::IsMatchingType(ns3::Address const & address) [member function]
cls.add_method('IsMatchingType',
'bool',
[param('ns3::Address const &', 'address')],
is_static=True)
return
def register_Ns3NetDeviceContainer_methods(root_module, cls):
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NetDeviceContainer const &', 'arg0')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer() [constructor]
cls.add_constructor([])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::Ptr<ns3::NetDevice> dev) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::NetDevice >', 'dev')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(std::string devName) [constructor]
cls.add_constructor([param('std::string', 'devName')])
## net-device-container.h (module 'network'): ns3::NetDeviceContainer::NetDeviceContainer(ns3::NetDeviceContainer const & a, ns3::NetDeviceContainer const & b) [constructor]
cls.add_constructor([param('ns3::NetDeviceContainer const &', 'a'), param('ns3::NetDeviceContainer const &', 'b')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::NetDeviceContainer other) [member function]
cls.add_method('Add',
'void',
[param('ns3::NetDeviceContainer', 'other')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(ns3::Ptr<ns3::NetDevice> device) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ptr< ns3::NetDevice >', 'device')])
## net-device-container.h (module 'network'): void ns3::NetDeviceContainer::Add(std::string deviceName) [member function]
cls.add_method('Add',
'void',
[param('std::string', 'deviceName')])
## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > 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 > > >',
[],
is_const=True)
## net-device-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::NetDevice>*,std::vector<ns3::Ptr<ns3::NetDevice>, std::allocator<ns3::Ptr<ns3::NetDevice> > > > 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 > > >',
[],
is_const=True)
## net-device-container.h (module 'network'): ns3::Ptr<ns3::NetDevice> ns3::NetDeviceContainer::Get(uint32_t i) const [member function]
cls.add_method('Get',
'ns3::Ptr< ns3::NetDevice >',
[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',
'uint32_t',
[],
is_const=True)
return
def register_Ns3NodeContainer_methods(root_module, cls):
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'arg0')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer() [constructor]
cls.add_constructor([])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::Ptr<ns3::Node> node) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(std::string nodeName) [constructor]
cls.add_constructor([param('std::string', 'nodeName')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd')])
## node-container.h (module 'network'): ns3::NodeContainer::NodeContainer(ns3::NodeContainer const & a, ns3::NodeContainer const & b, ns3::NodeContainer const & c, ns3::NodeContainer const & d, ns3::NodeContainer const & e) [constructor]
cls.add_constructor([param('ns3::NodeContainer const &', 'a'), param('ns3::NodeContainer const &', 'b'), param('ns3::NodeContainer const &', 'c'), param('ns3::NodeContainer const &', 'd'), param('ns3::NodeContainer const &', 'e')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::NodeContainer other) [member function]
cls.add_method('Add',
'void',
[param('ns3::NodeContainer', 'other')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ptr< ns3::Node >', 'node')])
## node-container.h (module 'network'): void ns3::NodeContainer::Add(std::string nodeName) [member function]
cls.add_method('Add',
'void',
[param('std::string', 'nodeName')])
## node-container.h (module 'network'): __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > 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 > > >',
[],
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')])
## 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<const ns3::Ptr<ns3::Node>*,std::vector<ns3::Ptr<ns3::Node>, std::allocator<ns3::Ptr<ns3::Node> > > > 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 > > >',
[],
is_const=True)
## node-container.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NodeContainer::Get(uint32_t i) const [member function]
cls.add_method('Get',
'ns3::Ptr< ns3::Node >',
[param('uint32_t', 'i')],
is_const=True)
## node-container.h (module 'network'): static ns3::NodeContainer ns3::NodeContainer::GetGlobal() [member function]
cls.add_method('GetGlobal',
'ns3::NodeContainer',
[],
is_static=True)
## node-container.h (module 'network'): uint32_t ns3::NodeContainer::GetN() const [member function]
cls.add_method('GetN',
'uint32_t',
[],
is_const=True)
return
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]
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',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue &', 'value')],
is_const=True)
## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]
cls.add_method('GetAttributeFailSafe',
'bool',
[param('std::string', 'name'), param('ns3::AttributeValue &', 'attribute')],
is_const=True)
## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('SetAttribute',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('SetAttributeFailSafe',
'bool',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceConnect',
'bool',
[param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceConnectWithoutContext',
'bool',
[param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceDisconnect',
'bool',
[param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]
cls.add_method('TraceDisconnectWithoutContext',
'bool',
[param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])
## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeConstructionList const & attributes) [member function]
cls.add_method('ConstructSelf',
'void',
[param('ns3::AttributeConstructionList const &', 'attributes')],
visibility='protected')
## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function]
cls.add_method('NotifyConstructionCompleted',
'void',
[],
visibility='protected', is_virtual=True)
return
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]
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',
'void',
[param('ns3::Object *', 'object')],
is_static=True)
return
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]
cls.add_constructor([param('ns3::ObjectFactory const &', 'arg0')])
## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory() [constructor]
cls.add_constructor([])
## object-factory.h (module 'core'): ns3::ObjectFactory::ObjectFactory(std::string typeId) [constructor]
cls.add_constructor([param('std::string', 'typeId')])
## object-factory.h (module 'core'): ns3::Ptr<ns3::Object> ns3::ObjectFactory::Create() const [member function]
cls.add_method('Create',
'ns3::Ptr< ns3::Object >',
[],
is_const=True)
## object-factory.h (module 'core'): ns3::TypeId ns3::ObjectFactory::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
## object-factory.h (module 'core'): void ns3::ObjectFactory::Set(std::string name, ns3::AttributeValue const & value) [member function]
cls.add_method('Set',
'void',
[param('std::string', 'name'), param('ns3::AttributeValue const &', 'value')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(ns3::TypeId tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('ns3::TypeId', 'tid')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(char const * tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('char const *', 'tid')])
## object-factory.h (module 'core'): void ns3::ObjectFactory::SetTypeId(std::string tid) [member function]
cls.add_method('SetTypeId',
'void',
[param('std::string', 'tid')])
return
def register_Ns3OfdmDcdChannelEncodings_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings::OfdmDcdChannelEncodings(ns3::OfdmDcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDcdChannelEncodings const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings::OfdmDcdChannelEncodings() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::OfdmDcdChannelEncodings::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetChannelNr() const [member function]
cls.add_method('GetChannelNr',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetFrameDurationCode() const [member function]
cls.add_method('GetFrameDurationCode',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::OfdmDcdChannelEncodings::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDcdChannelEncodings::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetBaseStationId(ns3::Mac48Address baseStationId) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationId')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetChannelNr(uint8_t channelNr) [member function]
cls.add_method('SetChannelNr',
'void',
[param('uint8_t', 'channelNr')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetFrameDurationCode(uint8_t frameDurationCode) [member function]
cls.add_method('SetFrameDurationCode',
'void',
[param('uint8_t', 'frameDurationCode')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetRtg(uint8_t rtg) [member function]
cls.add_method('SetRtg',
'void',
[param('uint8_t', 'rtg')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDcdChannelEncodings::SetTtg(uint8_t ttg) [member function]
cls.add_method('SetTtg',
'void',
[param('uint8_t', 'ttg')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
visibility='private', is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3OfdmDlBurstProfile_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::OfdmDlBurstProfile(ns3::OfdmDlBurstProfile const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDlBurstProfile const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlBurstProfile::OfdmDlBurstProfile() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetFecCodeType() const [member function]
cls.add_method('GetFecCodeType',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlBurstProfile::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlBurstProfile::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlBurstProfile::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetFecCodeType(uint8_t fecCodeType) [member function]
cls.add_method('SetFecCodeType',
'void',
[param('uint8_t', 'fecCodeType')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetLength(uint8_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint8_t', 'length')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlBurstProfile::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlBurstProfile::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmDlMapIe_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe::OfdmDlMapIe(ns3::OfdmDlMapIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDlMapIe const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDlMapIe::OfdmDlMapIe() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): ns3::Cid ns3::OfdmDlMapIe::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlMapIe::GetDiuc() const [member function]
cls.add_method('GetDiuc',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmDlMapIe::GetPreamblePresent() const [member function]
cls.add_method('GetPreamblePresent',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlMapIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmDlMapIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlMapIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetDiuc(uint8_t diuc) [member function]
cls.add_method('SetDiuc',
'void',
[param('uint8_t', 'diuc')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetPreamblePresent(uint8_t preamblePresent) [member function]
cls.add_method('SetPreamblePresent',
'void',
[param('uint8_t', 'preamblePresent')])
## dl-mac-messages.h (module 'wimax'): void ns3::OfdmDlMapIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## dl-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmDlMapIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmUlBurstProfile_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::OfdmUlBurstProfile(ns3::OfdmUlBurstProfile const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUlBurstProfile const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlBurstProfile::OfdmUlBurstProfile() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetFecCodeType() const [member function]
cls.add_method('GetFecCodeType',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetLength() const [member function]
cls.add_method('GetLength',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlBurstProfile::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlBurstProfile::GetUiuc() const [member function]
cls.add_method('GetUiuc',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlBurstProfile::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetFecCodeType(uint8_t fecCodeType) [member function]
cls.add_method('SetFecCodeType',
'void',
[param('uint8_t', 'fecCodeType')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetLength(uint8_t length) [member function]
cls.add_method('SetLength',
'void',
[param('uint8_t', 'length')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlBurstProfile::SetUiuc(uint8_t uiuc) [member function]
cls.add_method('SetUiuc',
'void',
[param('uint8_t', 'uiuc')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlBurstProfile::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
def register_Ns3OfdmUlMapIe_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe::OfdmUlMapIe(ns3::OfdmUlMapIe const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUlMapIe const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUlMapIe::OfdmUlMapIe() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): ns3::Cid ns3::OfdmUlMapIe::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetDuration() const [member function]
cls.add_method('GetDuration',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetMidambleRepetitionInterval() const [member function]
cls.add_method('GetMidambleRepetitionInterval',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUlMapIe::GetStartTime() const [member function]
cls.add_method('GetStartTime',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetSubchannelIndex() const [member function]
cls.add_method('GetSubchannelIndex',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUlMapIe::GetUiuc() const [member function]
cls.add_method('GetUiuc',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlMapIe::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetDuration(uint16_t duration) [member function]
cls.add_method('SetDuration',
'void',
[param('uint16_t', 'duration')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetMidambleRepetitionInterval(uint8_t midambleRepetitionInterval) [member function]
cls.add_method('SetMidambleRepetitionInterval',
'void',
[param('uint8_t', 'midambleRepetitionInterval')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetStartTime(uint16_t startTime) [member function]
cls.add_method('SetStartTime',
'void',
[param('uint16_t', 'startTime')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetSubchannelIndex(uint8_t subchannelIndex) [member function]
cls.add_method('SetSubchannelIndex',
'void',
[param('uint8_t', 'subchannelIndex')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUlMapIe::SetUiuc(uint8_t uiuc) [member function]
cls.add_method('SetUiuc',
'void',
[param('uint8_t', 'uiuc')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUlMapIe::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
return
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]
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',
'void',
[param('ns3::PacketMetadata const &', 'o')])
## 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')])
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::AddPaddingAtEnd(uint32_t end) [member function]
cls.add_method('AddPaddingAtEnd',
'void',
[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('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',
[param('ns3::Buffer', 'buffer')],
is_const=True)
## 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')],
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')])
## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::Enable() [member function]
cls.add_method('Enable',
'void',
[],
is_static=True)
## packet-metadata.h (module 'network'): static void ns3::PacketMetadata::EnableChecking() [member function]
cls.add_method('EnableChecking',
'void',
[],
is_static=True)
## packet-metadata.h (module 'network'): uint32_t ns3::PacketMetadata::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## packet-metadata.h (module 'network'): uint64_t ns3::PacketMetadata::GetUid() const [member function]
cls.add_method('GetUid',
'uint64_t',
[],
is_const=True)
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtEnd(uint32_t end) [member function]
cls.add_method('RemoveAtEnd',
'void',
[param('uint32_t', 'end')])
## packet-metadata.h (module 'network'): void ns3::PacketMetadata::RemoveAtStart(uint32_t start) [member function]
cls.add_method('RemoveAtStart',
'void',
[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('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('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('uint32_t', '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]
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)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentSize [variable]
cls.add_instance_attribute('currentSize', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromEnd [variable]
cls.add_instance_attribute('currentTrimedFromEnd', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::currentTrimedFromStart [variable]
cls.add_instance_attribute('currentTrimedFromStart', 'uint32_t', is_const=False)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item::isFragment [variable]
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)
return
def register_Ns3PacketMetadataItemIterator_methods(root_module, cls):
## packet-metadata.h (module 'network'): ns3::PacketMetadata::ItemIterator::ItemIterator(ns3::PacketMetadata::ItemIterator const & arg0) [copy 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')])
## packet-metadata.h (module 'network'): bool ns3::PacketMetadata::ItemIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet-metadata.h (module 'network'): ns3::PacketMetadata::Item ns3::PacketMetadata::ItemIterator::Next() [member function]
cls.add_method('Next',
'ns3::PacketMetadata::Item',
[])
return
def register_Ns3PacketTagIterator_methods(root_module, cls):
## packet.h (module 'network'): ns3::PacketTagIterator::PacketTagIterator(ns3::PacketTagIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PacketTagIterator const &', 'arg0')])
## packet.h (module 'network'): bool ns3::PacketTagIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## packet.h (module 'network'): ns3::PacketTagIterator::Item ns3::PacketTagIterator::Next() [member function]
cls.add_method('Next',
'ns3::PacketTagIterator::Item',
[])
return
def register_Ns3PacketTagIteratorItem_methods(root_module, cls):
## packet.h (module 'network'): ns3::PacketTagIterator::Item::Item(ns3::PacketTagIterator::Item const & arg0) [copy 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',
'void',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::TypeId ns3::PacketTagIterator::Item::GetTypeId() const [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_const=True)
return
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]
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',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData const * ns3::PacketTagList::Head() const [member function]
cls.add_method('Head',
'ns3::PacketTagList::TagData const *',
[],
is_const=True)
## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Peek(ns3::Tag & tag) const [member function]
cls.add_method('Peek',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet-tag-list.h (module 'network'): bool ns3::PacketTagList::Remove(ns3::Tag & tag) [member function]
cls.add_method('Remove',
'bool',
[param('ns3::Tag &', 'tag')])
## packet-tag-list.h (module 'network'): void ns3::PacketTagList::RemoveAll() [member function]
cls.add_method('RemoveAll',
'void',
[])
return
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]
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)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::data [variable]
cls.add_instance_attribute('data', 'uint8_t [ 20 ]', is_const=False)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::next [variable]
cls.add_instance_attribute('next', 'ns3::PacketTagList::TagData *', is_const=False)
## packet-tag-list.h (module 'network'): ns3::PacketTagList::TagData::tid [variable]
cls.add_instance_attribute('tid', 'ns3::TypeId', is_const=False)
return
def register_Ns3PcapFile_methods(root_module, cls):
## pcap-file.h (module 'network'): ns3::PcapFile::PcapFile() [constructor]
cls.add_constructor([])
## pcap-file.h (module 'network'): void ns3::PcapFile::Clear() [member function]
cls.add_method('Clear',
'void',
[])
## pcap-file.h (module 'network'): void ns3::PcapFile::Close() [member function]
cls.add_method('Close',
'void',
[])
## 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 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', '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',
'bool',
[],
is_const=True)
## pcap-file.h (module 'network'): bool ns3::PcapFile::Fail() const [member function]
cls.add_method('Fail',
'bool',
[],
is_const=True)
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetDataLinkType() [member function]
cls.add_method('GetDataLinkType',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetMagic() [member function]
cls.add_method('GetMagic',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetSigFigs() [member function]
cls.add_method('GetSigFigs',
'uint32_t',
[])
## pcap-file.h (module 'network'): uint32_t ns3::PcapFile::GetSnapLen() [member function]
cls.add_method('GetSnapLen',
'uint32_t',
[])
## pcap-file.h (module 'network'): bool ns3::PcapFile::GetSwapMode() [member function]
cls.add_method('GetSwapMode',
'bool',
[])
## pcap-file.h (module 'network'): int32_t ns3::PcapFile::GetTimeZoneOffset() [member function]
cls.add_method('GetTimeZoneOffset',
'int32_t',
[])
## pcap-file.h (module 'network'): uint16_t ns3::PcapFile::GetVersionMajor() [member function]
cls.add_method('GetVersionMajor',
'uint16_t',
[])
## pcap-file.h (module 'network'): uint16_t ns3::PcapFile::GetVersionMinor() [member function]
cls.add_method('GetVersionMinor',
'uint16_t',
[])
## 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) [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')])
## pcap-file.h (module 'network'): void ns3::PcapFile::Open(std::string const & filename, std::_Ios_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')])
## 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<const ns3::Packet> 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 & header, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('Write',
'void',
[param('uint32_t', 'tsSec'), param('uint32_t', 'tsUsec'), param('ns3::Header &', '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]
cls.add_static_attribute('ZONE_DEFAULT', 'int32_t const', is_const=True)
return
def register_Ns3PcapHelper_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::PcapHelper::PcapHelper(ns3::PcapHelper const & arg0) [copy 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::PcapFileWrapper> ns3::PcapHelper::CreateFile(std::string filename, std::_Ios_Openmode filemode, uint32_t dataLinkType, uint32_t snapLen=65535, int32_t tzCorrection=0) [member function]
cls.add_method('CreateFile',
'ns3::Ptr< ns3::PcapFileWrapper >',
[param('std::string', 'filename'), param('std::_Ios_Openmode', 'filemode'), param('uint32_t', 'dataLinkType'), param('uint32_t', 'snapLen', default_value='65535'), param('int32_t', 'tzCorrection', default_value='0')])
## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromDevice(std::string prefix, ns3::Ptr<ns3::NetDevice> device, bool useObjectNames=true) [member function]
cls.add_method('GetFilenameFromDevice',
'std::string',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'device'), param('bool', 'useObjectNames', default_value='true')])
## trace-helper.h (module 'network'): std::string ns3::PcapHelper::GetFilenameFromInterfacePair(std::string prefix, ns3::Ptr<ns3::Object> 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')])
return
def register_Ns3PcapHelperForDevice_methods(root_module, cls):
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice(ns3::PcapHelperForDevice const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PcapHelperForDevice const &', 'arg0')])
## trace-helper.h (module 'network'): ns3::PcapHelperForDevice::PcapHelperForDevice() [constructor]
cls.add_constructor([])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous=false, bool explicitFilename=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous', default_value='false'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, std::string ndName, bool promiscuous=false, bool explicitFilename=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('std::string', 'ndName'), param('bool', 'promiscuous', default_value='false'), param('bool', 'explicitFilename', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::NetDeviceContainer d, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NetDeviceContainer', 'd'), param('bool', 'promiscuous', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcap(std::string prefix, ns3::NodeContainer n, bool promiscuous=false) [member function]
cls.add_method('EnablePcap',
'void',
[param('std::string', 'prefix'), param('ns3::NodeContainer', 'n'), param('bool', 'promiscuous', default_value='false')])
## 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')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapAll(std::string prefix, bool promiscuous=false) [member function]
cls.add_method('EnablePcapAll',
'void',
[param('std::string', 'prefix'), param('bool', 'promiscuous', default_value='false')])
## trace-helper.h (module 'network'): void ns3::PcapHelperForDevice::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool promiscuous, bool explicitFilename) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'promiscuous'), param('bool', 'explicitFilename')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3RandomVariable_methods(root_module, cls):
cls.add_output_stream_operator()
## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]
cls.add_constructor([param('ns3::RandomVariable const &', 'o')])
## random-variable.h (module 'core'): uint32_t ns3::RandomVariable::GetInteger() const [member function]
cls.add_method('GetInteger',
'uint32_t',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::RandomVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
return
def register_Ns3SNRToBlockErrorRateManager_methods(root_module, cls):
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager::SNRToBlockErrorRateManager(ns3::SNRToBlockErrorRateManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SNRToBlockErrorRateManager const &', 'arg0')])
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateManager::SNRToBlockErrorRateManager() [constructor]
cls.add_constructor([])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::ActivateLoss(bool loss) [member function]
cls.add_method('ActivateLoss',
'void',
[param('bool', 'loss')])
## snr-to-block-error-rate-manager.h (module 'wimax'): double ns3::SNRToBlockErrorRateManager::GetBlockErrorRate(double SNR, uint8_t modulation) [member function]
cls.add_method('GetBlockErrorRate',
'double',
[param('double', 'SNR'), param('uint8_t', 'modulation')])
## snr-to-block-error-rate-manager.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord * ns3::SNRToBlockErrorRateManager::GetSNRToBlockErrorRateRecord(double SNR, uint8_t modulation) [member function]
cls.add_method('GetSNRToBlockErrorRateRecord',
'ns3::SNRToBlockErrorRateRecord *',
[param('double', 'SNR'), param('uint8_t', 'modulation')])
## snr-to-block-error-rate-manager.h (module 'wimax'): std::string ns3::SNRToBlockErrorRateManager::GetTraceFilePath() [member function]
cls.add_method('GetTraceFilePath',
'std::string',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::LoadDefaultTraces() [member function]
cls.add_method('LoadDefaultTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::LoadTraces() [member function]
cls.add_method('LoadTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::ReLoadTraces() [member function]
cls.add_method('ReLoadTraces',
'void',
[])
## snr-to-block-error-rate-manager.h (module 'wimax'): void ns3::SNRToBlockErrorRateManager::SetTraceFilePath(char * traceFilePath) [member function]
cls.add_method('SetTraceFilePath',
'void',
[param('char *', 'traceFilePath')])
return
def register_Ns3SNRToBlockErrorRateRecord_methods(root_module, cls):
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord::SNRToBlockErrorRateRecord(ns3::SNRToBlockErrorRateRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SNRToBlockErrorRateRecord const &', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord::SNRToBlockErrorRateRecord(double snrValue, double bitErrorRate, double BlockErrorRate, double sigma2, double I1, double I2) [constructor]
cls.add_constructor([param('double', 'snrValue'), param('double', 'bitErrorRate'), param('double', 'BlockErrorRate'), param('double', 'sigma2'), param('double', 'I1'), param('double', 'I2')])
## snr-to-block-error-rate-record.h (module 'wimax'): ns3::SNRToBlockErrorRateRecord * ns3::SNRToBlockErrorRateRecord::Copy() [member function]
cls.add_method('Copy',
'ns3::SNRToBlockErrorRateRecord *',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetBitErrorRate() [member function]
cls.add_method('GetBitErrorRate',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetBlockErrorRate() [member function]
cls.add_method('GetBlockErrorRate',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetI1() [member function]
cls.add_method('GetI1',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetI2() [member function]
cls.add_method('GetI2',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetSNRValue() [member function]
cls.add_method('GetSNRValue',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): double ns3::SNRToBlockErrorRateRecord::GetSigma2() [member function]
cls.add_method('GetSigma2',
'double',
[])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetBitErrorRate(double arg0) [member function]
cls.add_method('SetBitErrorRate',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetBlockErrorRate(double arg0) [member function]
cls.add_method('SetBlockErrorRate',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetI1(double arg0) [member function]
cls.add_method('SetI1',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetI2(double arg0) [member function]
cls.add_method('SetI2',
'void',
[param('double', 'arg0')])
## snr-to-block-error-rate-record.h (module 'wimax'): void ns3::SNRToBlockErrorRateRecord::SetSNRValue(double arg0) [member function]
cls.add_method('SetSNRValue',
'void',
[param('double', 'arg0')])
return
def register_Ns3SSRecord_methods(root_module, cls):
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::SSRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SSRecord const &', 'arg0')])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord() [constructor]
cls.add_constructor([])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::Mac48Address macAddress) [constructor]
cls.add_constructor([param('ns3::Mac48Address', 'macAddress')])
## ss-record.h (module 'wimax'): ns3::SSRecord::SSRecord(ns3::Mac48Address macAddress, ns3::Ipv4Address IPaddress) [constructor]
cls.add_constructor([param('ns3::Mac48Address', 'macAddress'), param('ns3::Ipv4Address', 'IPaddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::DisablePollForRanging() [member function]
cls.add_method('DisablePollForRanging',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::EnablePollForRanging() [member function]
cls.add_method('EnablePollForRanging',
'void',
[])
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetAreServiceFlowsAllocated() const [member function]
cls.add_method('GetAreServiceFlowsAllocated',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Cid ns3::SSRecord::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::DsaRsp ns3::SSRecord::GetDsaRsp() const [member function]
cls.add_method('GetDsaRsp',
'ns3::DsaRsp',
[],
is_const=True)
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetDsaRspRetries() const [member function]
cls.add_method('GetDsaRspRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowBe() const [member function]
cls.add_method('GetHasServiceFlowBe',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowNrtps() const [member function]
cls.add_method('GetHasServiceFlowNrtps',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowRtps() const [member function]
cls.add_method('GetHasServiceFlowRtps',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetHasServiceFlowUgs() const [member function]
cls.add_method('GetHasServiceFlowUgs',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Ipv4Address ns3::SSRecord::GetIPAddress() [member function]
cls.add_method('GetIPAddress',
'ns3::Ipv4Address',
[])
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetInvitedRangRetries() const [member function]
cls.add_method('GetInvitedRangRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetIsBroadcastSS() [member function]
cls.add_method('GetIsBroadcastSS',
'bool',
[])
## ss-record.h (module 'wimax'): ns3::Mac48Address ns3::SSRecord::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::SSRecord::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetPollForRanging() const [member function]
cls.add_method('GetPollForRanging',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): bool ns3::SSRecord::GetPollMeBit() const [member function]
cls.add_method('GetPollMeBit',
'bool',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::Cid ns3::SSRecord::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## ss-record.h (module 'wimax'): uint8_t ns3::SSRecord::GetRangingCorrectionRetries() const [member function]
cls.add_method('GetRangingCorrectionRetries',
'uint8_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): ns3::WimaxNetDevice::RangingStatus ns3::SSRecord::GetRangingStatus() const [member function]
cls.add_method('GetRangingStatus',
'ns3::WimaxNetDevice::RangingStatus',
[],
is_const=True)
## ss-record.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::SSRecord::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## ss-record.h (module 'wimax'): uint16_t ns3::SSRecord::GetSfTransactionId() const [member function]
cls.add_method('GetSfTransactionId',
'uint16_t',
[],
is_const=True)
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementDsaRspRetries() [member function]
cls.add_method('IncrementDsaRspRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementInvitedRangingRetries() [member function]
cls.add_method('IncrementInvitedRangingRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::IncrementRangingCorrectionRetries() [member function]
cls.add_method('IncrementRangingCorrectionRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::ResetInvitedRangingRetries() [member function]
cls.add_method('ResetInvitedRangingRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::ResetRangingCorrectionRetries() [member function]
cls.add_method('ResetRangingCorrectionRetries',
'void',
[])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetAreServiceFlowsAllocated(bool val) [member function]
cls.add_method('SetAreServiceFlowsAllocated',
'void',
[param('bool', 'val')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetBasicCid(ns3::Cid basicCid) [member function]
cls.add_method('SetBasicCid',
'void',
[param('ns3::Cid', 'basicCid')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetDsaRsp(ns3::DsaRsp dsaRsp) [member function]
cls.add_method('SetDsaRsp',
'void',
[param('ns3::DsaRsp', 'dsaRsp')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetDsaRspRetries(uint8_t dsaRspRetries) [member function]
cls.add_method('SetDsaRspRetries',
'void',
[param('uint8_t', 'dsaRspRetries')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetIPAddress(ns3::Ipv4Address IPaddress) [member function]
cls.add_method('SetIPAddress',
'void',
[param('ns3::Ipv4Address', 'IPaddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetIsBroadcastSS(bool arg0) [member function]
cls.add_method('SetIsBroadcastSS',
'void',
[param('bool', 'arg0')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetPollMeBit(bool pollMeBit) [member function]
cls.add_method('SetPollMeBit',
'void',
[param('bool', 'pollMeBit')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetPrimaryCid(ns3::Cid primaryCid) [member function]
cls.add_method('SetPrimaryCid',
'void',
[param('ns3::Cid', 'primaryCid')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetRangingStatus(ns3::WimaxNetDevice::RangingStatus rangingStatus) [member function]
cls.add_method('SetRangingStatus',
'void',
[param('ns3::WimaxNetDevice::RangingStatus', 'rangingStatus')])
## ss-record.h (module 'wimax'): void ns3::SSRecord::SetSfTransactionId(uint16_t sfTransactionId) [member function]
cls.add_method('SetSfTransactionId',
'void',
[param('uint16_t', 'sfTransactionId')])
return
def register_Ns3SeedManager_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::SeedManager::SeedManager() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SeedManager const &', 'arg0')])
## random-variable.h (module 'core'): static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]
cls.add_method('CheckSeed',
'bool',
[param('uint32_t', 'seed')],
is_static=True)
## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetRun() [member function]
cls.add_method('GetRun',
'uint32_t',
[],
is_static=True)
## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetSeed() [member function]
cls.add_method('GetSeed',
'uint32_t',
[],
is_static=True)
## random-variable.h (module 'core'): static void ns3::SeedManager::SetRun(uint32_t run) [member function]
cls.add_method('SetRun',
'void',
[param('uint32_t', 'run')],
is_static=True)
## random-variable.h (module 'core'): static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]
cls.add_method('SetSeed',
'void',
[param('uint32_t', 'seed')],
is_static=True)
return
def register_Ns3SendParams_methods(root_module, cls):
## send-params.h (module 'wimax'): ns3::SendParams::SendParams(ns3::SendParams const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SendParams const &', 'arg0')])
## send-params.h (module 'wimax'): ns3::SendParams::SendParams() [constructor]
cls.add_constructor([])
return
def register_Ns3SequentialVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SequentialVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]
cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])
## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]
cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])
return
def register_Ns3ServiceFlow_methods(root_module, cls):
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::Tlv tlv) [constructor]
cls.add_constructor([param('ns3::Tlv', 'tlv')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::ServiceFlow::Direction direction) [constructor]
cls.add_constructor([param('ns3::ServiceFlow::Direction', 'direction')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow() [constructor]
cls.add_constructor([])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(ns3::ServiceFlow const & sf) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlow const &', 'sf')])
## service-flow.h (module 'wimax'): ns3::ServiceFlow::ServiceFlow(uint32_t sfid, ns3::ServiceFlow::Direction direction, ns3::Ptr<ns3::WimaxConnection> connection) [constructor]
cls.add_constructor([param('uint32_t', 'sfid'), param('ns3::ServiceFlow::Direction', 'direction'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')])
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::CheckClassifierMatch(ns3::Ipv4Address srcAddress, ns3::Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const [member function]
cls.add_method('CheckClassifierMatch',
'bool',
[param('ns3::Ipv4Address', 'srcAddress'), param('ns3::Ipv4Address', 'dstAddress'), param('uint16_t', 'srcPort'), param('uint16_t', 'dstPort'), param('uint8_t', 'proto')],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::CleanUpQueue() [member function]
cls.add_method('CleanUpQueue',
'void',
[])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::CopyParametersFrom(ns3::ServiceFlow sf) [member function]
cls.add_method('CopyParametersFrom',
'void',
[param('ns3::ServiceFlow', 'sf')])
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqBlockLifeTime() const [member function]
cls.add_method('GetArqBlockLifeTime',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqBlockSize() const [member function]
cls.add_method('GetArqBlockSize',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetArqDeliverInOrder() const [member function]
cls.add_method('GetArqDeliverInOrder',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetArqEnable() const [member function]
cls.add_method('GetArqEnable',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqPurgeTimeout() const [member function]
cls.add_method('GetArqPurgeTimeout',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqRetryTimeoutRx() const [member function]
cls.add_method('GetArqRetryTimeoutRx',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqRetryTimeoutTx() const [member function]
cls.add_method('GetArqRetryTimeoutTx',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqSyncLoss() const [member function]
cls.add_method('GetArqSyncLoss',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetArqWindowSize() const [member function]
cls.add_method('GetArqWindowSize',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetCid() const [member function]
cls.add_method('GetCid',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ServiceFlow::GetConnection() const [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::CsParameters ns3::ServiceFlow::GetConvergenceSublayerParam() const [member function]
cls.add_method('GetConvergenceSublayerParam',
'ns3::CsParameters',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::CsSpecification ns3::ServiceFlow::GetCsSpecification() const [member function]
cls.add_method('GetCsSpecification',
'ns3::ServiceFlow::CsSpecification',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Direction ns3::ServiceFlow::GetDirection() const [member function]
cls.add_method('GetDirection',
'ns3::ServiceFlow::Direction',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetFixedversusVariableSduIndicator() const [member function]
cls.add_method('GetFixedversusVariableSduIndicator',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::GetIsEnabled() const [member function]
cls.add_method('GetIsEnabled',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::GetIsMulticast() const [member function]
cls.add_method('GetIsMulticast',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaxSustainedTrafficRate() const [member function]
cls.add_method('GetMaxSustainedTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaxTrafficBurst() const [member function]
cls.add_method('GetMaxTrafficBurst',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMaximumLatency() const [member function]
cls.add_method('GetMaximumLatency',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMinReservedTrafficRate() const [member function]
cls.add_method('GetMinReservedTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetMinTolerableTrafficRate() const [member function]
cls.add_method('GetMinTolerableTrafficRate',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::ServiceFlow::GetModulation() const [member function]
cls.add_method('GetModulation',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetQosParamSetType() const [member function]
cls.add_method('GetQosParamSetType',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::Ptr<ns3::WimaxMacQueue> ns3::ServiceFlow::GetQueue() const [member function]
cls.add_method('GetQueue',
'ns3::Ptr< ns3::WimaxMacQueue >',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlowRecord * ns3::ServiceFlow::GetRecord() const [member function]
cls.add_method('GetRecord',
'ns3::ServiceFlowRecord *',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetRequestTransmissionPolicy() const [member function]
cls.add_method('GetRequestTransmissionPolicy',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::ServiceFlow::GetSchedulingType() const [member function]
cls.add_method('GetSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[],
is_const=True)
## service-flow.h (module 'wimax'): char * ns3::ServiceFlow::GetSchedulingTypeStr() const [member function]
cls.add_method('GetSchedulingTypeStr',
'char *',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetSduSize() const [member function]
cls.add_method('GetSduSize',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): std::string ns3::ServiceFlow::GetServiceClassName() const [member function]
cls.add_method('GetServiceClassName',
'std::string',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::ServiceFlow::GetServiceSchedulingType() const [member function]
cls.add_method('GetServiceSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetTargetSAID() const [member function]
cls.add_method('GetTargetSAID',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint32_t ns3::ServiceFlow::GetToleratedJitter() const [member function]
cls.add_method('GetToleratedJitter',
'uint32_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint8_t ns3::ServiceFlow::GetTrafficPriority() const [member function]
cls.add_method('GetTrafficPriority',
'uint8_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): ns3::ServiceFlow::Type ns3::ServiceFlow::GetType() const [member function]
cls.add_method('GetType',
'ns3::ServiceFlow::Type',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetUnsolicitedGrantInterval() const [member function]
cls.add_method('GetUnsolicitedGrantInterval',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): uint16_t ns3::ServiceFlow::GetUnsolicitedPollingInterval() const [member function]
cls.add_method('GetUnsolicitedPollingInterval',
'uint16_t',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## service-flow.h (module 'wimax'): bool ns3::ServiceFlow::HasPackets(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('HasPackets',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::InitValues() [member function]
cls.add_method('InitValues',
'void',
[])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::PrintQoSParameters() const [member function]
cls.add_method('PrintQoSParameters',
'void',
[],
is_const=True)
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqBlockLifeTime(uint16_t arg0) [member function]
cls.add_method('SetArqBlockLifeTime',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqBlockSize(uint16_t arg0) [member function]
cls.add_method('SetArqBlockSize',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqDeliverInOrder(uint8_t arg0) [member function]
cls.add_method('SetArqDeliverInOrder',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqEnable(uint8_t arg0) [member function]
cls.add_method('SetArqEnable',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqPurgeTimeout(uint16_t arg0) [member function]
cls.add_method('SetArqPurgeTimeout',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqRetryTimeoutRx(uint16_t arg0) [member function]
cls.add_method('SetArqRetryTimeoutRx',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqRetryTimeoutTx(uint16_t arg0) [member function]
cls.add_method('SetArqRetryTimeoutTx',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqSyncLoss(uint16_t arg0) [member function]
cls.add_method('SetArqSyncLoss',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetArqWindowSize(uint16_t arg0) [member function]
cls.add_method('SetArqWindowSize',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetConnection(ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('SetConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetConvergenceSublayerParam(ns3::CsParameters arg0) [member function]
cls.add_method('SetConvergenceSublayerParam',
'void',
[param('ns3::CsParameters', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetCsSpecification(ns3::ServiceFlow::CsSpecification arg0) [member function]
cls.add_method('SetCsSpecification',
'void',
[param('ns3::ServiceFlow::CsSpecification', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetDirection(ns3::ServiceFlow::Direction direction) [member function]
cls.add_method('SetDirection',
'void',
[param('ns3::ServiceFlow::Direction', 'direction')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetFixedversusVariableSduIndicator(uint8_t arg0) [member function]
cls.add_method('SetFixedversusVariableSduIndicator',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetIsEnabled(bool isEnabled) [member function]
cls.add_method('SetIsEnabled',
'void',
[param('bool', 'isEnabled')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetIsMulticast(bool isMulticast) [member function]
cls.add_method('SetIsMulticast',
'void',
[param('bool', 'isMulticast')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaxSustainedTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMaxSustainedTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaxTrafficBurst(uint32_t arg0) [member function]
cls.add_method('SetMaxTrafficBurst',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMaximumLatency(uint32_t arg0) [member function]
cls.add_method('SetMaximumLatency',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMinReservedTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMinReservedTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetMinTolerableTrafficRate(uint32_t arg0) [member function]
cls.add_method('SetMinTolerableTrafficRate',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetModulation(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulation',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetQosParamSetType(uint8_t arg0) [member function]
cls.add_method('SetQosParamSetType',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetRecord(ns3::ServiceFlowRecord * record) [member function]
cls.add_method('SetRecord',
'void',
[param('ns3::ServiceFlowRecord *', 'record')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetRequestTransmissionPolicy(uint32_t arg0) [member function]
cls.add_method('SetRequestTransmissionPolicy',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetSduSize(uint8_t arg0) [member function]
cls.add_method('SetSduSize',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetServiceClassName(std::string arg0) [member function]
cls.add_method('SetServiceClassName',
'void',
[param('std::string', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetServiceSchedulingType(ns3::ServiceFlow::SchedulingType arg0) [member function]
cls.add_method('SetServiceSchedulingType',
'void',
[param('ns3::ServiceFlow::SchedulingType', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetSfid(uint32_t arg0) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetTargetSAID(uint16_t arg0) [member function]
cls.add_method('SetTargetSAID',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetToleratedJitter(uint32_t arg0) [member function]
cls.add_method('SetToleratedJitter',
'void',
[param('uint32_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetTrafficPriority(uint8_t arg0) [member function]
cls.add_method('SetTrafficPriority',
'void',
[param('uint8_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetType(ns3::ServiceFlow::Type type) [member function]
cls.add_method('SetType',
'void',
[param('ns3::ServiceFlow::Type', 'type')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetUnsolicitedGrantInterval(uint16_t arg0) [member function]
cls.add_method('SetUnsolicitedGrantInterval',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): void ns3::ServiceFlow::SetUnsolicitedPollingInterval(uint16_t arg0) [member function]
cls.add_method('SetUnsolicitedPollingInterval',
'void',
[param('uint16_t', 'arg0')])
## service-flow.h (module 'wimax'): ns3::Tlv ns3::ServiceFlow::ToTlv() const [member function]
cls.add_method('ToTlv',
'ns3::Tlv',
[],
is_const=True)
return
def register_Ns3ServiceFlowRecord_methods(root_module, cls):
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord::ServiceFlowRecord(ns3::ServiceFlowRecord const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlowRecord const &', 'arg0')])
## service-flow-record.h (module 'wimax'): ns3::ServiceFlowRecord::ServiceFlowRecord() [constructor]
cls.add_constructor([])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBacklogged() const [member function]
cls.add_method('GetBacklogged',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBackloggedTemp() const [member function]
cls.add_method('GetBackloggedTemp',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBwSinceLastExpiry() [member function]
cls.add_method('GetBwSinceLastExpiry',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBytesRcvd() const [member function]
cls.add_method('GetBytesRcvd',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetBytesSent() const [member function]
cls.add_method('GetBytesSent',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetDlTimeStamp() const [member function]
cls.add_method('GetDlTimeStamp',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantSize() const [member function]
cls.add_method('GetGrantSize',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetGrantTimeStamp() const [member function]
cls.add_method('GetGrantTimeStamp',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantedBandwidth() [member function]
cls.add_method('GetGrantedBandwidth',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetGrantedBandwidthTemp() [member function]
cls.add_method('GetGrantedBandwidthTemp',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): ns3::Time ns3::ServiceFlowRecord::GetLastGrantTime() const [member function]
cls.add_method('GetLastGrantTime',
'ns3::Time',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetPktsRcvd() const [member function]
cls.add_method('GetPktsRcvd',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetPktsSent() const [member function]
cls.add_method('GetPktsSent',
'uint32_t',
[],
is_const=True)
## service-flow-record.h (module 'wimax'): uint32_t ns3::ServiceFlowRecord::GetRequestedBandwidth() [member function]
cls.add_method('GetRequestedBandwidth',
'uint32_t',
[])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::IncreaseBacklogged(uint32_t backlogged) [member function]
cls.add_method('IncreaseBacklogged',
'void',
[param('uint32_t', 'backlogged')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::IncreaseBackloggedTemp(uint32_t backloggedTemp) [member function]
cls.add_method('IncreaseBackloggedTemp',
'void',
[param('uint32_t', 'backloggedTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBacklogged(uint32_t backlogged) [member function]
cls.add_method('SetBacklogged',
'void',
[param('uint32_t', 'backlogged')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBackloggedTemp(uint32_t backloggedTemp) [member function]
cls.add_method('SetBackloggedTemp',
'void',
[param('uint32_t', 'backloggedTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBwSinceLastExpiry(uint32_t bwSinceLastExpiry) [member function]
cls.add_method('SetBwSinceLastExpiry',
'void',
[param('uint32_t', 'bwSinceLastExpiry')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBytesRcvd(uint32_t bytesRcvd) [member function]
cls.add_method('SetBytesRcvd',
'void',
[param('uint32_t', 'bytesRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetBytesSent(uint32_t bytesSent) [member function]
cls.add_method('SetBytesSent',
'void',
[param('uint32_t', 'bytesSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetDlTimeStamp(ns3::Time dlTimeStamp) [member function]
cls.add_method('SetDlTimeStamp',
'void',
[param('ns3::Time', 'dlTimeStamp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantSize(uint32_t grantSize) [member function]
cls.add_method('SetGrantSize',
'void',
[param('uint32_t', 'grantSize')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantTimeStamp(ns3::Time grantTimeStamp) [member function]
cls.add_method('SetGrantTimeStamp',
'void',
[param('ns3::Time', 'grantTimeStamp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantedBandwidth(uint32_t grantedBandwidth) [member function]
cls.add_method('SetGrantedBandwidth',
'void',
[param('uint32_t', 'grantedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetGrantedBandwidthTemp(uint32_t grantedBandwidthTemp) [member function]
cls.add_method('SetGrantedBandwidthTemp',
'void',
[param('uint32_t', 'grantedBandwidthTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetLastGrantTime(ns3::Time grantTime) [member function]
cls.add_method('SetLastGrantTime',
'void',
[param('ns3::Time', 'grantTime')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetPktsRcvd(uint32_t pktsRcvd) [member function]
cls.add_method('SetPktsRcvd',
'void',
[param('uint32_t', 'pktsRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetPktsSent(uint32_t pktsSent) [member function]
cls.add_method('SetPktsSent',
'void',
[param('uint32_t', 'pktsSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::SetRequestedBandwidth(uint32_t requestedBandwidth) [member function]
cls.add_method('SetRequestedBandwidth',
'void',
[param('uint32_t', 'requestedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBwSinceLastExpiry(uint32_t bwSinceLastExpiry) [member function]
cls.add_method('UpdateBwSinceLastExpiry',
'void',
[param('uint32_t', 'bwSinceLastExpiry')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBytesRcvd(uint32_t bytesRcvd) [member function]
cls.add_method('UpdateBytesRcvd',
'void',
[param('uint32_t', 'bytesRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateBytesSent(uint32_t bytesSent) [member function]
cls.add_method('UpdateBytesSent',
'void',
[param('uint32_t', 'bytesSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateGrantedBandwidth(uint32_t grantedBandwidth) [member function]
cls.add_method('UpdateGrantedBandwidth',
'void',
[param('uint32_t', 'grantedBandwidth')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateGrantedBandwidthTemp(uint32_t grantedBandwidthTemp) [member function]
cls.add_method('UpdateGrantedBandwidthTemp',
'void',
[param('uint32_t', 'grantedBandwidthTemp')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdatePktsRcvd(uint32_t pktsRcvd) [member function]
cls.add_method('UpdatePktsRcvd',
'void',
[param('uint32_t', 'pktsRcvd')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdatePktsSent(uint32_t pktsSent) [member function]
cls.add_method('UpdatePktsSent',
'void',
[param('uint32_t', 'pktsSent')])
## service-flow-record.h (module 'wimax'): void ns3::ServiceFlowRecord::UpdateRequestedBandwidth(uint32_t requestedBandwidth) [member function]
cls.add_method('UpdateRequestedBandwidth',
'void',
[param('uint32_t', 'requestedBandwidth')])
return
def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount(ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> const & o) [copy 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<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3Simulator_methods(root_module, cls):
## simulator.h (module 'core'): ns3::Simulator::Simulator(ns3::Simulator const & arg0) [copy 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',
'void',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Destroy() [member function]
cls.add_method('Destroy',
'void',
[],
is_static=True)
## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetContext() [member function]
cls.add_method('GetContext',
'uint32_t',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetDelayLeft(ns3::EventId const & id) [member function]
cls.add_method('GetDelayLeft',
'ns3::Time',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static ns3::Ptr<ns3::SimulatorImpl> ns3::Simulator::GetImplementation() [member function]
cls.add_method('GetImplementation',
'ns3::Ptr< ns3::SimulatorImpl >',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::GetMaximumSimulationTime() [member function]
cls.add_method('GetMaximumSimulationTime',
'ns3::Time',
[],
is_static=True)
## simulator.h (module 'core'): static uint32_t ns3::Simulator::GetSystemId() [member function]
cls.add_method('GetSystemId',
'uint32_t',
[],
is_static=True)
## simulator.h (module 'core'): static bool ns3::Simulator::IsExpired(ns3::EventId const & id) [member function]
cls.add_method('IsExpired',
'bool',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static bool ns3::Simulator::IsFinished() [member function]
cls.add_method('IsFinished',
'bool',
[],
is_static=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Next() [member function]
cls.add_method('Next',
'ns3::Time',
[],
is_static=True, deprecated=True)
## simulator.h (module 'core'): static ns3::Time ns3::Simulator::Now() [member function]
cls.add_method('Now',
'ns3::Time',
[],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Remove(ns3::EventId const & id) [member function]
cls.add_method('Remove',
'void',
[param('ns3::EventId const &', 'id')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::RunOneEvent() [member function]
cls.add_method('RunOneEvent',
'void',
[],
is_static=True, deprecated=True)
## simulator.h (module 'core'): static void ns3::Simulator::SetImplementation(ns3::Ptr<ns3::SimulatorImpl> impl) [member function]
cls.add_method('SetImplementation',
'void',
[param('ns3::Ptr< ns3::SimulatorImpl >', 'impl')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::SetScheduler(ns3::ObjectFactory schedulerFactory) [member function]
cls.add_method('SetScheduler',
'void',
[param('ns3::ObjectFactory', 'schedulerFactory')],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_static=True)
## simulator.h (module 'core'): static void ns3::Simulator::Stop(ns3::Time const & time) [member function]
cls.add_method('Stop',
'void',
[param('ns3::Time const &', 'time')],
is_static=True)
return
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]
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',
'void',
[param('ns3::TagBuffer', 'i')],
is_pure_virtual=True, is_virtual=True)
## tag.h (module 'network'): uint32_t ns3::Tag::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## tag.h (module 'network'): static ns3::TypeId ns3::Tag::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## tag.h (module 'network'): void ns3::Tag::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## tag.h (module 'network'): void ns3::Tag::Serialize(ns3::TagBuffer i) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::TagBuffer', 'i')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TagBuffer_methods(root_module, cls):
## tag-buffer.h (module 'network'): ns3::TagBuffer::TagBuffer(ns3::TagBuffer const & arg0) [copy 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')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::CopyFrom(ns3::TagBuffer o) [member function]
cls.add_method('CopyFrom',
'void',
[param('ns3::TagBuffer', 'o')])
## 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')])
## tag-buffer.h (module 'network'): double ns3::TagBuffer::ReadDouble() [member function]
cls.add_method('ReadDouble',
'double',
[])
## tag-buffer.h (module 'network'): uint16_t ns3::TagBuffer::ReadU16() [member function]
cls.add_method('ReadU16',
'uint16_t',
[])
## tag-buffer.h (module 'network'): uint32_t ns3::TagBuffer::ReadU32() [member function]
cls.add_method('ReadU32',
'uint32_t',
[])
## tag-buffer.h (module 'network'): uint64_t ns3::TagBuffer::ReadU64() [member function]
cls.add_method('ReadU64',
'uint64_t',
[])
## tag-buffer.h (module 'network'): uint8_t ns3::TagBuffer::ReadU8() [member function]
cls.add_method('ReadU8',
'uint8_t',
[])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::TrimAtEnd(uint32_t trim) [member function]
cls.add_method('TrimAtEnd',
'void',
[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('uint32_t', '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]
cls.add_method('WriteU16',
'void',
[param('uint16_t', 'data')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU32(uint32_t data) [member function]
cls.add_method('WriteU32',
'void',
[param('uint32_t', 'data')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU64(uint64_t v) [member function]
cls.add_method('WriteU64',
'void',
[param('uint64_t', 'v')])
## tag-buffer.h (module 'network'): void ns3::TagBuffer::WriteU8(uint8_t v) [member function]
cls.add_method('WriteU8',
'void',
[param('uint8_t', 'v')])
return
def register_Ns3TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::TlvValue::TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::TlvValue::TlvValue(ns3::TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::TlvValue *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_pure_virtual=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TosTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue(ns3::TosTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TosTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue::TosTlvValue(uint8_t arg0, uint8_t arg1, uint8_t arg2) [constructor]
cls.add_constructor([param('uint8_t', 'arg0'), param('uint8_t', 'arg1'), param('uint8_t', 'arg2')])
## wimax-tlv.h (module 'wimax'): ns3::TosTlvValue * ns3::TosTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::TosTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TosTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetHigh() const [member function]
cls.add_method('GetHigh',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetLow() const [member function]
cls.add_method('GetLow',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::TosTlvValue::GetMask() const [member function]
cls.add_method('GetMask',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::TosTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::TosTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3TriangularVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TriangularVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]
cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])
return
def register_Ns3TypeId_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_binary_comparison_operator('<')
cls.add_output_stream_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]
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<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [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')])
## 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<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [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')])
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddTraceSource(std::string name, std::string help, ns3::Ptr<ns3::TraceSourceAccessor const> accessor) [member function]
cls.add_method('AddTraceSource',
'ns3::TypeId',
[param('std::string', 'name'), param('std::string', 'help'), param('ns3::Ptr< ns3::TraceSourceAccessor const >', 'accessor')])
## 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')],
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')],
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::ObjectBase*,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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 >',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeId::GetGroupName() const [member function]
cls.add_method('GetGroupName',
'std::string',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeId::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::GetParent() const [member function]
cls.add_method('GetParent',
'ns3::TypeId',
[],
is_const=True)
## 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')],
is_static=True)
## type-id.h (module 'core'): static uint32_t ns3::TypeId::GetRegisteredN() [member function]
cls.add_method('GetRegisteredN',
'uint32_t',
[],
is_static=True)
## 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')],
is_const=True)
## type-id.h (module 'core'): uint32_t ns3::TypeId::GetTraceSourceN() const [member function]
cls.add_method('GetTraceSourceN',
'uint32_t',
[],
is_const=True)
## type-id.h (module 'core'): uint16_t ns3::TypeId::GetUid() const [member function]
cls.add_method('GetUid',
'uint16_t',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::HasConstructor() const [member function]
cls.add_method('HasConstructor',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::HasParent() const [member function]
cls.add_method('HasParent',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::HideFromDocumentation() [member function]
cls.add_method('HideFromDocumentation',
'ns3::TypeId',
[])
## type-id.h (module 'core'): bool ns3::TypeId::IsChildOf(ns3::TypeId other) const [member function]
cls.add_method('IsChildOf',
'bool',
[param('ns3::TypeId', 'other')],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::LookupAttributeByName(std::string name, ns3::TypeId::AttributeInformation * info) const [member function]
cls.add_method('LookupAttributeByName',
'bool',
[param('std::string', 'name'), param('ns3::TypeId::AttributeInformation *', 'info')],
is_const=True)
## type-id.h (module 'core'): static ns3::TypeId ns3::TypeId::LookupByName(std::string name) [member function]
cls.add_method('LookupByName',
'ns3::TypeId',
[param('std::string', 'name')],
is_static=True)
## type-id.h (module 'core'): ns3::Ptr<ns3::TraceSourceAccessor const> 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'): bool ns3::TypeId::MustHideFromDocumentation() const [member function]
cls.add_method('MustHideFromDocumentation',
'bool',
[],
is_const=True)
## type-id.h (module 'core'): bool ns3::TypeId::SetAttributeInitialValue(uint32_t i, ns3::Ptr<ns3::AttributeValue const> initialValue) [member function]
cls.add_method('SetAttributeInitialValue',
'bool',
[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',
[param('std::string', 'groupName')])
## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::SetParent(ns3::TypeId tid) [member function]
cls.add_method('SetParent',
'ns3::TypeId',
[param('ns3::TypeId', 'tid')])
## type-id.h (module 'core'): void ns3::TypeId::SetUid(uint16_t tid) [member function]
cls.add_method('SetUid',
'void',
[param('uint16_t', 'tid')])
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]
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)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::initialValue [variable]
cls.add_instance_attribute('initialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::AttributeInformation::originalInitialValue [variable]
cls.add_instance_attribute('originalInitialValue', 'ns3::Ptr< ns3::AttributeValue const >', is_const=False)
return
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]
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)
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::help [variable]
cls.add_instance_attribute('help', 'std::string', is_const=False)
## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation::name [variable]
cls.add_instance_attribute('name', 'std::string', is_const=False)
return
def register_Ns3U16TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue(ns3::U16TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U16TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue(uint16_t value) [constructor]
cls.add_constructor([param('uint16_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue::U16TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U16TlvValue * ns3::U16TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U16TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U16TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint16_t ns3::U16TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint16_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U16TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3U32TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue(ns3::U32TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U32TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue(uint32_t value) [constructor]
cls.add_constructor([param('uint32_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue::U32TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U32TlvValue * ns3::U32TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U32TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U32TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint32_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U32TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3U8TlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue(ns3::U8TlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::U8TlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue(uint8_t value) [constructor]
cls.add_constructor([param('uint8_t', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue::U8TlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::U8TlvValue * ns3::U8TlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::U8TlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLen) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLen')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')])
## wimax-tlv.h (module 'wimax'): uint32_t ns3::U8TlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::U8TlvValue::GetValue() const [member function]
cls.add_method('GetValue',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): void ns3::U8TlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3UcdChannelEncodings_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings::UcdChannelEncodings(ns3::UcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UcdChannelEncodings const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::UcdChannelEncodings::UcdChannelEncodings() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetBwReqOppSize() const [member function]
cls.add_method('GetBwReqOppSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UcdChannelEncodings::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetRangReqOppSize() const [member function]
cls.add_method('GetRangReqOppSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::UcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::Read(ns3::Buffer::Iterator start) [member function]
cls.add_method('Read',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetBwReqOppSize(uint16_t bwReqOppSize) [member function]
cls.add_method('SetBwReqOppSize',
'void',
[param('uint16_t', 'bwReqOppSize')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## ul-mac-messages.h (module 'wimax'): void ns3::UcdChannelEncodings::SetRangReqOppSize(uint16_t rangReqOppSize) [member function]
cls.add_method('SetRangReqOppSize',
'void',
[param('uint16_t', 'rangReqOppSize')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::Write(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Write',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::UcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3UniformVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(ns3::UniformVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UniformVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::UniformVariable::UniformVariable(double s, double l) [constructor]
cls.add_constructor([param('double', 's'), param('double', 'l')])
## random-variable.h (module 'core'): uint32_t ns3::UniformVariable::GetInteger(uint32_t s, uint32_t l) [member function]
cls.add_method('GetInteger',
'uint32_t',
[param('uint32_t', 's'), param('uint32_t', 'l')])
## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::UniformVariable::GetValue(double s, double l) [member function]
cls.add_method('GetValue',
'double',
[param('double', 's'), param('double', 'l')])
return
def register_Ns3VectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue::VectorTlvValue(ns3::VectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::VectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue::VectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::VectorTlvValue::Add(ns3::Tlv const & val) [member function]
cls.add_method('Add',
'void',
[param('ns3::Tlv const &', 'val')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<ns3::Tlv* const*,std::vector<ns3::Tlv*, std::allocator<ns3::Tlv*> > > ns3::VectorTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::Tlv * const *, std::vector< ns3::Tlv * > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::VectorTlvValue * ns3::VectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::VectorTlvValue *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::VectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_pure_virtual=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<ns3::Tlv* const*,std::vector<ns3::Tlv*, std::allocator<ns3::Tlv*> > > ns3::VectorTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::Tlv * const *, std::vector< ns3::Tlv * > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::VectorTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::VectorTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3WeibullVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(ns3::WeibullVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WeibullVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's')])
## random-variable.h (module 'core'): ns3::WeibullVariable::WeibullVariable(double m, double s, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
return
def register_Ns3WimaxHelper_methods(root_module, cls):
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::WimaxHelper(ns3::WimaxHelper const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxHelper const &', 'arg0')])
## wimax-helper.h (module 'wimax'): ns3::WimaxHelper::WimaxHelper() [constructor]
cls.add_constructor([])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::BSScheduler> ns3::WimaxHelper::CreateBSScheduler(ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('CreateBSScheduler',
'ns3::Ptr< ns3::BSScheduler >',
[param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhy(ns3::WimaxHelper::PhyType phyType) [member function]
cls.add_method('CreatePhy',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhy(ns3::WimaxHelper::PhyType phyType, char * SNRTraceFilePath, bool activateLoss) [member function]
cls.add_method('CreatePhy',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType'), param('char *', 'SNRTraceFilePath'), param('bool', 'activateLoss')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhyWithoutChannel(ns3::WimaxHelper::PhyType phyType) [member function]
cls.add_method('CreatePhyWithoutChannel',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxHelper::CreatePhyWithoutChannel(ns3::WimaxHelper::PhyType phyType, char * SNRTraceFilePath, bool activateLoss) [member function]
cls.add_method('CreatePhyWithoutChannel',
'ns3::Ptr< ns3::WimaxPhy >',
[param('ns3::WimaxHelper::PhyType', 'phyType'), param('char *', 'SNRTraceFilePath'), param('bool', 'activateLoss')])
## wimax-helper.h (module 'wimax'): ns3::ServiceFlow ns3::WimaxHelper::CreateServiceFlow(ns3::ServiceFlow::Direction direction, ns3::ServiceFlow::SchedulingType schedulinType, ns3::IpcsClassifierRecord classifier) [member function]
cls.add_method('CreateServiceFlow',
'ns3::ServiceFlow',
[param('ns3::ServiceFlow::Direction', 'direction'), param('ns3::ServiceFlow::SchedulingType', 'schedulinType'), param('ns3::IpcsClassifierRecord', 'classifier')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::UplinkScheduler> ns3::WimaxHelper::CreateUplinkScheduler(ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('CreateUplinkScheduler',
'ns3::Ptr< ns3::UplinkScheduler >',
[param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): static void ns3::WimaxHelper::EnableAsciiForConnection(ns3::Ptr<ns3::OutputStreamWrapper> oss, uint32_t nodeid, uint32_t deviceid, char * netdevice, char * connection) [member function]
cls.add_method('EnableAsciiForConnection',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'oss'), param('uint32_t', 'nodeid'), param('uint32_t', 'deviceid'), param('char *', 'netdevice'), param('char *', 'connection')],
is_static=True)
## wimax-helper.h (module 'wimax'): static void ns3::WimaxHelper::EnableLogComponents() [member function]
cls.add_method('EnableLogComponents',
'void',
[],
is_static=True)
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType type, ns3::WimaxHelper::PhyType phyType, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'type'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::Ptr<ns3::WimaxChannel> channel, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::Ptr< ns3::WimaxChannel >', 'channel'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): ns3::NetDeviceContainer ns3::WimaxHelper::Install(ns3::NodeContainer c, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::WimaxHelper::SchedulerType schedulerType, double frameDuration) [member function]
cls.add_method('Install',
'ns3::NetDeviceContainer',
[param('ns3::NodeContainer', 'c'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType'), param('double', 'frameDuration')])
## wimax-helper.h (module 'wimax'): ns3::Ptr<ns3::WimaxNetDevice> ns3::WimaxHelper::Install(ns3::Ptr<ns3::Node> node, ns3::WimaxHelper::NetDeviceType deviceType, ns3::WimaxHelper::PhyType phyType, ns3::Ptr<ns3::WimaxChannel> channel, ns3::WimaxHelper::SchedulerType schedulerType) [member function]
cls.add_method('Install',
'ns3::Ptr< ns3::WimaxNetDevice >',
[param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::WimaxHelper::NetDeviceType', 'deviceType'), param('ns3::WimaxHelper::PhyType', 'phyType'), param('ns3::Ptr< ns3::WimaxChannel >', 'channel'), param('ns3::WimaxHelper::SchedulerType', 'schedulerType')])
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::SetPropagationLossModel(ns3::SimpleOfdmWimaxChannel::PropModel propagationModel) [member function]
cls.add_method('SetPropagationLossModel',
'void',
[param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propagationModel')])
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::EnableAsciiInternal(ns3::Ptr<ns3::OutputStreamWrapper> stream, std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename) [member function]
cls.add_method('EnableAsciiInternal',
'void',
[param('ns3::Ptr< ns3::OutputStreamWrapper >', 'stream'), param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename')],
visibility='private', is_virtual=True)
## wimax-helper.h (module 'wimax'): void ns3::WimaxHelper::EnablePcapInternal(std::string prefix, ns3::Ptr<ns3::NetDevice> nd, bool explicitFilename, bool promiscuous) [member function]
cls.add_method('EnablePcapInternal',
'void',
[param('std::string', 'prefix'), param('ns3::Ptr< ns3::NetDevice >', 'nd'), param('bool', 'explicitFilename'), param('bool', 'promiscuous')],
visibility='private', is_virtual=True)
return
def register_Ns3ZetaVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(ns3::ZetaVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ZetaVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable(double alpha) [constructor]
cls.add_constructor([param('double', 'alpha')])
## random-variable.h (module 'core'): ns3::ZetaVariable::ZetaVariable() [constructor]
cls.add_constructor([])
return
def register_Ns3ZipfVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(ns3::ZipfVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ZipfVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable(long int N, double alpha) [constructor]
cls.add_constructor([param('long int', 'N'), param('double', 'alpha')])
## random-variable.h (module 'core'): ns3::ZipfVariable::ZipfVariable() [constructor]
cls.add_constructor([])
return
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]
cls.add_constructor([param('ns3::empty const &', 'arg0')])
return
def register_Ns3Int64x64_t_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', '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 &', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short unsigned int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('unsigned char const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long long int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('long int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('short int const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('signed char const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('double const', 'right'))
cls.add_binary_numeric_operator('/', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', 'right'))
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('>')
cls.add_inplace_numeric_operator('*=', param('ns3::int64x64_t const &', 'right'))
cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', 'right'))
cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', '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(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_constructor([param('ns3::int64x64_t const &', 'o')])
## int64x64-double.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]
cls.add_method('GetHigh',
'int64_t',
[],
is_const=True)
## int64x64-double.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]
cls.add_method('Invert',
'ns3::int64x64_t',
[param('uint64_t', 'v')],
is_static=True)
## int64x64-double.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')])
return
def register_Ns3SimpleOfdmSendParam_methods(root_module, cls):
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(ns3::simpleOfdmSendParam const & arg0) [copy constructor]
cls.add_constructor([param('ns3::simpleOfdmSendParam const &', 'arg0')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam() [constructor]
cls.add_constructor([])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(ns3::bvec const & fecBlock, uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPowerDbm) [constructor]
cls.add_constructor([param('ns3::bvec const &', 'fecBlock'), param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'Frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPowerDbm')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::simpleOfdmSendParam::simpleOfdmSendParam(uint32_t burstSize, bool isFirstBlock, uint64_t Frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPowerDbm, ns3::Ptr<ns3::PacketBurst> burst) [constructor]
cls.add_constructor([param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'Frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPowerDbm'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-send-param.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::simpleOfdmSendParam::GetBurst() [member function]
cls.add_method('GetBurst',
'ns3::Ptr< ns3::PacketBurst >',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint32_t ns3::simpleOfdmSendParam::GetBurstSize() [member function]
cls.add_method('GetBurstSize',
'uint32_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint8_t ns3::simpleOfdmSendParam::GetDirection() [member function]
cls.add_method('GetDirection',
'uint8_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): ns3::bvec ns3::simpleOfdmSendParam::GetFecBlock() [member function]
cls.add_method('GetFecBlock',
'ns3::bvec',
[])
## simple-ofdm-send-param.h (module 'wimax'): uint64_t ns3::simpleOfdmSendParam::GetFrequency() [member function]
cls.add_method('GetFrequency',
'uint64_t',
[])
## simple-ofdm-send-param.h (module 'wimax'): bool ns3::simpleOfdmSendParam::GetIsFirstBlock() [member function]
cls.add_method('GetIsFirstBlock',
'bool',
[])
## simple-ofdm-send-param.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::simpleOfdmSendParam::GetModulationType() [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[])
## simple-ofdm-send-param.h (module 'wimax'): double ns3::simpleOfdmSendParam::GetRxPowerDbm() [member function]
cls.add_method('GetRxPowerDbm',
'double',
[])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetBurstSize(uint32_t burstSize) [member function]
cls.add_method('SetBurstSize',
'void',
[param('uint32_t', 'burstSize')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetDirection(uint8_t direction) [member function]
cls.add_method('SetDirection',
'void',
[param('uint8_t', 'direction')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetFecBlock(ns3::bvec const & fecBlock) [member function]
cls.add_method('SetFecBlock',
'void',
[param('ns3::bvec const &', 'fecBlock')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetFrequency(uint64_t Frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint64_t', 'Frequency')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetIsFirstBlock(bool isFirstBlock) [member function]
cls.add_method('SetIsFirstBlock',
'void',
[param('bool', 'isFirstBlock')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## simple-ofdm-send-param.h (module 'wimax'): void ns3::simpleOfdmSendParam::SetRxPowerDbm(double rxPowerDbm) [member function]
cls.add_method('SetRxPowerDbm',
'void',
[param('double', 'rxPowerDbm')])
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_virtual=True)
## chunk.h (module 'network'): static ns3::TypeId ns3::Chunk::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## chunk.h (module 'network'): void ns3::Chunk::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3ClassificationRuleVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleVectorTlvValue(ns3::ClassificationRuleVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ClassificationRuleVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue::ClassificationRuleVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::ClassificationRuleVectorTlvValue * ns3::ClassificationRuleVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::ClassificationRuleVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ClassificationRuleVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3ConstantVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(ns3::ConstantVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ConstantVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ConstantVariable::ConstantVariable(double c) [constructor]
cls.add_constructor([param('double', 'c')])
## random-variable.h (module 'core'): void ns3::ConstantVariable::SetConstant(double c) [member function]
cls.add_method('SetConstant',
'void',
[param('double', 'c')])
return
def register_Ns3CsParamVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::CsParamVectorTlvValue(ns3::CsParamVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CsParamVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue::CsParamVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::CsParamVectorTlvValue * ns3::CsParamVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::CsParamVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::CsParamVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3DeterministicVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(ns3::DeterministicVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DeterministicVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::DeterministicVariable::DeterministicVariable(double * d, uint32_t c) [constructor]
cls.add_constructor([param('double *', 'd'), param('uint32_t', 'c')])
return
def register_Ns3EmpiricalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable(ns3::EmpiricalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EmpiricalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::EmpiricalVariable::EmpiricalVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): void ns3::EmpiricalVariable::CDF(double v, double c) [member function]
cls.add_method('CDF',
'void',
[param('double', 'v'), param('double', 'c')])
return
def register_Ns3ErlangVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(ns3::ErlangVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ErlangVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ErlangVariable::ErlangVariable(unsigned int k, double lambda) [constructor]
cls.add_constructor([param('unsigned int', 'k'), param('double', 'lambda')])
## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::ErlangVariable::GetValue(unsigned int k, double lambda) const [member function]
cls.add_method('GetValue',
'double',
[param('unsigned int', 'k'), param('double', 'lambda')],
is_const=True)
return
def register_Ns3ExponentialVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(ns3::ExponentialVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ExponentialVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::ExponentialVariable::ExponentialVariable(double m, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'b')])
return
def register_Ns3GammaVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(ns3::GammaVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GammaVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::GammaVariable::GammaVariable(double alpha, double beta) [constructor]
cls.add_constructor([param('double', 'alpha'), param('double', 'beta')])
## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue() const [member function]
cls.add_method('GetValue',
'double',
[],
is_const=True)
## random-variable.h (module 'core'): double ns3::GammaVariable::GetValue(double alpha, double beta) const [member function]
cls.add_method('GetValue',
'double',
[param('double', 'alpha'), param('double', 'beta')],
is_const=True)
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_virtual=True)
## header.h (module 'network'): uint32_t ns3::Header::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## header.h (module 'network'): static ns3::TypeId ns3::Header::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## header.h (module 'network'): void ns3::Header::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## header.h (module 'network'): void ns3::Header::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3IntEmpiricalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable(ns3::IntEmpiricalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IntEmpiricalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::IntEmpiricalVariable::IntEmpiricalVariable() [constructor]
cls.add_constructor([])
return
def register_Ns3Ipv4AddressTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::Ipv4AddressTlvValue(ns3::Ipv4AddressTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ipv4AddressTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::Ipv4AddressTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::Ipv4AddressTlvValue::Add(ns3::Ipv4Address address, ns3::Ipv4Mask Mask) [member function]
cls.add_method('Add',
'void',
[param('ns3::Ipv4Address', 'address'), param('ns3::Ipv4Mask', 'Mask')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::Ipv4AddressTlvValue::ipv4Addr*,std::vector<ns3::Ipv4AddressTlvValue::ipv4Addr, std::allocator<ns3::Ipv4AddressTlvValue::ipv4Addr> > > ns3::Ipv4AddressTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::Ipv4AddressTlvValue::ipv4Addr const *, std::vector< ns3::Ipv4AddressTlvValue::ipv4Addr > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue * ns3::Ipv4AddressTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ipv4AddressTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Ipv4AddressTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::Ipv4AddressTlvValue::ipv4Addr*,std::vector<ns3::Ipv4AddressTlvValue::ipv4Addr, std::allocator<ns3::Ipv4AddressTlvValue::ipv4Addr> > > ns3::Ipv4AddressTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::Ipv4AddressTlvValue::ipv4Addr const *, std::vector< ns3::Ipv4AddressTlvValue::ipv4Addr > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Ipv4AddressTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::Ipv4AddressTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3Ipv4AddressTlvValueIpv4Addr_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::ipv4Addr() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::ipv4Addr(ns3::Ipv4AddressTlvValue::ipv4Addr const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ipv4AddressTlvValue::ipv4Addr const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::Address [variable]
cls.add_instance_attribute('Address', 'ns3::Ipv4Address', is_const=False)
## wimax-tlv.h (module 'wimax'): ns3::Ipv4AddressTlvValue::ipv4Addr::Mask [variable]
cls.add_instance_attribute('Mask', 'ns3::Ipv4Mask', is_const=False)
return
def register_Ns3LogNormalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(ns3::LogNormalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::LogNormalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::LogNormalVariable::LogNormalVariable(double mu, double sigma) [constructor]
cls.add_constructor([param('double', 'mu'), param('double', 'sigma')])
return
def register_Ns3MacHeaderType_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType(ns3::MacHeaderType const & arg0) [copy constructor]
cls.add_constructor([param('ns3::MacHeaderType const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): ns3::MacHeaderType::MacHeaderType(uint8_t type) [constructor]
cls.add_constructor([param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::MacHeaderType::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::MacHeaderType::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::MacHeaderType::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::MacHeaderType::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::MacHeaderType::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::MacHeaderType::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::MacHeaderType::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
return
def register_Ns3ManagementMessageType_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType(ns3::ManagementMessageType const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ManagementMessageType const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): ns3::ManagementMessageType::ManagementMessageType(uint8_t type) [constructor]
cls.add_constructor([param('uint8_t', 'type')])
## mac-messages.h (module 'wimax'): uint32_t ns3::ManagementMessageType::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::ManagementMessageType::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::ManagementMessageType::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::ManagementMessageType::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::ManagementMessageType::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::ManagementMessageType::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::ManagementMessageType::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
return
def register_Ns3NormalVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(ns3::NormalVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::NormalVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'v')])
## random-variable.h (module 'core'): ns3::NormalVariable::NormalVariable(double m, double v, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 'v'), param('double', 'b')])
return
def register_Ns3Object_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::Object() [constructor]
cls.add_constructor([])
## object.h (module 'core'): void ns3::Object::AggregateObject(ns3::Ptr<ns3::Object> other) [member function]
cls.add_method('AggregateObject',
'void',
[param('ns3::Ptr< ns3::Object >', 'other')])
## object.h (module 'core'): void ns3::Object::Dispose() [member function]
cls.add_method('Dispose',
'void',
[])
## object.h (module 'core'): ns3::Object::AggregateIterator ns3::Object::GetAggregateIterator() const [member function]
cls.add_method('GetAggregateIterator',
'ns3::Object::AggregateIterator',
[],
is_const=True)
## object.h (module 'core'): ns3::TypeId ns3::Object::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## object.h (module 'core'): static ns3::TypeId ns3::Object::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## object.h (module 'core'): void ns3::Object::Start() [member function]
cls.add_method('Start',
'void',
[])
## object.h (module 'core'): ns3::Object::Object(ns3::Object const & o) [copy constructor]
cls.add_constructor([param('ns3::Object const &', 'o')],
visibility='protected')
## object.h (module 'core'): void ns3::Object::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='protected', is_virtual=True)
## object.h (module 'core'): void ns3::Object::DoStart() [member function]
cls.add_method('DoStart',
'void',
[],
visibility='protected', is_virtual=True)
## object.h (module 'core'): void ns3::Object::NotifyNewAggregate() [member function]
cls.add_method('NotifyNewAggregate',
'void',
[],
visibility='protected', is_virtual=True)
return
def register_Ns3ObjectAggregateIterator_methods(root_module, cls):
## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator(ns3::Object::AggregateIterator const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Object::AggregateIterator const &', 'arg0')])
## object.h (module 'core'): ns3::Object::AggregateIterator::AggregateIterator() [constructor]
cls.add_constructor([])
## object.h (module 'core'): bool ns3::Object::AggregateIterator::HasNext() const [member function]
cls.add_method('HasNext',
'bool',
[],
is_const=True)
## object.h (module 'core'): ns3::Ptr<ns3::Object const> ns3::Object::AggregateIterator::Next() [member function]
cls.add_method('Next',
'ns3::Ptr< ns3::Object const >',
[])
return
def register_Ns3OfdmDownlinkFramePrefix_methods(root_module, cls):
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix::OfdmDownlinkFramePrefix(ns3::OfdmDownlinkFramePrefix const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmDownlinkFramePrefix const &', 'arg0')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::OfdmDownlinkFramePrefix::OfdmDownlinkFramePrefix() [constructor]
cls.add_constructor([])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::AddDlFramePrefixElement(ns3::DlFramePrefixIe dlFramePrefixElement) [member function]
cls.add_method('AddDlFramePrefixElement',
'void',
[param('ns3::DlFramePrefixIe', 'dlFramePrefixElement')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): ns3::Mac48Address ns3::OfdmDownlinkFramePrefix::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::OfdmDownlinkFramePrefix::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): std::vector<ns3::DlFramePrefixIe, std::allocator<ns3::DlFramePrefixIe> > ns3::OfdmDownlinkFramePrefix::GetDlFramePrefixElements() const [member function]
cls.add_method('GetDlFramePrefixElements',
'std::vector< ns3::DlFramePrefixIe >',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint8_t ns3::OfdmDownlinkFramePrefix::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): std::string ns3::OfdmDownlinkFramePrefix::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): uint32_t ns3::OfdmDownlinkFramePrefix::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetBaseStationId(ns3::Mac48Address baseStationId) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationId')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetConfigurationChangeCount(uint8_t configurationChangeCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'configurationChangeCount')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## ofdm-downlink-frame-prefix.h (module 'wimax'): void ns3::OfdmDownlinkFramePrefix::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
return
def register_Ns3OfdmSendParams_methods(root_module, cls):
## send-params.h (module 'wimax'): ns3::OfdmSendParams::OfdmSendParams(ns3::OfdmSendParams const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmSendParams const &', 'arg0')])
## send-params.h (module 'wimax'): ns3::OfdmSendParams::OfdmSendParams(ns3::Ptr<ns3::PacketBurst> burst, uint8_t modulationType, uint8_t direction) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('uint8_t', 'modulationType'), param('uint8_t', 'direction')])
## send-params.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::OfdmSendParams::GetBurst() const [member function]
cls.add_method('GetBurst',
'ns3::Ptr< ns3::PacketBurst >',
[],
is_const=True)
## send-params.h (module 'wimax'): uint8_t ns3::OfdmSendParams::GetDirection() const [member function]
cls.add_method('GetDirection',
'uint8_t',
[],
is_const=True)
## send-params.h (module 'wimax'): uint8_t ns3::OfdmSendParams::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'uint8_t',
[],
is_const=True)
return
def register_Ns3OfdmUcdChannelEncodings_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings::OfdmUcdChannelEncodings(ns3::OfdmUcdChannelEncodings const & arg0) [copy constructor]
cls.add_constructor([param('ns3::OfdmUcdChannelEncodings const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings::OfdmUcdChannelEncodings() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUcdChannelEncodings::GetSbchnlFocContCodes() const [member function]
cls.add_method('GetSbchnlFocContCodes',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::OfdmUcdChannelEncodings::GetSbchnlReqRegionFullParams() const [member function]
cls.add_method('GetSbchnlReqRegionFullParams',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint16_t ns3::OfdmUcdChannelEncodings::GetSize() const [member function]
cls.add_method('GetSize',
'uint16_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUcdChannelEncodings::SetSbchnlFocContCodes(uint8_t sbchnlFocContCodes) [member function]
cls.add_method('SetSbchnlFocContCodes',
'void',
[param('uint8_t', 'sbchnlFocContCodes')])
## ul-mac-messages.h (module 'wimax'): void ns3::OfdmUcdChannelEncodings::SetSbchnlReqRegionFullParams(uint8_t sbchnlReqRegionFullParams) [member function]
cls.add_method('SetSbchnlReqRegionFullParams',
'void',
[param('uint8_t', 'sbchnlReqRegionFullParams')])
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUcdChannelEncodings::DoRead(ns3::Buffer::Iterator start) [member function]
cls.add_method('DoRead',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
visibility='private', is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::Buffer::Iterator ns3::OfdmUcdChannelEncodings::DoWrite(ns3::Buffer::Iterator start) const [member function]
cls.add_method('DoWrite',
'ns3::Buffer::Iterator',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3PacketBurst_methods(root_module, cls):
## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst(ns3::PacketBurst const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PacketBurst const &', 'arg0')])
## packet-burst.h (module 'network'): ns3::PacketBurst::PacketBurst() [constructor]
cls.add_constructor([])
## packet-burst.h (module 'network'): void ns3::PacketBurst::AddPacket(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('AddPacket',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')])
## packet-burst.h (module 'network'): std::_List_const_iterator<ns3::Ptr<ns3::Packet> > ns3::PacketBurst::Begin() const [member function]
cls.add_method('Begin',
'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): ns3::Ptr<ns3::PacketBurst> ns3::PacketBurst::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::PacketBurst >',
[],
is_const=True)
## packet-burst.h (module 'network'): std::_List_const_iterator<ns3::Ptr<ns3::Packet> > ns3::PacketBurst::End() const [member function]
cls.add_method('End',
'std::_List_const_iterator< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetNPackets() const [member function]
cls.add_method('GetNPackets',
'uint32_t',
[],
is_const=True)
## packet-burst.h (module 'network'): std::list<ns3::Ptr<ns3::Packet>, std::allocator<ns3::Ptr<ns3::Packet> > > ns3::PacketBurst::GetPackets() const [member function]
cls.add_method('GetPackets',
'std::list< ns3::Ptr< ns3::Packet > >',
[],
is_const=True)
## packet-burst.h (module 'network'): uint32_t ns3::PacketBurst::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## packet-burst.h (module 'network'): static ns3::TypeId ns3::PacketBurst::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## packet-burst.h (module 'network'): void ns3::PacketBurst::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3ParetoVariable_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(ns3::ParetoVariable const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ParetoVariable const &', 'arg0')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m) [constructor]
cls.add_constructor([param('double', 'm')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(double m, double s, double b) [constructor]
cls.add_constructor([param('double', 'm'), param('double', 's'), param('double', 'b')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params) [constructor]
cls.add_constructor([param('std::pair< double, double >', 'params')])
## random-variable.h (module 'core'): ns3::ParetoVariable::ParetoVariable(std::pair<double,double> params, double b) [constructor]
cls.add_constructor([param('std::pair< double, double >', 'params'), param('double', 'b')])
return
def register_Ns3PcapFileWrapper_methods(root_module, cls):
## pcap-file-wrapper.h (module 'network'): static ns3::TypeId ns3::PcapFileWrapper::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## pcap-file-wrapper.h (module 'network'): ns3::PcapFileWrapper::PcapFileWrapper() [constructor]
cls.add_constructor([])
## pcap-file-wrapper.h (module 'network'): bool ns3::PcapFileWrapper::Fail() const [member function]
cls.add_method('Fail',
'bool',
[],
is_const=True)
## pcap-file-wrapper.h (module 'network'): bool ns3::PcapFileWrapper::Eof() const [member function]
cls.add_method('Eof',
'bool',
[],
is_const=True)
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Clear() [member function]
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]
cls.add_method('Open',
'void',
[param('std::string const &', 'filename'), param('std::_Ios_Openmode', 'mode')])
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Close() [member function]
cls.add_method('Close',
'void',
[])
## pcap-file-wrapper.h (module 'network'): void ns3::PcapFileWrapper::Init(uint32_t dataLinkType, uint32_t snapLen=std::numeric_limits<unsigned int>::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<unsigned int>::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<const ns3::Packet> 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 & header, ns3::Ptr<const ns3::Packet> p) [member function]
cls.add_method('Write',
'void',
[param('ns3::Time', 't'), param('ns3::Header &', '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')])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetMagic() [member function]
cls.add_method('GetMagic',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint16_t ns3::PcapFileWrapper::GetVersionMajor() [member function]
cls.add_method('GetVersionMajor',
'uint16_t',
[])
## pcap-file-wrapper.h (module 'network'): uint16_t ns3::PcapFileWrapper::GetVersionMinor() [member function]
cls.add_method('GetVersionMinor',
'uint16_t',
[])
## pcap-file-wrapper.h (module 'network'): int32_t ns3::PcapFileWrapper::GetTimeZoneOffset() [member function]
cls.add_method('GetTimeZoneOffset',
'int32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetSigFigs() [member function]
cls.add_method('GetSigFigs',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetSnapLen() [member function]
cls.add_method('GetSnapLen',
'uint32_t',
[])
## pcap-file-wrapper.h (module 'network'): uint32_t ns3::PcapFileWrapper::GetDataLinkType() [member function]
cls.add_method('GetDataLinkType',
'uint32_t',
[])
return
def register_Ns3PortRangeTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRangeTlvValue(ns3::PortRangeTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PortRangeTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRangeTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::PortRangeTlvValue::Add(uint16_t portLow, uint16_t portHigh) [member function]
cls.add_method('Add',
'void',
[param('uint16_t', 'portLow'), param('uint16_t', 'portHigh')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::PortRangeTlvValue::PortRange*,std::vector<ns3::PortRangeTlvValue::PortRange, std::allocator<ns3::PortRangeTlvValue::PortRange> > > ns3::PortRangeTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< ns3::PortRangeTlvValue::PortRange const *, std::vector< ns3::PortRangeTlvValue::PortRange > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue * ns3::PortRangeTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::PortRangeTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::PortRangeTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const ns3::PortRangeTlvValue::PortRange*,std::vector<ns3::PortRangeTlvValue::PortRange, std::allocator<ns3::PortRangeTlvValue::PortRange> > > ns3::PortRangeTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< ns3::PortRangeTlvValue::PortRange const *, std::vector< ns3::PortRangeTlvValue::PortRange > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::PortRangeTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::PortRangeTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3PortRangeTlvValuePortRange_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortRange() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortRange(ns3::PortRangeTlvValue::PortRange const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PortRangeTlvValue::PortRange const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortHigh [variable]
cls.add_instance_attribute('PortHigh', 'uint16_t', is_const=False)
## wimax-tlv.h (module 'wimax'): ns3::PortRangeTlvValue::PortRange::PortLow [variable]
cls.add_instance_attribute('PortLow', 'uint16_t', is_const=False)
return
def register_Ns3PriorityUlJob_methods(root_module, cls):
## ul-job.h (module 'wimax'): ns3::PriorityUlJob::PriorityUlJob(ns3::PriorityUlJob const & arg0) [copy constructor]
cls.add_constructor([param('ns3::PriorityUlJob const &', 'arg0')])
## ul-job.h (module 'wimax'): ns3::PriorityUlJob::PriorityUlJob() [constructor]
cls.add_constructor([])
## ul-job.h (module 'wimax'): int ns3::PriorityUlJob::GetPriority() [member function]
cls.add_method('GetPriority',
'int',
[])
## ul-job.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::PriorityUlJob::GetUlJob() [member function]
cls.add_method('GetUlJob',
'ns3::Ptr< ns3::UlJob >',
[])
## ul-job.h (module 'wimax'): void ns3::PriorityUlJob::SetPriority(int priority) [member function]
cls.add_method('SetPriority',
'void',
[param('int', 'priority')])
## ul-job.h (module 'wimax'): void ns3::PriorityUlJob::SetUlJob(ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('SetUlJob',
'void',
[param('ns3::Ptr< ns3::UlJob >', 'job')])
return
def register_Ns3PropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel::PropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::PropagationLossModel::SetNext(ns3::Ptr<ns3::PropagationLossModel> next) [member function]
cls.add_method('SetNext',
'void',
[param('ns3::Ptr< ns3::PropagationLossModel >', 'next')])
## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::CalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('CalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::PropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3ProtocolTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue::ProtocolTlvValue(ns3::ProtocolTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ProtocolTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue::ProtocolTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): void ns3::ProtocolTlvValue::Add(uint8_t protiocol) [member function]
cls.add_method('Add',
'void',
[param('uint8_t', 'protiocol')])
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const unsigned char*,std::vector<unsigned char, std::allocator<unsigned char> > > ns3::ProtocolTlvValue::Begin() const [member function]
cls.add_method('Begin',
'__gnu_cxx::__normal_iterator< unsigned char const *, std::vector< unsigned char > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::ProtocolTlvValue * ns3::ProtocolTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::ProtocolTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ProtocolTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): __gnu_cxx::__normal_iterator<const unsigned char*,std::vector<unsigned char, std::allocator<unsigned char> > > ns3::ProtocolTlvValue::End() const [member function]
cls.add_method('End',
'__gnu_cxx::__normal_iterator< unsigned char const *, std::vector< unsigned char > >',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::ProtocolTlvValue::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::ProtocolTlvValue::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3RandomPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RandomPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel::RandomPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::RandomPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3RangePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::RangePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel::RangePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::RangePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3RngReq_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::RngReq::RngReq(ns3::RngReq const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RngReq const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::RngReq::RngReq() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::RngReq::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::RngReq::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::RngReq::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## mac-messages.h (module 'wimax'): std::string ns3::RngReq::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngReq::GetRangingAnomalies() const [member function]
cls.add_method('GetRangingAnomalies',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngReq::GetReqDlBurstProfile() const [member function]
cls.add_method('GetReqDlBurstProfile',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngReq::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::RngReq::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::PrintDebug() const [member function]
cls.add_method('PrintDebug',
'void',
[],
is_const=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetRangingAnomalies(uint8_t rangingAnomalies) [member function]
cls.add_method('SetRangingAnomalies',
'void',
[param('uint8_t', 'rangingAnomalies')])
## mac-messages.h (module 'wimax'): void ns3::RngReq::SetReqDlBurstProfile(uint8_t reqDlBurstProfile) [member function]
cls.add_method('SetReqDlBurstProfile',
'void',
[param('uint8_t', 'reqDlBurstProfile')])
return
def register_Ns3RngRsp_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::RngRsp::RngRsp(ns3::RngRsp const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RngRsp const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::RngRsp::RngRsp() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetAasBdcastPermission() const [member function]
cls.add_method('GetAasBdcastPermission',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::RngRsp::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetDlFreqOverride() const [member function]
cls.add_method('GetDlFreqOverride',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::RngRsp::GetDlOperBurstProfile() const [member function]
cls.add_method('GetDlOperBurstProfile',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetFrameNumber() const [member function]
cls.add_method('GetFrameNumber',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetInitRangOppNumber() const [member function]
cls.add_method('GetInitRangOppNumber',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::RngRsp::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::RngRsp::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## mac-messages.h (module 'wimax'): std::string ns3::RngRsp::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetOffsetFreqAdjust() const [member function]
cls.add_method('GetOffsetFreqAdjust',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetPowerLevelAdjust() const [member function]
cls.add_method('GetPowerLevelAdjust',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::RngRsp::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetRangStatus() const [member function]
cls.add_method('GetRangStatus',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetRangSubchnl() const [member function]
cls.add_method('GetRangSubchnl',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::RngRsp::GetTimingAdjust() const [member function]
cls.add_method('GetTimingAdjust',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::RngRsp::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): uint8_t ns3::RngRsp::GetUlChnlIdOverride() const [member function]
cls.add_method('GetUlChnlIdOverride',
'uint8_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetAasBdcastPermission(uint8_t aasBdcastPermission) [member function]
cls.add_method('SetAasBdcastPermission',
'void',
[param('uint8_t', 'aasBdcastPermission')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetBasicCid(ns3::Cid basicCid) [member function]
cls.add_method('SetBasicCid',
'void',
[param('ns3::Cid', 'basicCid')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetDlFreqOverride(uint32_t dlFreqOverride) [member function]
cls.add_method('SetDlFreqOverride',
'void',
[param('uint32_t', 'dlFreqOverride')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetDlOperBurstProfile(uint16_t dlOperBurstProfile) [member function]
cls.add_method('SetDlOperBurstProfile',
'void',
[param('uint16_t', 'dlOperBurstProfile')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetFrameNumber(uint32_t frameNumber) [member function]
cls.add_method('SetFrameNumber',
'void',
[param('uint32_t', 'frameNumber')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetInitRangOppNumber(uint8_t initRangOppNumber) [member function]
cls.add_method('SetInitRangOppNumber',
'void',
[param('uint8_t', 'initRangOppNumber')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetMacAddress(ns3::Mac48Address macAddress) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'macAddress')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetOffsetFreqAdjust(uint32_t offsetFreqAdjust) [member function]
cls.add_method('SetOffsetFreqAdjust',
'void',
[param('uint32_t', 'offsetFreqAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetPowerLevelAdjust(uint8_t powerLevelAdjust) [member function]
cls.add_method('SetPowerLevelAdjust',
'void',
[param('uint8_t', 'powerLevelAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetPrimaryCid(ns3::Cid primaryCid) [member function]
cls.add_method('SetPrimaryCid',
'void',
[param('ns3::Cid', 'primaryCid')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetRangStatus(uint8_t rangStatus) [member function]
cls.add_method('SetRangStatus',
'void',
[param('uint8_t', 'rangStatus')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetRangSubchnl(uint8_t rangSubchnl) [member function]
cls.add_method('SetRangSubchnl',
'void',
[param('uint8_t', 'rangSubchnl')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetTimingAdjust(uint32_t timingAdjust) [member function]
cls.add_method('SetTimingAdjust',
'void',
[param('uint32_t', 'timingAdjust')])
## mac-messages.h (module 'wimax'): void ns3::RngRsp::SetUlChnlIdOverride(uint8_t ulChnlIdOverride) [member function]
cls.add_method('SetUlChnlIdOverride',
'void',
[param('uint8_t', 'ulChnlIdOverride')])
return
def register_Ns3SSManager_methods(root_module, cls):
## ss-manager.h (module 'wimax'): ns3::SSManager::SSManager(ns3::SSManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SSManager const &', 'arg0')])
## ss-manager.h (module 'wimax'): ns3::SSManager::SSManager() [constructor]
cls.add_constructor([])
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::CreateSSRecord(ns3::Mac48Address const & macAddress) [member function]
cls.add_method('CreateSSRecord',
'ns3::SSRecord *',
[param('ns3::Mac48Address const &', 'macAddress')])
## ss-manager.h (module 'wimax'): void ns3::SSManager::DeleteSSRecord(ns3::Cid cid) [member function]
cls.add_method('DeleteSSRecord',
'void',
[param('ns3::Cid', 'cid')])
## ss-manager.h (module 'wimax'): ns3::Mac48Address ns3::SSManager::GetMacAddress(ns3::Cid cid) const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[param('ns3::Cid', 'cid')],
is_const=True)
## ss-manager.h (module 'wimax'): uint32_t ns3::SSManager::GetNRegisteredSSs() const [member function]
cls.add_method('GetNRegisteredSSs',
'uint32_t',
[],
is_const=True)
## ss-manager.h (module 'wimax'): uint32_t ns3::SSManager::GetNSSs() const [member function]
cls.add_method('GetNSSs',
'uint32_t',
[],
is_const=True)
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::GetSSRecord(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('GetSSRecord',
'ns3::SSRecord *',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
## ss-manager.h (module 'wimax'): ns3::SSRecord * ns3::SSManager::GetSSRecord(ns3::Cid cid) const [member function]
cls.add_method('GetSSRecord',
'ns3::SSRecord *',
[param('ns3::Cid', 'cid')],
is_const=True)
## ss-manager.h (module 'wimax'): std::vector<ns3::SSRecord*,std::allocator<ns3::SSRecord*> > * ns3::SSManager::GetSSRecords() const [member function]
cls.add_method('GetSSRecords',
'std::vector< ns3::SSRecord * > *',
[],
is_const=True)
## ss-manager.h (module 'wimax'): static ns3::TypeId ns3::SSManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ss-manager.h (module 'wimax'): bool ns3::SSManager::IsInRecord(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('IsInRecord',
'bool',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
## ss-manager.h (module 'wimax'): bool ns3::SSManager::IsRegistered(ns3::Mac48Address const & macAddress) const [member function]
cls.add_method('IsRegistered',
'bool',
[param('ns3::Mac48Address const &', 'macAddress')],
is_const=True)
return
def register_Ns3ServiceFlowManager_methods(root_module, cls):
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ServiceFlowManager(ns3::ServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ServiceFlowManager const &', 'arg0')])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlowManager::ServiceFlowManager() [constructor]
cls.add_constructor([])
## service-flow-manager.h (module 'wimax'): void ns3::ServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated() [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated(std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > * serviceFlows) [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[param('std::vector< ns3::ServiceFlow * > *', 'serviceFlows')])
## service-flow-manager.h (module 'wimax'): bool ns3::ServiceFlowManager::AreServiceFlowsAllocated(std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > serviceFlows) [member function]
cls.add_method('AreServiceFlowsAllocated',
'bool',
[param('std::vector< ns3::ServiceFlow * >', 'serviceFlows')])
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::DoClassify(ns3::Ipv4Address SrcAddress, ns3::Ipv4Address DstAddress, uint16_t SrcPort, uint16_t DstPort, uint8_t Proto, ns3::ServiceFlow::Direction dir) const [member function]
cls.add_method('DoClassify',
'ns3::ServiceFlow *',
[param('ns3::Ipv4Address', 'SrcAddress'), param('ns3::Ipv4Address', 'DstAddress'), param('uint16_t', 'SrcPort'), param('uint16_t', 'DstPort'), param('uint8_t', 'Proto'), param('ns3::ServiceFlow::Direction', 'dir')],
is_const=True)
## service-flow-manager.h (module 'wimax'): void ns3::ServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetNextServiceFlowToAllocate() [member function]
cls.add_method('GetNextServiceFlowToAllocate',
'ns3::ServiceFlow *',
[])
## service-flow-manager.h (module 'wimax'): uint32_t ns3::ServiceFlowManager::GetNrServiceFlows() const [member function]
cls.add_method('GetNrServiceFlows',
'uint32_t',
[],
is_const=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetServiceFlow(uint32_t sfid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('uint32_t', 'sfid')],
is_const=True)
## service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::ServiceFlowManager::GetServiceFlow(ns3::Cid cid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('ns3::Cid', 'cid')],
is_const=True)
## service-flow-manager.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::ServiceFlowManager::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## service-flow-manager.h (module 'wimax'): static ns3::TypeId ns3::ServiceFlowManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
def register_Ns3SfVectorTlvValue_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::SfVectorTlvValue(ns3::SfVectorTlvValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SfVectorTlvValue const &', 'arg0')])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue::SfVectorTlvValue() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::SfVectorTlvValue * ns3::SfVectorTlvValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::SfVectorTlvValue *',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::SfVectorTlvValue::Deserialize(ns3::Buffer::Iterator start, uint64_t valueLength) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start'), param('uint64_t', 'valueLength')],
is_virtual=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > const & o) [copy 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<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > const & o) [copy 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<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::SimpleRefCount(ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > const & o) [copy 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<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::SimpleRefCount(ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > const & o) [copy 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<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3EventImpl_Ns3Empty_Ns3DefaultDeleter__lt__ns3EventImpl__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::SimpleRefCount(ns3::SimpleRefCount<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> > const & o) [copy 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<ns3::EventImpl, ns3::empty, ns3::DefaultDeleter<ns3::EventImpl> >::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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::SimpleRefCount(ns3::SimpleRefCount<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> > const & o) [copy 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<ns3::NixVector, ns3::empty, ns3::DefaultDeleter<ns3::NixVector> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3OutputStreamWrapper_Ns3Empty_Ns3DefaultDeleter__lt__ns3OutputStreamWrapper__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::SimpleRefCount(ns3::SimpleRefCount<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> > const & o) [copy 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<ns3::OutputStreamWrapper, ns3::empty, ns3::DefaultDeleter<ns3::OutputStreamWrapper> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3Packet_Ns3Empty_Ns3DefaultDeleter__lt__ns3Packet__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::SimpleRefCount(ns3::SimpleRefCount<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> > const & o) [copy 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<ns3::Packet, ns3::empty, ns3::DefaultDeleter<ns3::Packet> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, cls):
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount() [constructor]
cls.add_constructor([])
## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::SimpleRefCount(ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > const & o) [copy 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<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >::Cleanup() [member function]
cls.add_method('Cleanup',
'void',
[],
is_static=True)
return
def register_Ns3SsServiceFlowManager_methods(root_module, cls):
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::SsServiceFlowManager(ns3::SsServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SsServiceFlowManager const &', 'arg0')])
## ss-service-flow-manager.h (module 'wimax'): ns3::SsServiceFlowManager::SsServiceFlowManager(ns3::Ptr<ns3::SubscriberStationNetDevice> device) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::SubscriberStationNetDevice >', 'device')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::SsServiceFlowManager::CreateDsaAck() [member function]
cls.add_method('CreateDsaAck',
'ns3::Ptr< ns3::Packet >',
[])
## ss-service-flow-manager.h (module 'wimax'): ns3::DsaReq ns3::SsServiceFlowManager::CreateDsaReq(ns3::ServiceFlow const * serviceFlow) [member function]
cls.add_method('CreateDsaReq',
'ns3::DsaReq',
[param('ns3::ServiceFlow const *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## ss-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::SsServiceFlowManager::GetDsaAckTimeoutEvent() const [member function]
cls.add_method('GetDsaAckTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::SsServiceFlowManager::GetDsaRspTimeoutEvent() const [member function]
cls.add_method('GetDsaRspTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): uint8_t ns3::SsServiceFlowManager::GetMaxDsaReqRetries() const [member function]
cls.add_method('GetMaxDsaReqRetries',
'uint8_t',
[],
is_const=True)
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::InitiateServiceFlows() [member function]
cls.add_method('InitiateServiceFlows',
'void',
[])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::ProcessDsaRsp(ns3::DsaRsp const & dsaRsp) [member function]
cls.add_method('ProcessDsaRsp',
'void',
[param('ns3::DsaRsp const &', 'dsaRsp')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::ScheduleDsaReq(ns3::ServiceFlow const * serviceFlow) [member function]
cls.add_method('ScheduleDsaReq',
'void',
[param('ns3::ServiceFlow const *', 'serviceFlow')])
## ss-service-flow-manager.h (module 'wimax'): void ns3::SsServiceFlowManager::SetMaxDsaReqRetries(uint8_t maxDsaReqRetries) [member function]
cls.add_method('SetMaxDsaReqRetries',
'void',
[param('uint8_t', 'maxDsaReqRetries')])
return
def register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::ThreeLogDistancePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::ThreeLogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3Time_methods(root_module, cls):
cls.add_binary_comparison_operator('!=')
cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', 'right'))
cls.add_binary_numeric_operator('+', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
cls.add_binary_numeric_operator('-', root_module['ns3::Time'], root_module['ns3::Time'], param('ns3::Time const &', 'right'))
cls.add_binary_comparison_operator('<')
cls.add_binary_comparison_operator('>')
cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', '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]
cls.add_constructor([param('ns3::Time const &', 'o')])
## nstime.h (module 'core'): ns3::Time::Time(double v) [constructor]
cls.add_constructor([param('double', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(int v) [constructor]
cls.add_constructor([param('int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long int v) [constructor]
cls.add_constructor([param('long int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long long int v) [constructor]
cls.add_constructor([param('long long int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(unsigned int v) [constructor]
cls.add_constructor([param('unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long unsigned int v) [constructor]
cls.add_constructor([param('long unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(long long unsigned int v) [constructor]
cls.add_constructor([param('long long unsigned int', 'v')])
## nstime.h (module 'core'): ns3::Time::Time(std::string const & s) [constructor]
cls.add_constructor([param('std::string const &', 's')])
## nstime.h (module 'core'): ns3::Time::Time(ns3::int64x64_t const & value) [constructor]
cls.add_constructor([param('ns3::int64x64_t const &', 'value')])
## nstime.h (module 'core'): int ns3::Time::Compare(ns3::Time const & o) const [member function]
cls.add_method('Compare',
'int',
[param('ns3::Time const &', 'o')],
is_const=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & from, ns3::Time::Unit timeUnit) [member function]
cls.add_method('From',
'ns3::Time',
[param('ns3::int64x64_t const &', 'from'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::From(ns3::int64x64_t const & value) [member function]
cls.add_method('From',
'ns3::Time',
[param('ns3::int64x64_t const &', 'value')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::FromDouble(double value, ns3::Time::Unit timeUnit) [member function]
cls.add_method('FromDouble',
'ns3::Time',
[param('double', 'value'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): static ns3::Time ns3::Time::FromInteger(uint64_t value, ns3::Time::Unit timeUnit) [member function]
cls.add_method('FromInteger',
'ns3::Time',
[param('uint64_t', 'value'), param('ns3::Time::Unit', 'timeUnit')],
is_static=True)
## nstime.h (module 'core'): double ns3::Time::GetDouble() const [member function]
cls.add_method('GetDouble',
'double',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetFemtoSeconds() const [member function]
cls.add_method('GetFemtoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetInteger() const [member function]
cls.add_method('GetInteger',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetMicroSeconds() const [member function]
cls.add_method('GetMicroSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetMilliSeconds() const [member function]
cls.add_method('GetMilliSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetNanoSeconds() const [member function]
cls.add_method('GetNanoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetPicoSeconds() const [member function]
cls.add_method('GetPicoSeconds',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): static ns3::Time::Unit ns3::Time::GetResolution() [member function]
cls.add_method('GetResolution',
'ns3::Time::Unit',
[],
is_static=True)
## nstime.h (module 'core'): double ns3::Time::GetSeconds() const [member function]
cls.add_method('GetSeconds',
'double',
[],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::GetTimeStep() const [member function]
cls.add_method('GetTimeStep',
'int64_t',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsNegative() const [member function]
cls.add_method('IsNegative',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsPositive() const [member function]
cls.add_method('IsPositive',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsStrictlyNegative() const [member function]
cls.add_method('IsStrictlyNegative',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsStrictlyPositive() const [member function]
cls.add_method('IsStrictlyPositive',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): bool ns3::Time::IsZero() const [member function]
cls.add_method('IsZero',
'bool',
[],
is_const=True)
## nstime.h (module 'core'): static void ns3::Time::SetResolution(ns3::Time::Unit resolution) [member function]
cls.add_method('SetResolution',
'void',
[param('ns3::Time::Unit', 'resolution')],
is_static=True)
## nstime.h (module 'core'): ns3::int64x64_t ns3::Time::To(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('To',
'ns3::int64x64_t',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
## nstime.h (module 'core'): double ns3::Time::ToDouble(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('ToDouble',
'double',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
## nstime.h (module 'core'): int64_t ns3::Time::ToInteger(ns3::Time::Unit timeUnit) const [member function]
cls.add_method('ToInteger',
'int64_t',
[param('ns3::Time::Unit', 'timeUnit')],
is_const=True)
return
def register_Ns3Tlv_methods(root_module, cls):
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv(uint8_t type, uint64_t length, ns3::TlvValue const & value) [constructor]
cls.add_constructor([param('uint8_t', 'type'), param('uint64_t', 'length'), param('ns3::TlvValue const &', 'value')])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv() [constructor]
cls.add_constructor([])
## wimax-tlv.h (module 'wimax'): ns3::Tlv::Tlv(ns3::Tlv const & tlv) [copy constructor]
cls.add_constructor([param('ns3::Tlv const &', 'tlv')])
## wimax-tlv.h (module 'wimax'): ns3::Tlv * ns3::Tlv::Copy() const [member function]
cls.add_method('Copy',
'ns3::Tlv *',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::Tlv::CopyValue() const [member function]
cls.add_method('CopyValue',
'ns3::TlvValue *',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Tlv::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-tlv.h (module 'wimax'): ns3::TypeId ns3::Tlv::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint64_t ns3::Tlv::GetLength() const [member function]
cls.add_method('GetLength',
'uint64_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint32_t ns3::Tlv::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::Tlv::GetSizeOfLen() const [member function]
cls.add_method('GetSizeOfLen',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): uint8_t ns3::Tlv::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-tlv.h (module 'wimax'): ns3::TlvValue * ns3::Tlv::PeekValue() [member function]
cls.add_method('PeekValue',
'ns3::TlvValue *',
[])
## wimax-tlv.h (module 'wimax'): void ns3::Tlv::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-tlv.h (module 'wimax'): void ns3::Tlv::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3TraceSourceAccessor_methods(root_module, cls):
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor(ns3::TraceSourceAccessor const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TraceSourceAccessor const &', 'arg0')])
## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor::TraceSourceAccessor() [constructor]
cls.add_constructor([])
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Connect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
cls.add_method('Connect',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::ConnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
cls.add_method('ConnectWithoutContext',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::Disconnect(ns3::ObjectBase * obj, std::string context, ns3::CallbackBase const & cb) const [member function]
cls.add_method('Disconnect',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trace-source-accessor.h (module 'core'): bool ns3::TraceSourceAccessor::DisconnectWithoutContext(ns3::ObjectBase * obj, ns3::CallbackBase const & cb) const [member function]
cls.add_method('DisconnectWithoutContext',
'bool',
[param('ns3::ObjectBase *', 'obj', transfer_ownership=False), param('ns3::CallbackBase const &', 'cb')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
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]
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',
'uint32_t',
[param('ns3::Buffer::Iterator', 'end')],
is_pure_virtual=True, is_virtual=True)
## trailer.h (module 'network'): uint32_t ns3::Trailer::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trailer.h (module 'network'): static ns3::TypeId ns3::Trailer::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## trailer.h (module 'network'): void ns3::Trailer::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## trailer.h (module 'network'): void ns3::Trailer::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::TwoRayGroundPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double frequency, double speed) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'frequency'), param('double', 'speed')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetLambda(double lambda) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'lambda')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
cls.add_method('SetSystemLoss',
'void',
[param('double', 'systemLoss')])
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetMinDistance(double minDistance) [member function]
cls.add_method('SetMinDistance',
'void',
[param('double', 'minDistance')])
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetMinDistance() const [member function]
cls.add_method('GetMinDistance',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetLambda() const [member function]
cls.add_method('GetLambda',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::GetSystemLoss() const [member function]
cls.add_method('GetSystemLoss',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): void ns3::TwoRayGroundPropagationLossModel::SetHeightAboveZ(double heightAboveZ) [member function]
cls.add_method('SetHeightAboveZ',
'void',
[param('double', 'heightAboveZ')])
## propagation-loss-model.h (module 'propagation'): double ns3::TwoRayGroundPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3Ucd_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::Ucd::Ucd(ns3::Ucd const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Ucd const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::Ucd::Ucd() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::AddUlBurstProfile(ns3::OfdmUlBurstProfile ulBurstProfile) [member function]
cls.add_method('AddUlBurstProfile',
'void',
[param('ns3::OfdmUlBurstProfile', 'ulBurstProfile')])
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::Ucd::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ul-mac-messages.h (module 'wimax'): ns3::OfdmUcdChannelEncodings ns3::Ucd::GetChannelEncodings() const [member function]
cls.add_method('GetChannelEncodings',
'ns3::OfdmUcdChannelEncodings',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::TypeId ns3::Ucd::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): std::string ns3::Ucd::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetNrUlBurstProfiles() const [member function]
cls.add_method('GetNrUlBurstProfiles',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRangingBackoffEnd() const [member function]
cls.add_method('GetRangingBackoffEnd',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRangingBackoffStart() const [member function]
cls.add_method('GetRangingBackoffStart',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRequestBackoffEnd() const [member function]
cls.add_method('GetRequestBackoffEnd',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::Ucd::GetRequestBackoffStart() const [member function]
cls.add_method('GetRequestBackoffStart',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::Ucd::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::Ucd::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ul-mac-messages.h (module 'wimax'): std::vector<ns3::OfdmUlBurstProfile, std::allocator<ns3::OfdmUlBurstProfile> > ns3::Ucd::GetUlBurstProfiles() const [member function]
cls.add_method('GetUlBurstProfiles',
'std::vector< ns3::OfdmUlBurstProfile >',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetChannelEncodings(ns3::OfdmUcdChannelEncodings channelEncodings) [member function]
cls.add_method('SetChannelEncodings',
'void',
[param('ns3::OfdmUcdChannelEncodings', 'channelEncodings')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetConfigurationChangeCount(uint8_t ucdCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'ucdCount')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetNrUlBurstProfiles(uint8_t nrUlBurstProfiles) [member function]
cls.add_method('SetNrUlBurstProfiles',
'void',
[param('uint8_t', 'nrUlBurstProfiles')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRangingBackoffEnd(uint8_t rangingBackoffEnd) [member function]
cls.add_method('SetRangingBackoffEnd',
'void',
[param('uint8_t', 'rangingBackoffEnd')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRangingBackoffStart(uint8_t rangingBackoffStart) [member function]
cls.add_method('SetRangingBackoffStart',
'void',
[param('uint8_t', 'rangingBackoffStart')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRequestBackoffEnd(uint8_t requestBackoffEnd) [member function]
cls.add_method('SetRequestBackoffEnd',
'void',
[param('uint8_t', 'requestBackoffEnd')])
## ul-mac-messages.h (module 'wimax'): void ns3::Ucd::SetRequestBackoffStart(uint8_t requestBackoffStart) [member function]
cls.add_method('SetRequestBackoffStart',
'void',
[param('uint8_t', 'requestBackoffStart')])
return
def register_Ns3UlJob_methods(root_module, cls):
cls.add_binary_comparison_operator('==')
## ul-job.h (module 'wimax'): ns3::UlJob::UlJob(ns3::UlJob const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UlJob const &', 'arg0')])
## ul-job.h (module 'wimax'): ns3::UlJob::UlJob() [constructor]
cls.add_constructor([])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetDeadline() [member function]
cls.add_method('GetDeadline',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetPeriod() [member function]
cls.add_method('GetPeriod',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::Time ns3::UlJob::GetReleaseTime() [member function]
cls.add_method('GetReleaseTime',
'ns3::Time',
[])
## ul-job.h (module 'wimax'): ns3::ServiceFlow::SchedulingType ns3::UlJob::GetSchedulingType() [member function]
cls.add_method('GetSchedulingType',
'ns3::ServiceFlow::SchedulingType',
[])
## ul-job.h (module 'wimax'): ns3::ServiceFlow * ns3::UlJob::GetServiceFlow() [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[])
## ul-job.h (module 'wimax'): uint32_t ns3::UlJob::GetSize() [member function]
cls.add_method('GetSize',
'uint32_t',
[])
## ul-job.h (module 'wimax'): ns3::SSRecord * ns3::UlJob::GetSsRecord() [member function]
cls.add_method('GetSsRecord',
'ns3::SSRecord *',
[])
## ul-job.h (module 'wimax'): ns3::ReqType ns3::UlJob::GetType() [member function]
cls.add_method('GetType',
'ns3::ReqType',
[])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetDeadline(ns3::Time deadline) [member function]
cls.add_method('SetDeadline',
'void',
[param('ns3::Time', 'deadline')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetPeriod(ns3::Time period) [member function]
cls.add_method('SetPeriod',
'void',
[param('ns3::Time', 'period')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetReleaseTime(ns3::Time releaseTime) [member function]
cls.add_method('SetReleaseTime',
'void',
[param('ns3::Time', 'releaseTime')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSchedulingType(ns3::ServiceFlow::SchedulingType schedulingType) [member function]
cls.add_method('SetSchedulingType',
'void',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSize(uint32_t size) [member function]
cls.add_method('SetSize',
'void',
[param('uint32_t', 'size')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetSsRecord(ns3::SSRecord * ssRecord) [member function]
cls.add_method('SetSsRecord',
'void',
[param('ns3::SSRecord *', 'ssRecord')])
## ul-job.h (module 'wimax'): void ns3::UlJob::SetType(ns3::ReqType type) [member function]
cls.add_method('SetType',
'void',
[param('ns3::ReqType', 'type')])
return
def register_Ns3UlMap_methods(root_module, cls):
## ul-mac-messages.h (module 'wimax'): ns3::UlMap::UlMap(ns3::UlMap const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UlMap const &', 'arg0')])
## ul-mac-messages.h (module 'wimax'): ns3::UlMap::UlMap() [constructor]
cls.add_constructor([])
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::AddUlMapElement(ns3::OfdmUlMapIe ulMapElement) [member function]
cls.add_method('AddUlMapElement',
'void',
[param('ns3::OfdmUlMapIe', 'ulMapElement')])
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::GetAllocationStartTime() const [member function]
cls.add_method('GetAllocationStartTime',
'uint32_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): ns3::TypeId ns3::UlMap::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): std::string ns3::UlMap::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): uint32_t ns3::UlMap::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::UlMap::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ul-mac-messages.h (module 'wimax'): uint8_t ns3::UlMap::GetUcdCount() const [member function]
cls.add_method('GetUcdCount',
'uint8_t',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UlMap::GetUlMapElements() const [member function]
cls.add_method('GetUlMapElements',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::SetAllocationStartTime(uint32_t allocationStartTime) [member function]
cls.add_method('SetAllocationStartTime',
'void',
[param('uint32_t', 'allocationStartTime')])
## ul-mac-messages.h (module 'wimax'): void ns3::UlMap::SetUcdCount(uint8_t ucdCount) [member function]
cls.add_method('SetUcdCount',
'void',
[param('uint8_t', 'ucdCount')])
return
def register_Ns3UplinkScheduler_methods(root_module, cls):
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler(ns3::UplinkScheduler const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkScheduler const &', 'arg0')])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler.h (module 'wimax'): ns3::UplinkScheduler::UplinkScheduler(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): uint32_t ns3::UplinkScheduler::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Ptr<ns3::BaseStationNetDevice> ns3::UplinkScheduler::GetBs() [member function]
cls.add_method('GetBs',
'ns3::Ptr< ns3::BaseStationNetDevice >',
[],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetDcdTimeStamp() const [member function]
cls.add_method('GetDcdTimeStamp',
'ns3::Time',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::GetIsInvIrIntrvlAllocated() const [member function]
cls.add_method('GetIsInvIrIntrvlAllocated',
'bool',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::GetIsIrIntrvlAllocated() const [member function]
cls.add_method('GetIsIrIntrvlAllocated',
'bool',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): uint8_t ns3::UplinkScheduler::GetNrIrOppsAllocated() const [member function]
cls.add_method('GetNrIrOppsAllocated',
'uint8_t',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetTimeStampIrInterval() [member function]
cls.add_method('GetTimeStampIrInterval',
'ns3::Time',
[],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): static ns3::TypeId ns3::UplinkScheduler::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler.h (module 'wimax'): ns3::Time ns3::UplinkScheduler::GetUcdTimeStamp() const [member function]
cls.add_method('GetUcdTimeStamp',
'ns3::Time',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkScheduler::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): bool ns3::UplinkScheduler::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetBs(ns3::Ptr<ns3::BaseStationNetDevice> bs) [member function]
cls.add_method('SetBs',
'void',
[param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetDcdTimeStamp(ns3::Time dcdTimeStamp) [member function]
cls.add_method('SetDcdTimeStamp',
'void',
[param('ns3::Time', 'dcdTimeStamp')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetIsInvIrIntrvlAllocated(bool isInvIrIntrvlAllocated) [member function]
cls.add_method('SetIsInvIrIntrvlAllocated',
'void',
[param('bool', 'isInvIrIntrvlAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetIsIrIntrvlAllocated(bool isIrIntrvlAllocated) [member function]
cls.add_method('SetIsIrIntrvlAllocated',
'void',
[param('bool', 'isIrIntrvlAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetNrIrOppsAllocated(uint8_t nrIrOppsAllocated) [member function]
cls.add_method('SetNrIrOppsAllocated',
'void',
[param('uint8_t', 'nrIrOppsAllocated')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetTimeStampIrInterval(ns3::Time timeStampIrInterval) [member function]
cls.add_method('SetTimeStampIrInterval',
'void',
[param('ns3::Time', 'timeStampIrInterval')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetUcdTimeStamp(ns3::Time ucdTimeStamp) [member function]
cls.add_method('SetUcdTimeStamp',
'void',
[param('ns3::Time', 'ucdTimeStamp')],
is_virtual=True)
## bs-uplink-scheduler.h (module 'wimax'): void ns3::UplinkScheduler::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_pure_virtual=True, is_virtual=True)
return
def register_Ns3UplinkSchedulerMBQoS_methods(root_module, cls):
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS(ns3::UplinkSchedulerMBQoS const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerMBQoS const &', 'arg0')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::UplinkSchedulerMBQoS::UplinkSchedulerMBQoS(ns3::Time time) [constructor]
cls.add_constructor([param('ns3::Time', 'time')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::CheckDeadline(uint32_t & availableSymbols) [member function]
cls.add_method('CheckDeadline',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::CheckMinimumBandwidth(uint32_t & availableSymbols) [member function]
cls.add_method('CheckMinimumBandwidth',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CountSymbolsJobs(ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('CountSymbolsJobs',
'uint32_t',
[param('ns3::Ptr< ns3::UlJob >', 'job')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::CountSymbolsQueue(std::list<ns3::Ptr<ns3::UlJob>, std::allocator<ns3::Ptr<ns3::UlJob> > > jobs) [member function]
cls.add_method('CountSymbolsQueue',
'uint32_t',
[param('std::list< ns3::Ptr< ns3::UlJob > >', 'jobs')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::UplinkSchedulerMBQoS::CreateUlJob(ns3::SSRecord * ssRecord, ns3::ServiceFlow::SchedulingType schedType, ns3::ReqType reqType) [member function]
cls.add_method('CreateUlJob',
'ns3::Ptr< ns3::UlJob >',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedType'), param('ns3::ReqType', 'reqType')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Ptr<ns3::UlJob> ns3::UplinkSchedulerMBQoS::DequeueJob(ns3::UlJob::JobPriority priority) [member function]
cls.add_method('DequeueJob',
'ns3::Ptr< ns3::UlJob >',
[param('ns3::UlJob::JobPriority', 'priority')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): ns3::Time ns3::UplinkSchedulerMBQoS::DetermineDeadline(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('DetermineDeadline',
'ns3::Time',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::EnqueueJob(ns3::UlJob::JobPriority priority, ns3::Ptr<ns3::UlJob> job) [member function]
cls.add_method('EnqueueJob',
'void',
[param('ns3::UlJob::JobPriority', 'priority'), param('ns3::Ptr< ns3::UlJob >', 'job')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): uint32_t ns3::UplinkSchedulerMBQoS::GetPendingSize(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('GetPendingSize',
'uint32_t',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerMBQoS::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerMBQoS::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): bool ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): bool ns3::UplinkSchedulerMBQoS::ServiceBandwidthRequestsBytes(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols, uint32_t allocationSizeBytes) [member function]
cls.add_method('ServiceBandwidthRequestsBytes',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols'), param('uint32_t', 'allocationSizeBytes')])
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
## bs-uplink-scheduler-mbqos.h (module 'wimax'): void ns3::UplinkSchedulerMBQoS::UplinkSchedWindowTimer() [member function]
cls.add_method('UplinkSchedWindowTimer',
'void',
[])
return
def register_Ns3UplinkSchedulerRtps_methods(root_module, cls):
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps(ns3::UplinkSchedulerRtps const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerRtps const &', 'arg0')])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-rtps.h (module 'wimax'): ns3::UplinkSchedulerRtps::UplinkSchedulerRtps(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): uint32_t ns3::UplinkSchedulerRtps::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerRtps::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerRtps::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): bool ns3::UplinkSchedulerRtps::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
## bs-uplink-scheduler-rtps.h (module 'wimax'): void ns3::UplinkSchedulerRtps::ULSchedulerRTPSConnection(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ULSchedulerRTPSConnection',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')])
return
def register_Ns3UplinkSchedulerSimple_methods(root_module, cls):
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple(ns3::UplinkSchedulerSimple const & arg0) [copy constructor]
cls.add_constructor([param('ns3::UplinkSchedulerSimple const &', 'arg0')])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple() [constructor]
cls.add_constructor([])
## bs-uplink-scheduler-simple.h (module 'wimax'): ns3::UplinkSchedulerSimple::UplinkSchedulerSimple(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::AddUplinkAllocation(ns3::OfdmUlMapIe & ulMapIe, uint32_t const & allocationSize, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AddUplinkAllocation',
'void',
[param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('uint32_t const &', 'allocationSize'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::AllocateInitialRangingInterval(uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('AllocateInitialRangingInterval',
'void',
[param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): uint32_t ns3::UplinkSchedulerSimple::CalculateAllocationStartTime() [member function]
cls.add_method('CalculateAllocationStartTime',
'uint32_t',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::GetChannelDescriptorsToUpdate(bool & arg0, bool & arg1, bool & arg2, bool & arg3) [member function]
cls.add_method('GetChannelDescriptorsToUpdate',
'void',
[param('bool &', 'arg0'), param('bool &', 'arg1'), param('bool &', 'arg2'), param('bool &', 'arg3')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): static ns3::TypeId ns3::UplinkSchedulerSimple::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): std::list<ns3::OfdmUlMapIe, std::allocator<ns3::OfdmUlMapIe> > ns3::UplinkSchedulerSimple::GetUplinkAllocations() const [member function]
cls.add_method('GetUplinkAllocations',
'std::list< ns3::OfdmUlMapIe >',
[],
is_const=True, is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::InitOnce() [member function]
cls.add_method('InitOnce',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::OnSetRequestedBandwidth(ns3::ServiceFlowRecord * sfr) [member function]
cls.add_method('OnSetRequestedBandwidth',
'void',
[param('ns3::ServiceFlowRecord *', 'sfr')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ProcessBandwidthRequest(ns3::BandwidthRequestHeader const & bwRequestHdr) [member function]
cls.add_method('ProcessBandwidthRequest',
'void',
[param('ns3::BandwidthRequestHeader const &', 'bwRequestHdr')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ServiceBandwidthRequests(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): bool ns3::UplinkSchedulerSimple::ServiceBandwidthRequests(ns3::ServiceFlow * serviceFlow, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceBandwidthRequests',
'bool',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::ServiceUnsolicitedGrants(ns3::SSRecord const * ssRecord, ns3::ServiceFlow::SchedulingType schedulingType, ns3::OfdmUlMapIe & ulMapIe, ns3::WimaxPhy::ModulationType const modulationType, uint32_t & symbolsToAllocation, uint32_t & availableSymbols) [member function]
cls.add_method('ServiceUnsolicitedGrants',
'void',
[param('ns3::SSRecord const *', 'ssRecord'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType'), param('ns3::OfdmUlMapIe &', 'ulMapIe'), param('ns3::WimaxPhy::ModulationType const', 'modulationType'), param('uint32_t &', 'symbolsToAllocation'), param('uint32_t &', 'availableSymbols')],
is_virtual=True)
## bs-uplink-scheduler-simple.h (module 'wimax'): void ns3::UplinkSchedulerSimple::SetupServiceFlow(ns3::SSRecord * ssRecord, ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetupServiceFlow',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::ServiceFlow *', 'serviceFlow')],
is_virtual=True)
return
def register_Ns3WimaxConnection_methods(root_module, cls):
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection::WimaxConnection(ns3::WimaxConnection const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxConnection const &', 'arg0')])
## wimax-connection.h (module 'wimax'): ns3::WimaxConnection::WimaxConnection(ns3::Cid cid, ns3::Cid::Type type) [constructor]
cls.add_constructor([param('ns3::Cid', 'cid'), param('ns3::Cid::Type', 'type')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::ClearFragmentsQueue() [member function]
cls.add_method('ClearFragmentsQueue',
'void',
[])
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxConnection::Dequeue(ns3::MacHeaderType::HeaderType packetType=::ns3::MacHeaderType::HEADER_TYPE_GENERIC) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType', default_value='::ns3::MacHeaderType::HEADER_TYPE_GENERIC')])
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxConnection::Dequeue(ns3::MacHeaderType::HeaderType packetType, uint32_t availableByte) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'availableByte')])
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::GenericMacHeader const & hdr) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::GenericMacHeader const &', 'hdr')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::FragmentEnqueue(ns3::Ptr<const ns3::Packet> fragment) [member function]
cls.add_method('FragmentEnqueue',
'void',
[param('ns3::Ptr< ns3::Packet const >', 'fragment')])
## wimax-connection.h (module 'wimax'): ns3::Cid ns3::WimaxConnection::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): std::list<ns3::Ptr<ns3::Packet const>, std::allocator<ns3::Ptr<ns3::Packet const> > > const ns3::WimaxConnection::GetFragmentsQueue() const [member function]
cls.add_method('GetFragmentsQueue',
'std::list< ns3::Ptr< ns3::Packet const > > const',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::Ptr<ns3::WimaxMacQueue> ns3::WimaxConnection::GetQueue() const [member function]
cls.add_method('GetQueue',
'ns3::Ptr< ns3::WimaxMacQueue >',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): uint8_t ns3::WimaxConnection::GetSchedulingType() const [member function]
cls.add_method('GetSchedulingType',
'uint8_t',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::ServiceFlow * ns3::WimaxConnection::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): ns3::Cid::Type ns3::WimaxConnection::GetType() const [member function]
cls.add_method('GetType',
'ns3::Cid::Type',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): static ns3::TypeId ns3::WimaxConnection::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-connection.h (module 'wimax'): std::string ns3::WimaxConnection::GetTypeStr() const [member function]
cls.add_method('GetTypeStr',
'std::string',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## wimax-connection.h (module 'wimax'): bool ns3::WimaxConnection::HasPackets(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('HasPackets',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::SetServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## wimax-connection.h (module 'wimax'): void ns3::WimaxConnection::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3WimaxMacQueue_methods(root_module, cls):
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue(ns3::WimaxMacQueue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxMacQueue const &', 'arg0')])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue() [constructor]
cls.add_constructor([])
## wimax-mac-queue.h (module 'wimax'): ns3::WimaxMacQueue::WimaxMacQueue(uint32_t maxSize) [constructor]
cls.add_constructor([param('uint32_t', 'maxSize')])
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::CheckForFragmentation(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('CheckForFragmentation',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Dequeue(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Dequeue(ns3::MacHeaderType::HeaderType packetType, uint32_t availableByte) [member function]
cls.add_method('Dequeue',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'availableByte')])
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::GenericMacHeader const & hdr) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::GenericMacHeader const &', 'hdr')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketHdrSize(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketHdrSize',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketPayloadSize(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketPayloadSize',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetFirstPacketRequiredByte(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('GetFirstPacketRequiredByte',
'uint32_t',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetMaxSize() const [member function]
cls.add_method('GetMaxSize',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetNBytes() const [member function]
cls.add_method('GetNBytes',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): std::deque<ns3::WimaxMacQueue::QueueElement, std::allocator<ns3::WimaxMacQueue::QueueElement> > const & ns3::WimaxMacQueue::GetPacketQueue() const [member function]
cls.add_method('GetPacketQueue',
'std::deque< ns3::WimaxMacQueue::QueueElement > const &',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetQueueLengthWithMACOverhead() [member function]
cls.add_method('GetQueueLengthWithMACOverhead',
'uint32_t',
[])
## wimax-mac-queue.h (module 'wimax'): uint32_t ns3::WimaxMacQueue::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): static ns3::TypeId ns3::WimaxMacQueue::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::IsEmpty() const [member function]
cls.add_method('IsEmpty',
'bool',
[],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): bool ns3::WimaxMacQueue::IsEmpty(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('IsEmpty',
'bool',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::GenericMacHeader & hdr) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::GenericMacHeader &', 'hdr')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::GenericMacHeader & hdr, ns3::Time & timeStamp) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::GenericMacHeader &', 'hdr'), param('ns3::Time &', 'timeStamp')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::MacHeaderType::HeaderType packetType) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): ns3::Ptr<ns3::Packet> ns3::WimaxMacQueue::Peek(ns3::MacHeaderType::HeaderType packetType, ns3::Time & timeStamp) const [member function]
cls.add_method('Peek',
'ns3::Ptr< ns3::Packet >',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('ns3::Time &', 'timeStamp')],
is_const=True)
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentNumber(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('SetFragmentNumber',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentOffset(ns3::MacHeaderType::HeaderType packetType, uint32_t offset) [member function]
cls.add_method('SetFragmentOffset',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType'), param('uint32_t', 'offset')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetFragmentation(ns3::MacHeaderType::HeaderType packetType) [member function]
cls.add_method('SetFragmentation',
'void',
[param('ns3::MacHeaderType::HeaderType', 'packetType')])
## wimax-mac-queue.h (module 'wimax'): void ns3::WimaxMacQueue::SetMaxSize(uint32_t maxSize) [member function]
cls.add_method('SetMaxSize',
'void',
[param('uint32_t', 'maxSize')])
return
def register_Ns3WimaxMacToMacHeader_methods(root_module, cls):
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader(ns3::WimaxMacToMacHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxMacToMacHeader const &', 'arg0')])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader() [constructor]
cls.add_constructor([])
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::WimaxMacToMacHeader::WimaxMacToMacHeader(uint32_t len) [constructor]
cls.add_constructor([param('uint32_t', 'len')])
## wimax-mac-to-mac-header.h (module 'wimax'): uint32_t ns3::WimaxMacToMacHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): ns3::TypeId ns3::WimaxMacToMacHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): uint32_t ns3::WimaxMacToMacHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): uint8_t ns3::WimaxMacToMacHeader::GetSizeOfLen() const [member function]
cls.add_method('GetSizeOfLen',
'uint8_t',
[],
is_const=True)
## wimax-mac-to-mac-header.h (module 'wimax'): static ns3::TypeId ns3::WimaxMacToMacHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-to-mac-header.h (module 'wimax'): void ns3::WimaxMacToMacHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-to-mac-header.h (module 'wimax'): void ns3::WimaxMacToMacHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
return
def register_Ns3WimaxPhy_methods(root_module, cls):
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::WimaxPhy(ns3::WimaxPhy const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxPhy const &', 'arg0')])
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::WimaxPhy() [constructor]
cls.add_constructor([])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::Attach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::WimaxChannel> ns3::WimaxPhy::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::WimaxChannel >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetChannelBandwidth() const [member function]
cls.add_method('GetChannelBandwidth',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::EventId ns3::WimaxPhy::GetChnlSrchTimeoutEvent() const [member function]
cls.add_method('GetChnlSrchTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxPhy::GetDevice() const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDuration() const [member function]
cls.add_method('GetFrameDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('GetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::GetFrameDurationCode() const [member function]
cls.add_method('GetFrameDurationCode',
'uint8_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetFrameDurationSec() const [member function]
cls.add_method('GetFrameDurationSec',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetFrequency() const [member function]
cls.add_method('GetFrequency',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetGValue() const [member function]
cls.add_method('GetGValue',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Ptr<ns3::Object> ns3::WimaxPhy::GetMobility() [member function]
cls.add_method('GetMobility',
'ns3::Ptr< ns3::Object >',
[],
is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetNfft() const [member function]
cls.add_method('GetNfft',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::GetNrCarriers() const [member function]
cls.add_method('GetNrCarriers',
'uint8_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType ns3::WimaxPhy::GetPhyType() const [member function]
cls.add_method('GetPhyType',
'ns3::WimaxPhy::PhyType',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetPsDuration() const [member function]
cls.add_method('GetPsDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetPsPerFrame() const [member function]
cls.add_method('GetPsPerFrame',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetPsPerSymbol() const [member function]
cls.add_method('GetPsPerSymbol',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Callback<void, ns3::Ptr<ns3::PacketBurst const>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> ns3::WimaxPhy::GetReceiveCallback() const [member function]
cls.add_method('GetReceiveCallback',
'ns3::Callback< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetRxFrequency() const [member function]
cls.add_method('GetRxFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetSamplingFactor() const [member function]
cls.add_method('GetSamplingFactor',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::GetSamplingFrequency() const [member function]
cls.add_method('GetSamplingFrequency',
'double',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetScanningFrequency() const [member function]
cls.add_method('GetScanningFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyState ns3::WimaxPhy::GetState() const [member function]
cls.add_method('GetState',
'ns3::WimaxPhy::PhyState',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetSymbolDuration() const [member function]
cls.add_method('GetSymbolDuration',
'ns3::Time',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::GetSymbolsPerFrame() const [member function]
cls.add_method('GetSymbolsPerFrame',
'uint32_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::GetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('GetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint16_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::GetTxFrequency() const [member function]
cls.add_method('GetTxFrequency',
'uint64_t',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): static ns3::TypeId ns3::WimaxPhy::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-phy.h (module 'wimax'): bool ns3::WimaxPhy::IsDuplex() const [member function]
cls.add_method('IsDuplex',
'bool',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::Send(ns3::SendParams * params) [member function]
cls.add_method('Send',
'void',
[param('ns3::SendParams *', 'params')],
is_pure_virtual=True, is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetChannelBandwidth(uint32_t channelBandwidth) [member function]
cls.add_method('SetChannelBandwidth',
'void',
[param('uint32_t', 'channelBandwidth')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDataRates() [member function]
cls.add_method('SetDataRates',
'void',
[])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDevice(ns3::Ptr<ns3::WimaxNetDevice> device) [member function]
cls.add_method('SetDevice',
'void',
[param('ns3::Ptr< ns3::WimaxNetDevice >', 'device')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetDuplex(uint64_t rxFrequency, uint64_t txFrequency) [member function]
cls.add_method('SetDuplex',
'void',
[param('uint64_t', 'rxFrequency'), param('uint64_t', 'txFrequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetFrameDuration(ns3::Time frameDuration) [member function]
cls.add_method('SetFrameDuration',
'void',
[param('ns3::Time', 'frameDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetFrequency(uint32_t frequency) [member function]
cls.add_method('SetFrequency',
'void',
[param('uint32_t', 'frequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetMobility(ns3::Ptr<ns3::Object> mobility) [member function]
cls.add_method('SetMobility',
'void',
[param('ns3::Ptr< ns3::Object >', 'mobility')],
is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetNrCarriers(uint8_t nrCarriers) [member function]
cls.add_method('SetNrCarriers',
'void',
[param('uint8_t', 'nrCarriers')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPhyParameters() [member function]
cls.add_method('SetPhyParameters',
'void',
[])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsDuration(ns3::Time psDuration) [member function]
cls.add_method('SetPsDuration',
'void',
[param('ns3::Time', 'psDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsPerFrame(uint16_t psPerFrame) [member function]
cls.add_method('SetPsPerFrame',
'void',
[param('uint16_t', 'psPerFrame')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetPsPerSymbol(uint16_t psPerSymbol) [member function]
cls.add_method('SetPsPerSymbol',
'void',
[param('uint16_t', 'psPerSymbol')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetReceiveCallback(ns3::Callback<void, ns3::Ptr<ns3::PacketBurst const>, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('SetReceiveCallback',
'void',
[param('ns3::Callback< void, ns3::Ptr< ns3::PacketBurst const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetScanningCallback() const [member function]
cls.add_method('SetScanningCallback',
'void',
[],
is_const=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSimplex(uint64_t frequency) [member function]
cls.add_method('SetSimplex',
'void',
[param('uint64_t', 'frequency')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetState(ns3::WimaxPhy::PhyState state) [member function]
cls.add_method('SetState',
'void',
[param('ns3::WimaxPhy::PhyState', 'state')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSymbolDuration(ns3::Time symbolDuration) [member function]
cls.add_method('SetSymbolDuration',
'void',
[param('ns3::Time', 'symbolDuration')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::SetSymbolsPerFrame(uint32_t symbolsPerFrame) [member function]
cls.add_method('SetSymbolsPerFrame',
'void',
[param('uint32_t', 'symbolsPerFrame')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::StartScanning(uint64_t frequency, ns3::Time timeout, ns3::Callback<void, bool, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('StartScanning',
'void',
[param('uint64_t', 'frequency'), param('ns3::Time', 'timeout'), param('ns3::Callback< void, bool, unsigned long, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoAttach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint32_t ns3::WimaxPhy::DoGetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::DoGetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('DoGetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint8_t ns3::WimaxPhy::DoGetFrameDurationCode() const [member function]
cls.add_method('DoGetFrameDurationCode',
'uint8_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetGValue() const [member function]
cls.add_method('DoGetGValue',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetNfft() const [member function]
cls.add_method('DoGetNfft',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::DoGetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint64_t ns3::WimaxPhy::DoGetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetRtg() const [member function]
cls.add_method('DoGetRtg',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetSamplingFactor() const [member function]
cls.add_method('DoGetSamplingFactor',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): double ns3::WimaxPhy::DoGetSamplingFrequency() const [member function]
cls.add_method('DoGetSamplingFrequency',
'double',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): ns3::Time ns3::WimaxPhy::DoGetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): uint16_t ns3::WimaxPhy::DoGetTtg() const [member function]
cls.add_method('DoGetTtg',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoSetDataRates() [member function]
cls.add_method('DoSetDataRates',
'void',
[],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-phy.h (module 'wimax'): void ns3::WimaxPhy::DoSetPhyParameters() [member function]
cls.add_method('DoSetPhyParameters',
'void',
[],
is_pure_virtual=True, visibility='private', is_virtual=True)
return
def register_Ns3AttributeAccessor_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor(ns3::AttributeAccessor const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeAccessor const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeAccessor::AttributeAccessor() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): bool ns3::AttributeAccessor::Get(ns3::ObjectBase const * object, ns3::AttributeValue & attribute) const [member function]
cls.add_method('Get',
'bool',
[param('ns3::ObjectBase const *', 'object'), param('ns3::AttributeValue &', 'attribute')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasGetter() const [member function]
cls.add_method('HasGetter',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::HasSetter() const [member function]
cls.add_method('HasSetter',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeAccessor::Set(ns3::ObjectBase * object, ns3::AttributeValue const & value) const [member function]
cls.add_method('Set',
'bool',
[param('ns3::ObjectBase *', 'object', transfer_ownership=False), param('ns3::AttributeValue const &', 'value')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3AttributeChecker_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker(ns3::AttributeChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeChecker const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeChecker::AttributeChecker() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): bool ns3::AttributeChecker::Check(ns3::AttributeValue const & value) const [member function]
cls.add_method('Check',
'bool',
[param('ns3::AttributeValue const &', 'value')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeChecker::Copy(ns3::AttributeValue const & source, ns3::AttributeValue & destination) const [member function]
cls.add_method('Copy',
'bool',
[param('ns3::AttributeValue const &', 'source'), param('ns3::AttributeValue &', 'destination')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::Create() const [member function]
cls.add_method('Create',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeChecker::CreateValidValue(ns3::AttributeValue const & value) const [member function]
cls.add_method('CreateValidValue',
'ns3::Ptr< ns3::AttributeValue >',
[param('ns3::AttributeValue const &', 'value')],
is_const=True)
## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetUnderlyingTypeInformation() const [member function]
cls.add_method('GetUnderlyingTypeInformation',
'std::string',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): std::string ns3::AttributeChecker::GetValueTypeName() const [member function]
cls.add_method('GetValueTypeName',
'std::string',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## attribute.h (module 'core'): bool ns3::AttributeChecker::HasUnderlyingTypeInformation() const [member function]
cls.add_method('HasUnderlyingTypeInformation',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3AttributeValue_methods(root_module, cls):
## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue(ns3::AttributeValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::AttributeValue const &', 'arg0')])
## attribute.h (module 'core'): ns3::AttributeValue::AttributeValue() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeValue::Copy() const [member function]
cls.add_method('Copy',
'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<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> 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_Ns3BSScheduler_methods(root_module, cls):
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler(ns3::BSScheduler const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSScheduler const &', 'arg0')])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler() [constructor]
cls.add_constructor([])
## bs-scheduler.h (module 'wimax'): ns3::BSScheduler::BSScheduler(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): bool ns3::BSScheduler::CheckForFragmentation(ns3::Ptr<ns3::WimaxConnection> connection, int availableSymbols, ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('CheckForFragmentation',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('int', 'availableSymbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## bs-scheduler.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSScheduler::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): ns3::Ptr<ns3::BaseStationNetDevice> ns3::BSScheduler::GetBs() [member function]
cls.add_method('GetBs',
'ns3::Ptr< ns3::BaseStationNetDevice >',
[],
is_virtual=True)
## bs-scheduler.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSScheduler::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): static ns3::TypeId ns3::BSScheduler::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): bool ns3::BSScheduler::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_pure_virtual=True, is_virtual=True)
## bs-scheduler.h (module 'wimax'): void ns3::BSScheduler::SetBs(ns3::Ptr<ns3::BaseStationNetDevice> bs) [member function]
cls.add_method('SetBs',
'void',
[param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')],
is_virtual=True)
return
def register_Ns3BSSchedulerRtps_methods(root_module, cls):
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps(ns3::BSSchedulerRtps const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSSchedulerRtps const &', 'arg0')])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps() [constructor]
cls.add_constructor([])
## bs-scheduler-rtps.h (module 'wimax'): ns3::BSSchedulerRtps::BSSchedulerRtps(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBEConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBEConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBasicConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBasicConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerBroadcastConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerBroadcastConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerInitialRangingConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerInitialRangingConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerNRTPSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerNRTPSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerPrimaryConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerPrimaryConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerRTPSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerRTPSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::BSSchedulerUGSConnection(uint32_t & availableSymbols) [member function]
cls.add_method('BSSchedulerUGSConnection',
'void',
[param('uint32_t &', 'availableSymbols')])
## bs-scheduler-rtps.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSSchedulerRtps::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSSchedulerRtps::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_const=True, is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): static ns3::TypeId ns3::BSSchedulerRtps::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler-rtps.h (module 'wimax'): void ns3::BSSchedulerRtps::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectBEConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectBEConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_virtual=True)
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectIRandBCConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectIRandBCConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectMenagementConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectMenagementConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectNRTPSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectNRTPSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectRTPSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectRTPSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
## bs-scheduler-rtps.h (module 'wimax'): bool ns3::BSSchedulerRtps::SelectUGSConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectUGSConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')])
return
def register_Ns3BSSchedulerSimple_methods(root_module, cls):
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple(ns3::BSSchedulerSimple const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BSSchedulerSimple const &', 'arg0')])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple() [constructor]
cls.add_constructor([])
## bs-scheduler-simple.h (module 'wimax'): ns3::BSSchedulerSimple::BSSchedulerSimple(ns3::Ptr<ns3::BaseStationNetDevice> bs) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'bs')])
## bs-scheduler-simple.h (module 'wimax'): void ns3::BSSchedulerSimple::AddDownlinkBurst(ns3::Ptr<const ns3::WimaxConnection> connection, uint8_t diuc, ns3::WimaxPhy::ModulationType modulationType, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('AddDownlinkBurst',
'void',
[param('ns3::Ptr< ns3::WimaxConnection const >', 'connection'), param('uint8_t', 'diuc'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): ns3::Ptr<ns3::PacketBurst> ns3::BSSchedulerSimple::CreateUgsBurst(ns3::ServiceFlow * serviceFlow, ns3::WimaxPhy::ModulationType modulationType, uint32_t availableSymbols) [member function]
cls.add_method('CreateUgsBurst',
'ns3::Ptr< ns3::PacketBurst >',
[param('ns3::ServiceFlow *', 'serviceFlow'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint32_t', 'availableSymbols')],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): std::list<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> >,std::allocator<std::pair<ns3::OfdmDlMapIe*, ns3::Ptr<ns3::PacketBurst> > > > * ns3::BSSchedulerSimple::GetDownlinkBursts() const [member function]
cls.add_method('GetDownlinkBursts',
'std::list< std::pair< ns3::OfdmDlMapIe *, ns3::Ptr< ns3::PacketBurst > > > *',
[],
is_const=True, is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): static ns3::TypeId ns3::BSSchedulerSimple::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-scheduler-simple.h (module 'wimax'): void ns3::BSSchedulerSimple::Schedule() [member function]
cls.add_method('Schedule',
'void',
[],
is_virtual=True)
## bs-scheduler-simple.h (module 'wimax'): bool ns3::BSSchedulerSimple::SelectConnection(ns3::Ptr<ns3::WimaxConnection> & connection) [member function]
cls.add_method('SelectConnection',
'bool',
[param('ns3::Ptr< ns3::WimaxConnection > &', 'connection')],
is_virtual=True)
return
def register_Ns3BandwidthRequestHeader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::BandwidthRequestHeader(ns3::BandwidthRequestHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BandwidthRequestHeader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::BandwidthRequestHeader::BandwidthRequestHeader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::GetBr() const [member function]
cls.add_method('GetBr',
'uint32_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::Cid ns3::BandwidthRequestHeader::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetEc() const [member function]
cls.add_method('GetEc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetHt() const [member function]
cls.add_method('GetHt',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::BandwidthRequestHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::BandwidthRequestHeader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::BandwidthRequestHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::BandwidthRequestHeader::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::BandwidthRequestHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetBr(uint32_t br) [member function]
cls.add_method('SetBr',
'void',
[param('uint32_t', 'br')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetEc(uint8_t ec) [member function]
cls.add_method('SetEc',
'void',
[param('uint8_t', 'ec')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetHt(uint8_t HT) [member function]
cls.add_method('SetHt',
'void',
[param('uint8_t', 'HT')])
## wimax-mac-header.h (module 'wimax'): void ns3::BandwidthRequestHeader::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): bool ns3::BandwidthRequestHeader::check_hcs() const [member function]
cls.add_method('check_hcs',
'bool',
[],
is_const=True)
return
def register_Ns3BsServiceFlowManager_methods(root_module, cls):
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::BsServiceFlowManager(ns3::BsServiceFlowManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::BsServiceFlowManager const &', 'arg0')])
## bs-service-flow-manager.h (module 'wimax'): ns3::BsServiceFlowManager::BsServiceFlowManager(ns3::Ptr<ns3::BaseStationNetDevice> device) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::BaseStationNetDevice >', 'device')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AddMulticastServiceFlow(ns3::ServiceFlow sf, ns3::WimaxPhy::ModulationType modulation) [member function]
cls.add_method('AddMulticastServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf'), param('ns3::WimaxPhy::ModulationType', 'modulation')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AddServiceFlow(ns3::ServiceFlow * serviceFlow) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'serviceFlow')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::AllocateServiceFlows(ns3::DsaReq const & dsaReq, ns3::Cid cid) [member function]
cls.add_method('AllocateServiceFlows',
'void',
[param('ns3::DsaReq const &', 'dsaReq'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::EventId ns3::BsServiceFlowManager::GetDsaAckTimeoutEvent() const [member function]
cls.add_method('GetDsaAckTimeoutEvent',
'ns3::EventId',
[],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::GetServiceFlow(uint32_t sfid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('uint32_t', 'sfid')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::GetServiceFlow(ns3::Cid cid) const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow *',
[param('ns3::Cid', 'cid')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): std::vector<ns3::ServiceFlow*,std::allocator<ns3::ServiceFlow*> > ns3::BsServiceFlowManager::GetServiceFlows(ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetServiceFlows',
'std::vector< ns3::ServiceFlow * >',
[param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::ProcessDsaAck(ns3::DsaAck const & dsaAck, ns3::Cid cid) [member function]
cls.add_method('ProcessDsaAck',
'void',
[param('ns3::DsaAck const &', 'dsaAck'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): ns3::ServiceFlow * ns3::BsServiceFlowManager::ProcessDsaReq(ns3::DsaReq const & dsaReq, ns3::Cid cid) [member function]
cls.add_method('ProcessDsaReq',
'ns3::ServiceFlow *',
[param('ns3::DsaReq const &', 'dsaReq'), param('ns3::Cid', 'cid')])
## bs-service-flow-manager.h (module 'wimax'): void ns3::BsServiceFlowManager::SetMaxDsaRspRetries(uint8_t maxDsaRspRetries) [member function]
cls.add_method('SetMaxDsaRspRetries',
'void',
[param('uint8_t', 'maxDsaRspRetries')])
return
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]
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]
cls.add_constructor([param('ns3::CallbackImplBase const &', 'arg0')])
## callback.h (module 'core'): bool ns3::CallbackImplBase::IsEqual(ns3::Ptr<ns3::CallbackImplBase const> other) const [member function]
cls.add_method('IsEqual',
'bool',
[param('ns3::Ptr< ns3::CallbackImplBase const >', 'other')],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
def register_Ns3CallbackValue_methods(root_module, cls):
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::CallbackValue const &', 'arg0')])
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue() [constructor]
cls.add_constructor([])
## callback.h (module 'core'): ns3::CallbackValue::CallbackValue(ns3::CallbackBase const & base) [constructor]
cls.add_constructor([param('ns3::CallbackBase const &', 'base')])
## callback.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::CallbackValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_const=True, is_virtual=True)
## callback.h (module 'core'): bool ns3::CallbackValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## callback.h (module 'core'): void ns3::CallbackValue::Set(ns3::CallbackBase base) [member function]
cls.add_method('Set',
'void',
[param('ns3::CallbackBase', 'base')])
return
def register_Ns3Channel_methods(root_module, cls):
## channel.h (module 'network'): ns3::Channel::Channel(ns3::Channel const & arg0) [copy 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::NetDevice> ns3::Channel::GetDevice(uint32_t i) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[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',
'uint32_t',
[],
is_const=True)
## channel.h (module 'network'): uint32_t ns3::Channel::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## channel.h (module 'network'): static ns3::TypeId ns3::Channel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
def register_Ns3ConnectionManager_methods(root_module, cls):
## connection-manager.h (module 'wimax'): ns3::ConnectionManager::ConnectionManager(ns3::ConnectionManager const & arg0) [copy constructor]
cls.add_constructor([param('ns3::ConnectionManager const &', 'arg0')])
## connection-manager.h (module 'wimax'): ns3::ConnectionManager::ConnectionManager() [constructor]
cls.add_constructor([])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::AddConnection(ns3::Ptr<ns3::WimaxConnection> connection, ns3::Cid::Type type) [member function]
cls.add_method('AddConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('ns3::Cid::Type', 'type')])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::AllocateManagementConnections(ns3::SSRecord * ssRecord, ns3::RngRsp * rngrsp) [member function]
cls.add_method('AllocateManagementConnections',
'void',
[param('ns3::SSRecord *', 'ssRecord'), param('ns3::RngRsp *', 'rngrsp')])
## connection-manager.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ConnectionManager::CreateConnection(ns3::Cid::Type type) [member function]
cls.add_method('CreateConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid::Type', 'type')])
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## connection-manager.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::ConnectionManager::GetConnection(ns3::Cid cid) [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid', 'cid')])
## connection-manager.h (module 'wimax'): std::vector<ns3::Ptr<ns3::WimaxConnection>, std::allocator<ns3::Ptr<ns3::WimaxConnection> > > ns3::ConnectionManager::GetConnections(ns3::Cid::Type type) const [member function]
cls.add_method('GetConnections',
'std::vector< ns3::Ptr< ns3::WimaxConnection > >',
[param('ns3::Cid::Type', 'type')],
is_const=True)
## connection-manager.h (module 'wimax'): uint32_t ns3::ConnectionManager::GetNPackets(ns3::Cid::Type type, ns3::ServiceFlow::SchedulingType schedulingType) const [member function]
cls.add_method('GetNPackets',
'uint32_t',
[param('ns3::Cid::Type', 'type'), param('ns3::ServiceFlow::SchedulingType', 'schedulingType')],
is_const=True)
## connection-manager.h (module 'wimax'): static ns3::TypeId ns3::ConnectionManager::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## connection-manager.h (module 'wimax'): bool ns3::ConnectionManager::HasPackets() const [member function]
cls.add_method('HasPackets',
'bool',
[],
is_const=True)
## connection-manager.h (module 'wimax'): void ns3::ConnectionManager::SetCidFactory(ns3::CidFactory * cidFactory) [member function]
cls.add_method('SetCidFactory',
'void',
[param('ns3::CidFactory *', 'cidFactory')])
return
def register_Ns3Dcd_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::Dcd::Dcd(ns3::Dcd const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Dcd const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::Dcd::Dcd() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::AddDlBurstProfile(ns3::OfdmDlBurstProfile dlBurstProfile) [member function]
cls.add_method('AddDlBurstProfile',
'void',
[param('ns3::OfdmDlBurstProfile', 'dlBurstProfile')])
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::Dcd::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::OfdmDcdChannelEncodings ns3::Dcd::GetChannelEncodings() const [member function]
cls.add_method('GetChannelEncodings',
'ns3::OfdmDcdChannelEncodings',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::Dcd::GetConfigurationChangeCount() const [member function]
cls.add_method('GetConfigurationChangeCount',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): std::vector<ns3::OfdmDlBurstProfile, std::allocator<ns3::OfdmDlBurstProfile> > ns3::Dcd::GetDlBurstProfiles() const [member function]
cls.add_method('GetDlBurstProfiles',
'std::vector< ns3::OfdmDlBurstProfile >',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::TypeId ns3::Dcd::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): std::string ns3::Dcd::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::Dcd::GetNrDlBurstProfiles() const [member function]
cls.add_method('GetNrDlBurstProfiles',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::Dcd::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::Dcd::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetChannelEncodings(ns3::OfdmDcdChannelEncodings channelEncodings) [member function]
cls.add_method('SetChannelEncodings',
'void',
[param('ns3::OfdmDcdChannelEncodings', 'channelEncodings')])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetConfigurationChangeCount(uint8_t configurationChangeCount) [member function]
cls.add_method('SetConfigurationChangeCount',
'void',
[param('uint8_t', 'configurationChangeCount')])
## dl-mac-messages.h (module 'wimax'): void ns3::Dcd::SetNrDlBurstProfiles(uint8_t nrDlBurstProfiles) [member function]
cls.add_method('SetNrDlBurstProfiles',
'void',
[param('uint8_t', 'nrDlBurstProfiles')])
return
def register_Ns3DlMap_methods(root_module, cls):
## dl-mac-messages.h (module 'wimax'): ns3::DlMap::DlMap(ns3::DlMap const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DlMap const &', 'arg0')])
## dl-mac-messages.h (module 'wimax'): ns3::DlMap::DlMap() [constructor]
cls.add_constructor([])
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::AddDlMapElement(ns3::OfdmDlMapIe dlMapElement) [member function]
cls.add_method('AddDlMapElement',
'void',
[param('ns3::OfdmDlMapIe', 'dlMapElement')])
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DlMap::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## dl-mac-messages.h (module 'wimax'): ns3::Mac48Address ns3::DlMap::GetBaseStationId() const [member function]
cls.add_method('GetBaseStationId',
'ns3::Mac48Address',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint8_t ns3::DlMap::GetDcdCount() const [member function]
cls.add_method('GetDcdCount',
'uint8_t',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): std::list<ns3::OfdmDlMapIe, std::allocator<ns3::OfdmDlMapIe> > ns3::DlMap::GetDlMapElements() const [member function]
cls.add_method('GetDlMapElements',
'std::list< ns3::OfdmDlMapIe >',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): ns3::TypeId ns3::DlMap::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): std::string ns3::DlMap::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## dl-mac-messages.h (module 'wimax'): uint32_t ns3::DlMap::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DlMap::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::SetBaseStationId(ns3::Mac48Address baseStationID) [member function]
cls.add_method('SetBaseStationId',
'void',
[param('ns3::Mac48Address', 'baseStationID')])
## dl-mac-messages.h (module 'wimax'): void ns3::DlMap::SetDcdCount(uint8_t dcdCount) [member function]
cls.add_method('SetDcdCount',
'void',
[param('uint8_t', 'dcdCount')])
return
def register_Ns3DsaAck_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaAck::DsaAck(ns3::DsaAck const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaAck const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaAck::DsaAck() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaAck::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaAck::GetConfirmationCode() const [member function]
cls.add_method('GetConfirmationCode',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaAck::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaAck::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaAck::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaAck::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaAck::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaAck::SetConfirmationCode(uint16_t confirmationCode) [member function]
cls.add_method('SetConfirmationCode',
'void',
[param('uint16_t', 'confirmationCode')])
## mac-messages.h (module 'wimax'): void ns3::DsaAck::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3DsaReq_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq(ns3::DsaReq const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaReq const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): ns3::DsaReq::DsaReq(ns3::ServiceFlow sf) [constructor]
cls.add_constructor([param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::DsaReq::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaReq::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaReq::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::ServiceFlow ns3::DsaReq::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaReq::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaReq::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaReq::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetSfid(uint32_t sfid) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'sfid')])
## mac-messages.h (module 'wimax'): void ns3::DsaReq::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3DsaRsp_methods(root_module, cls):
## mac-messages.h (module 'wimax'): ns3::DsaRsp::DsaRsp(ns3::DsaRsp const & arg0) [copy constructor]
cls.add_constructor([param('ns3::DsaRsp const &', 'arg0')])
## mac-messages.h (module 'wimax'): ns3::DsaRsp::DsaRsp() [constructor]
cls.add_constructor([])
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::Cid ns3::DsaRsp::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaRsp::GetConfirmationCode() const [member function]
cls.add_method('GetConfirmationCode',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): ns3::TypeId ns3::DsaRsp::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): std::string ns3::DsaRsp::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): ns3::ServiceFlow ns3::DsaRsp::GetServiceFlow() const [member function]
cls.add_method('GetServiceFlow',
'ns3::ServiceFlow',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint32_t ns3::DsaRsp::GetSfid() const [member function]
cls.add_method('GetSfid',
'uint32_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): uint16_t ns3::DsaRsp::GetTransactionId() const [member function]
cls.add_method('GetTransactionId',
'uint16_t',
[],
is_const=True)
## mac-messages.h (module 'wimax'): static ns3::TypeId ns3::DsaRsp::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetConfirmationCode(uint16_t confirmationCode) [member function]
cls.add_method('SetConfirmationCode',
'void',
[param('uint16_t', 'confirmationCode')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('SetServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetSfid(uint32_t sfid) [member function]
cls.add_method('SetSfid',
'void',
[param('uint32_t', 'sfid')])
## mac-messages.h (module 'wimax'): void ns3::DsaRsp::SetTransactionId(uint16_t transactionId) [member function]
cls.add_method('SetTransactionId',
'void',
[param('uint16_t', 'transactionId')])
return
def register_Ns3EmptyAttributeValue_methods(root_module, cls):
## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue(ns3::EmptyAttributeValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EmptyAttributeValue const &', 'arg0')])
## attribute.h (module 'core'): ns3::EmptyAttributeValue::EmptyAttributeValue() [constructor]
cls.add_constructor([])
## attribute.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EmptyAttributeValue::Copy() const [member function]
cls.add_method('Copy',
'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<ns3::AttributeChecker const> 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<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3EventImpl_methods(root_module, cls):
## event-impl.h (module 'core'): ns3::EventImpl::EventImpl(ns3::EventImpl const & arg0) [copy constructor]
cls.add_constructor([param('ns3::EventImpl const &', 'arg0')])
## event-impl.h (module 'core'): ns3::EventImpl::EventImpl() [constructor]
cls.add_constructor([])
## event-impl.h (module 'core'): void ns3::EventImpl::Cancel() [member function]
cls.add_method('Cancel',
'void',
[])
## event-impl.h (module 'core'): void ns3::EventImpl::Invoke() [member function]
cls.add_method('Invoke',
'void',
[])
## event-impl.h (module 'core'): bool ns3::EventImpl::IsCancelled() [member function]
cls.add_method('IsCancelled',
'bool',
[])
## event-impl.h (module 'core'): void ns3::EventImpl::Notify() [member function]
cls.add_method('Notify',
'void',
[],
is_pure_virtual=True, visibility='protected', is_virtual=True)
return
def register_Ns3FixedRssLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::FixedRssLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel::FixedRssLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::FixedRssLossModel::SetRss(double rss) [member function]
cls.add_method('SetRss',
'void',
[param('double', 'rss')])
## propagation-loss-model.h (module 'propagation'): double ns3::FixedRssLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3FragmentationSubheader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader::FragmentationSubheader(ns3::FragmentationSubheader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::FragmentationSubheader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::FragmentationSubheader::FragmentationSubheader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::FragmentationSubheader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::FragmentationSubheader::GetFc() const [member function]
cls.add_method('GetFc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::FragmentationSubheader::GetFsn() const [member function]
cls.add_method('GetFsn',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::FragmentationSubheader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::FragmentationSubheader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::FragmentationSubheader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::FragmentationSubheader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::SetFc(uint8_t fc) [member function]
cls.add_method('SetFc',
'void',
[param('uint8_t', 'fc')])
## wimax-mac-header.h (module 'wimax'): void ns3::FragmentationSubheader::SetFsn(uint8_t fsn) [member function]
cls.add_method('SetFsn',
'void',
[param('uint8_t', 'fsn')])
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',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel::FriisPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double frequency, double speed) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'frequency'), param('double', 'speed')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetLambda(double lambda) [member function]
cls.add_method('SetLambda',
'void',
[param('double', 'lambda')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetSystemLoss(double systemLoss) [member function]
cls.add_method('SetSystemLoss',
'void',
[param('double', 'systemLoss')])
## propagation-loss-model.h (module 'propagation'): void ns3::FriisPropagationLossModel::SetMinDistance(double minDistance) [member function]
cls.add_method('SetMinDistance',
'void',
[param('double', 'minDistance')])
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetMinDistance() const [member function]
cls.add_method('GetMinDistance',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetLambda() const [member function]
cls.add_method('GetLambda',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::GetSystemLoss() const [member function]
cls.add_method('GetSystemLoss',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): double ns3::FriisPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3GenericMacHeader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader::GenericMacHeader(ns3::GenericMacHeader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GenericMacHeader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::GenericMacHeader::GenericMacHeader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GenericMacHeader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetCi() const [member function]
cls.add_method('GetCi',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::Cid ns3::GenericMacHeader::GetCid() const [member function]
cls.add_method('GetCid',
'ns3::Cid',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetEc() const [member function]
cls.add_method('GetEc',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetEks() const [member function]
cls.add_method('GetEks',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetHcs() const [member function]
cls.add_method('GetHcs',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetHt() const [member function]
cls.add_method('GetHt',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::GenericMacHeader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint16_t ns3::GenericMacHeader::GetLen() const [member function]
cls.add_method('GetLen',
'uint16_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::GenericMacHeader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GenericMacHeader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GenericMacHeader::GetType() const [member function]
cls.add_method('GetType',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::GenericMacHeader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetCi(uint8_t ci) [member function]
cls.add_method('SetCi',
'void',
[param('uint8_t', 'ci')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetCid(ns3::Cid cid) [member function]
cls.add_method('SetCid',
'void',
[param('ns3::Cid', 'cid')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetEc(uint8_t ec) [member function]
cls.add_method('SetEc',
'void',
[param('uint8_t', 'ec')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetEks(uint8_t eks) [member function]
cls.add_method('SetEks',
'void',
[param('uint8_t', 'eks')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetHcs(uint8_t hcs) [member function]
cls.add_method('SetHcs',
'void',
[param('uint8_t', 'hcs')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetHt(uint8_t HT) [member function]
cls.add_method('SetHt',
'void',
[param('uint8_t', 'HT')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetLen(uint16_t len) [member function]
cls.add_method('SetLen',
'void',
[param('uint16_t', 'len')])
## wimax-mac-header.h (module 'wimax'): void ns3::GenericMacHeader::SetType(uint8_t type) [member function]
cls.add_method('SetType',
'void',
[param('uint8_t', 'type')])
## wimax-mac-header.h (module 'wimax'): bool ns3::GenericMacHeader::check_hcs() const [member function]
cls.add_method('check_hcs',
'bool',
[],
is_const=True)
return
def register_Ns3GrantManagementSubheader_methods(root_module, cls):
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader::GrantManagementSubheader(ns3::GrantManagementSubheader const & arg0) [copy constructor]
cls.add_constructor([param('ns3::GrantManagementSubheader const &', 'arg0')])
## wimax-mac-header.h (module 'wimax'): ns3::GrantManagementSubheader::GrantManagementSubheader() [constructor]
cls.add_constructor([])
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GrantManagementSubheader::Deserialize(ns3::Buffer::Iterator start) [member function]
cls.add_method('Deserialize',
'uint32_t',
[param('ns3::Buffer::Iterator', 'start')],
is_virtual=True)
## wimax-mac-header.h (module 'wimax'): ns3::TypeId ns3::GrantManagementSubheader::GetInstanceTypeId() const [member function]
cls.add_method('GetInstanceTypeId',
'ns3::TypeId',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): std::string ns3::GrantManagementSubheader::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint16_t ns3::GrantManagementSubheader::GetPbr() const [member function]
cls.add_method('GetPbr',
'uint16_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GrantManagementSubheader::GetPm() const [member function]
cls.add_method('GetPm',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): uint32_t ns3::GrantManagementSubheader::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): uint8_t ns3::GrantManagementSubheader::GetSi() const [member function]
cls.add_method('GetSi',
'uint8_t',
[],
is_const=True)
## wimax-mac-header.h (module 'wimax'): static ns3::TypeId ns3::GrantManagementSubheader::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::Serialize(ns3::Buffer::Iterator start) const [member function]
cls.add_method('Serialize',
'void',
[param('ns3::Buffer::Iterator', 'start')],
is_const=True, is_virtual=True)
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetPbr(uint16_t pbr) [member function]
cls.add_method('SetPbr',
'void',
[param('uint16_t', 'pbr')])
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetPm(uint8_t pm) [member function]
cls.add_method('SetPm',
'void',
[param('uint8_t', 'pm')])
## wimax-mac-header.h (module 'wimax'): void ns3::GrantManagementSubheader::SetSi(uint8_t si) [member function]
cls.add_method('SetSi',
'void',
[param('uint8_t', 'si')])
return
def register_Ns3IpcsClassifier_methods(root_module, cls):
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier::IpcsClassifier(ns3::IpcsClassifier const & arg0) [copy constructor]
cls.add_constructor([param('ns3::IpcsClassifier const &', 'arg0')])
## ipcs-classifier.h (module 'wimax'): ns3::IpcsClassifier::IpcsClassifier() [constructor]
cls.add_constructor([])
## ipcs-classifier.h (module 'wimax'): ns3::ServiceFlow * ns3::IpcsClassifier::Classify(ns3::Ptr<const ns3::Packet> packet, ns3::Ptr<ns3::ServiceFlowManager> sfm, ns3::ServiceFlow::Direction dir) [member function]
cls.add_method('Classify',
'ns3::ServiceFlow *',
[param('ns3::Ptr< ns3::Packet const >', 'packet'), param('ns3::Ptr< ns3::ServiceFlowManager >', 'sfm'), param('ns3::ServiceFlow::Direction', 'dir')])
## ipcs-classifier.h (module 'wimax'): static ns3::TypeId ns3::IpcsClassifier::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Address ns3::Ipv4AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv4Address',
[],
is_const=True)
## ipv4-address.h (module 'network'): std::string ns3::Ipv4AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4AddressValue::Set(ns3::Ipv4Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv4Address const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv4-address.h (module 'network'): ns3::Ipv4Mask ns3::Ipv4MaskValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv4Mask',
[],
is_const=True)
## ipv4-address.h (module 'network'): std::string ns3::Ipv4MaskValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv4-address.h (module 'network'): void ns3::Ipv4MaskValue::Set(ns3::Ipv4Mask const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv4Mask const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv6-address.h (module 'network'): ns3::Ipv6Address ns3::Ipv6AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv6Address',
[],
is_const=True)
## ipv6-address.h (module 'network'): std::string ns3::Ipv6AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6AddressValue::Set(ns3::Ipv6Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv6Address const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## ipv6-address.h (module 'network'): ns3::Ipv6Prefix ns3::Ipv6PrefixValue::Get() const [member function]
cls.add_method('Get',
'ns3::Ipv6Prefix',
[],
is_const=True)
## ipv6-address.h (module 'network'): std::string ns3::Ipv6PrefixValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## ipv6-address.h (module 'network'): void ns3::Ipv6PrefixValue::Set(ns3::Ipv6Prefix const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Ipv6Prefix const &', 'value')])
return
def register_Ns3LogDistancePropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::LogDistancePropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel::LogDistancePropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetPathLossExponent(double n) [member function]
cls.add_method('SetPathLossExponent',
'void',
[param('double', 'n')])
## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::GetPathLossExponent() const [member function]
cls.add_method('GetPathLossExponent',
'double',
[],
is_const=True)
## propagation-loss-model.h (module 'propagation'): void ns3::LogDistancePropagationLossModel::SetReference(double referenceDistance, double referenceLoss) [member function]
cls.add_method('SetReference',
'void',
[param('double', 'referenceDistance'), param('double', 'referenceLoss')])
## propagation-loss-model.h (module 'propagation'): double ns3::LogDistancePropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## mac48-address.h (module 'network'): ns3::Mac48Address ns3::Mac48AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Mac48Address',
[],
is_const=True)
## mac48-address.h (module 'network'): std::string ns3::Mac48AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## mac48-address.h (module 'network'): void ns3::Mac48AddressValue::Set(ns3::Mac48Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Mac48Address const &', 'value')])
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',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel::MatrixPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b, double loss, bool symmetric=true) [member function]
cls.add_method('SetLoss',
'void',
[param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b'), param('double', 'loss'), param('bool', 'symmetric', default_value='true')])
## propagation-loss-model.h (module 'propagation'): void ns3::MatrixPropagationLossModel::SetDefaultLoss(double arg0) [member function]
cls.add_method('SetDefaultLoss',
'void',
[param('double', 'arg0')])
## propagation-loss-model.h (module 'propagation'): double ns3::MatrixPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3NakagamiPropagationLossModel_methods(root_module, cls):
## propagation-loss-model.h (module 'propagation'): static ns3::TypeId ns3::NakagamiPropagationLossModel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel::NakagamiPropagationLossModel() [constructor]
cls.add_constructor([])
## propagation-loss-model.h (module 'propagation'): double ns3::NakagamiPropagationLossModel::DoCalcRxPower(double txPowerDbm, ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]
cls.add_method('DoCalcRxPower',
'double',
[param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')],
is_const=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]
cls.add_constructor([param('ns3::NetDevice const &', 'arg0')])
## net-device.h (module 'network'): void ns3::NetDevice::AddLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('AddLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetAddress() const [member function]
cls.add_method('GetAddress',
'ns3::Address',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetBroadcast() const [member function]
cls.add_method('GetBroadcast',
'ns3::Address',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Ptr<ns3::Channel> ns3::NetDevice::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): uint32_t ns3::NetDevice::GetIfIndex() const [member function]
cls.add_method('GetIfIndex',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): uint16_t ns3::NetDevice::GetMtu() const [member function]
cls.add_method('GetMtu',
'uint16_t',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Address ns3::NetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv6Address', 'addr')],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): ns3::Ptr<ns3::Node> ns3::NetDevice::GetNode() const [member function]
cls.add_method('GetNode',
'ns3::Ptr< ns3::Node >',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): static ns3::TypeId ns3::NetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsBridge() const [member function]
cls.add_method('IsBridge',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsLinkUp() const [member function]
cls.add_method('IsLinkUp',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::IsPointToPoint() const [member function]
cls.add_method('IsPointToPoint',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::NeedsArp() const [member function]
cls.add_method('NeedsArp',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::Send(ns3::Ptr<ns3::Packet> 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')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SendFrom(ns3::Ptr<ns3::Packet> 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')],
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',
'void',
[param('ns3::Address', 'address')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::NetDevice::SetIfIndex(uint32_t const index) [member function]
cls.add_method('SetIfIndex',
'void',
[param('uint32_t const', 'index')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SetMtu(uint16_t const mtu) [member function]
cls.add_method('SetMtu',
'bool',
[param('uint16_t const', 'mtu')],
is_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): void ns3::NetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('SetNode',
'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<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) [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<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) [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_pure_virtual=True, is_virtual=True)
## net-device.h (module 'network'): bool ns3::NetDevice::SupportsSendFrom() const [member function]
cls.add_method('SupportsSendFrom',
'bool',
[],
is_pure_virtual=True, is_const=True, is_virtual=True)
return
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]
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')])
## 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')],
is_const=True)
## nix-vector.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::NixVector::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::NixVector >',
[],
is_const=True)
## 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')])
## 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')])
## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetRemainingBits() [member function]
cls.add_method('GetRemainingBits',
'uint32_t',
[])
## nix-vector.h (module 'network'): uint32_t ns3::NixVector::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## 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')],
is_const=True)
return
def register_Ns3Node_methods(root_module, cls):
## node.h (module 'network'): ns3::Node::Node(ns3::Node const & arg0) [copy constructor]
cls.add_constructor([param('ns3::Node const &', 'arg0')])
## node.h (module 'network'): ns3::Node::Node() [constructor]
cls.add_constructor([])
## node.h (module 'network'): ns3::Node::Node(uint32_t systemId) [constructor]
cls.add_constructor([param('uint32_t', 'systemId')])
## node.h (module 'network'): uint32_t ns3::Node::AddApplication(ns3::Ptr<ns3::Application> application) [member function]
cls.add_method('AddApplication',
'uint32_t',
[param('ns3::Ptr< ns3::Application >', 'application')])
## node.h (module 'network'): uint32_t ns3::Node::AddDevice(ns3::Ptr<ns3::NetDevice> device) [member function]
cls.add_method('AddDevice',
'uint32_t',
[param('ns3::Ptr< ns3::NetDevice >', 'device')])
## node.h (module 'network'): static bool ns3::Node::ChecksumEnabled() [member function]
cls.add_method('ChecksumEnabled',
'bool',
[],
is_static=True)
## node.h (module 'network'): ns3::Ptr<ns3::Application> ns3::Node::GetApplication(uint32_t index) const [member function]
cls.add_method('GetApplication',
'ns3::Ptr< ns3::Application >',
[param('uint32_t', 'index')],
is_const=True)
## node.h (module 'network'): ns3::Ptr<ns3::NetDevice> ns3::Node::GetDevice(uint32_t index) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'index')],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetId() const [member function]
cls.add_method('GetId',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetNApplications() const [member function]
cls.add_method('GetNApplications',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): uint32_t ns3::Node::GetSystemId() const [member function]
cls.add_method('GetSystemId',
'uint32_t',
[],
is_const=True)
## node.h (module 'network'): static ns3::TypeId ns3::Node::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## node.h (module 'network'): void ns3::Node::RegisterDeviceAdditionListener(ns3::Callback<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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<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, uint16_t protocolType, ns3::Ptr<ns3::NetDevice> 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<void,ns3::Ptr<ns3::NetDevice>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> 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<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) [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')])
## node.h (module 'network'): void ns3::Node::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='protected', is_virtual=True)
## node.h (module 'network'): void ns3::Node::DoStart() [member function]
cls.add_method('DoStart',
'void',
[],
visibility='protected', is_virtual=True)
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## object-factory.h (module 'core'): ns3::ObjectFactory ns3::ObjectFactoryValue::Get() const [member function]
cls.add_method('Get',
'ns3::ObjectFactory',
[],
is_const=True)
## object-factory.h (module 'core'): std::string ns3::ObjectFactoryValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## object-factory.h (module 'core'): void ns3::ObjectFactoryValue::Set(ns3::ObjectFactory const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::ObjectFactory const &', 'value')])
return
def register_Ns3OutputStreamWrapper_methods(root_module, cls):
## output-stream-wrapper.h (module 'network'): ns3::OutputStreamWrapper::OutputStreamWrapper(ns3::OutputStreamWrapper const & arg0) [copy 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::ostream * os) [constructor]
cls.add_constructor([param('std::ostream *', 'os')])
## output-stream-wrapper.h (module 'network'): std::ostream * ns3::OutputStreamWrapper::GetStream() [member function]
cls.add_method('GetStream',
'std::ostream *',
[])
return
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]
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')])
## packet.h (module 'network'): ns3::Packet::Packet(uint8_t const * buffer, uint32_t size, bool magic) [constructor]
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<const ns3::Packet> packet) [member function]
cls.add_method('AddAtEnd',
'void',
[param('ns3::Ptr< ns3::Packet const >', 'packet')])
## packet.h (module 'network'): void ns3::Packet::AddByteTag(ns3::Tag const & tag) const [member function]
cls.add_method('AddByteTag',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::AddHeader(ns3::Header const & header) [member function]
cls.add_method('AddHeader',
'void',
[param('ns3::Header const &', 'header')])
## packet.h (module 'network'): void ns3::Packet::AddPacketTag(ns3::Tag const & tag) const [member function]
cls.add_method('AddPacketTag',
'void',
[param('ns3::Tag const &', 'tag')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::AddPaddingAtEnd(uint32_t size) [member function]
cls.add_method('AddPaddingAtEnd',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): void ns3::Packet::AddTrailer(ns3::Trailer const & trailer) [member function]
cls.add_method('AddTrailer',
'void',
[param('ns3::Trailer const &', 'trailer')])
## packet.h (module 'network'): ns3::PacketMetadata::ItemIterator ns3::Packet::BeginItem() const [member function]
cls.add_method('BeginItem',
'ns3::PacketMetadata::ItemIterator',
[],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::Packet> ns3::Packet::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::Packet >',
[],
is_const=True)
## 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')],
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')],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::Packet> 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')],
is_const=True)
## packet.h (module 'network'): static void ns3::Packet::EnableChecking() [member function]
cls.add_method('EnableChecking',
'void',
[],
is_static=True)
## packet.h (module 'network'): static void ns3::Packet::EnablePrinting() [member function]
cls.add_method('EnablePrinting',
'void',
[],
is_static=True)
## packet.h (module 'network'): bool ns3::Packet::FindFirstMatchingByteTag(ns3::Tag & tag) const [member function]
cls.add_method('FindFirstMatchingByteTag',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): ns3::ByteTagIterator ns3::Packet::GetByteTagIterator() const [member function]
cls.add_method('GetByteTagIterator',
'ns3::ByteTagIterator',
[],
is_const=True)
## packet.h (module 'network'): ns3::Ptr<ns3::NixVector> ns3::Packet::GetNixVector() const [member function]
cls.add_method('GetNixVector',
'ns3::Ptr< ns3::NixVector >',
[],
is_const=True)
## packet.h (module 'network'): ns3::PacketTagIterator ns3::Packet::GetPacketTagIterator() const [member function]
cls.add_method('GetPacketTagIterator',
'ns3::PacketTagIterator',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::GetSerializedSize() const [member function]
cls.add_method('GetSerializedSize',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::GetSize() const [member function]
cls.add_method('GetSize',
'uint32_t',
[],
is_const=True)
## packet.h (module 'network'): uint64_t ns3::Packet::GetUid() const [member function]
cls.add_method('GetUid',
'uint64_t',
[],
is_const=True)
## packet.h (module 'network'): uint8_t const * ns3::Packet::PeekData() const [member function]
cls.add_method('PeekData',
'uint8_t const *',
[],
deprecated=True, is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::PeekHeader(ns3::Header & header) const [member function]
cls.add_method('PeekHeader',
'uint32_t',
[param('ns3::Header &', 'header')],
is_const=True)
## packet.h (module 'network'): bool ns3::Packet::PeekPacketTag(ns3::Tag & tag) const [member function]
cls.add_method('PeekPacketTag',
'bool',
[param('ns3::Tag &', 'tag')],
is_const=True)
## packet.h (module 'network'): uint32_t ns3::Packet::PeekTrailer(ns3::Trailer & trailer) [member function]
cls.add_method('PeekTrailer',
'uint32_t',
[param('ns3::Trailer &', 'trailer')])
## packet.h (module 'network'): void ns3::Packet::Print(std::ostream & os) const [member function]
cls.add_method('Print',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::PrintByteTags(std::ostream & os) const [member function]
cls.add_method('PrintByteTags',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::PrintPacketTags(std::ostream & os) const [member function]
cls.add_method('PrintPacketTags',
'void',
[param('std::ostream &', 'os')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::RemoveAllByteTags() [member function]
cls.add_method('RemoveAllByteTags',
'void',
[])
## packet.h (module 'network'): void ns3::Packet::RemoveAllPacketTags() [member function]
cls.add_method('RemoveAllPacketTags',
'void',
[])
## packet.h (module 'network'): void ns3::Packet::RemoveAtEnd(uint32_t size) [member function]
cls.add_method('RemoveAtEnd',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): void ns3::Packet::RemoveAtStart(uint32_t size) [member function]
cls.add_method('RemoveAtStart',
'void',
[param('uint32_t', 'size')])
## packet.h (module 'network'): uint32_t ns3::Packet::RemoveHeader(ns3::Header & header) [member function]
cls.add_method('RemoveHeader',
'uint32_t',
[param('ns3::Header &', 'header')])
## packet.h (module 'network'): bool ns3::Packet::RemovePacketTag(ns3::Tag & tag) [member function]
cls.add_method('RemovePacketTag',
'bool',
[param('ns3::Tag &', 'tag')])
## packet.h (module 'network'): uint32_t ns3::Packet::RemoveTrailer(ns3::Trailer & trailer) [member function]
cls.add_method('RemoveTrailer',
'uint32_t',
[param('ns3::Trailer &', 'trailer')])
## 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')],
is_const=True)
## packet.h (module 'network'): void ns3::Packet::SetNixVector(ns3::Ptr<ns3::NixVector> arg0) [member function]
cls.add_method('SetNixVector',
'void',
[param('ns3::Ptr< ns3::NixVector >', 'arg0')])
return
def register_Ns3RandomVariableChecker_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariableChecker::RandomVariableChecker(ns3::RandomVariableChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RandomVariableChecker const &', 'arg0')])
return
def register_Ns3RandomVariableValue_methods(root_module, cls):
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue() [constructor]
cls.add_constructor([])
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariableValue const & arg0) [copy constructor]
cls.add_constructor([param('ns3::RandomVariableValue const &', 'arg0')])
## random-variable.h (module 'core'): ns3::RandomVariableValue::RandomVariableValue(ns3::RandomVariable const & value) [constructor]
cls.add_constructor([param('ns3::RandomVariable const &', 'value')])
## random-variable.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::RandomVariableValue::Copy() const [member function]
cls.add_method('Copy',
'ns3::Ptr< ns3::AttributeValue >',
[],
is_const=True, is_virtual=True)
## random-variable.h (module 'core'): bool ns3::RandomVariableValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## random-variable.h (module 'core'): ns3::RandomVariable ns3::RandomVariableValue::Get() const [member function]
cls.add_method('Get',
'ns3::RandomVariable',
[],
is_const=True)
## random-variable.h (module 'core'): std::string ns3::RandomVariableValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## random-variable.h (module 'core'): void ns3::RandomVariableValue::Set(ns3::RandomVariable const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::RandomVariable const &', 'value')])
return
def register_Ns3SimpleOfdmWimaxPhy_methods(root_module, cls):
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy(ns3::SimpleOfdmWimaxPhy const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxPhy const &', 'arg0')])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy() [constructor]
cls.add_constructor([])
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy(char * tracesPath) [constructor]
cls.add_constructor([param('char *', 'tracesPath')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::ActivateLoss(bool loss) [member function]
cls.add_method('ActivateLoss',
'void',
[param('bool', 'loss')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoAttach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')],
is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxPhy::GetBandwidth() const [member function]
cls.add_method('GetBandwidth',
'uint32_t',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::GetNoiseFigure() const [member function]
cls.add_method('GetNoiseFigure',
'double',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::WimaxPhy::PhyType ns3::SimpleOfdmWimaxPhy::GetPhyType() const [member function]
cls.add_method('GetPhyType',
'ns3::WimaxPhy::PhyType',
[],
is_const=True, is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::GetTxPower() const [member function]
cls.add_method('GetTxPower',
'double',
[],
is_const=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): static ns3::TypeId ns3::SimpleOfdmWimaxPhy::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxBegin(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxBegin',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxDrop(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxDrop',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyRxEnd(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyRxEnd',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxBegin(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxBegin',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxDrop(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxDrop',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::NotifyTxEnd(ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('NotifyTxEnd',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::Send(ns3::Ptr<ns3::PacketBurst> burst, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction) [member function]
cls.add_method('Send',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::Send(ns3::SendParams * params) [member function]
cls.add_method('Send',
'void',
[param('ns3::SendParams *', 'params')],
is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetBandwidth(uint32_t BW) [member function]
cls.add_method('SetBandwidth',
'void',
[param('uint32_t', 'BW')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetNoiseFigure(double nf) [member function]
cls.add_method('SetNoiseFigure',
'void',
[param('double', 'nf')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetReceiveCallback(ns3::Callback<void,ns3::Ptr<ns3::PacketBurst>,ns3::Ptr<ns3::WimaxConnection>,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty,ns3::empty> callback) [member function]
cls.add_method('SetReceiveCallback',
'void',
[param('ns3::Callback< void, ns3::Ptr< ns3::PacketBurst >, ns3::Ptr< ns3::WimaxConnection >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetSNRToBlockErrorRateTracesPath(char * tracesPath) [member function]
cls.add_method('SetSNRToBlockErrorRateTracesPath',
'void',
[param('char *', 'tracesPath')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::SetTxPower(double txPower) [member function]
cls.add_method('SetTxPower',
'void',
[param('double', 'txPower')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::StartReceive(uint32_t burstSize, bool isFirstBlock, uint64_t frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double rxPower, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('StartReceive',
'void',
[param('uint32_t', 'burstSize'), param('bool', 'isFirstBlock'), param('uint64_t', 'frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'rxPower'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxPhy::DoGetDataRate(ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetDataRate',
'uint32_t',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::Time ns3::SimpleOfdmWimaxPhy::DoGetFrameDuration(uint8_t frameDurationCode) const [member function]
cls.add_method('DoGetFrameDuration',
'ns3::Time',
[param('uint8_t', 'frameDurationCode')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint8_t ns3::SimpleOfdmWimaxPhy::DoGetFrameDurationCode() const [member function]
cls.add_method('DoGetFrameDurationCode',
'uint8_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetGValue() const [member function]
cls.add_method('DoGetGValue',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetNfft() const [member function]
cls.add_method('DoGetNfft',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint64_t ns3::SimpleOfdmWimaxPhy::DoGetNrBytes(uint32_t symbols, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrBytes',
'uint64_t',
[param('uint32_t', 'symbols'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint64_t ns3::SimpleOfdmWimaxPhy::DoGetNrSymbols(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetNrSymbols',
'uint64_t',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetRtg() const [member function]
cls.add_method('DoGetRtg',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetSamplingFactor() const [member function]
cls.add_method('DoGetSamplingFactor',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): double ns3::SimpleOfdmWimaxPhy::DoGetSamplingFrequency() const [member function]
cls.add_method('DoGetSamplingFrequency',
'double',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): ns3::Time ns3::SimpleOfdmWimaxPhy::DoGetTransmissionTime(uint32_t size, ns3::WimaxPhy::ModulationType modulationType) const [member function]
cls.add_method('DoGetTransmissionTime',
'ns3::Time',
[param('uint32_t', 'size'), param('ns3::WimaxPhy::ModulationType', 'modulationType')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): uint16_t ns3::SimpleOfdmWimaxPhy::DoGetTtg() const [member function]
cls.add_method('DoGetTtg',
'uint16_t',
[],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoSetDataRates() [member function]
cls.add_method('DoSetDataRates',
'void',
[],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-phy.h (module 'wimax'): void ns3::SimpleOfdmWimaxPhy::DoSetPhyParameters() [member function]
cls.add_method('DoSetPhyParameters',
'void',
[],
visibility='private', is_virtual=True)
return
def register_Ns3TimeChecker_methods(root_module, cls):
## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker() [constructor]
cls.add_constructor([])
## nstime.h (module 'core'): ns3::TimeChecker::TimeChecker(ns3::TimeChecker const & arg0) [copy constructor]
cls.add_constructor([param('ns3::TimeChecker const &', 'arg0')])
return
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## nstime.h (module 'core'): ns3::Time ns3::TimeValue::Get() const [member function]
cls.add_method('Get',
'ns3::Time',
[],
is_const=True)
## nstime.h (module 'core'): std::string ns3::TimeValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## nstime.h (module 'core'): void ns3::TimeValue::Set(ns3::Time const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Time const &', 'value')])
return
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## type-id.h (module 'core'): ns3::TypeId ns3::TypeIdValue::Get() const [member function]
cls.add_method('Get',
'ns3::TypeId',
[],
is_const=True)
## type-id.h (module 'core'): std::string ns3::TypeIdValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## type-id.h (module 'core'): void ns3::TypeIdValue::Set(ns3::TypeId const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::TypeId const &', 'value')])
return
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## uinteger.h (module 'core'): uint64_t ns3::UintegerValue::Get() const [member function]
cls.add_method('Get',
'uint64_t',
[],
is_const=True)
## uinteger.h (module 'core'): std::string ns3::UintegerValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## uinteger.h (module 'core'): void ns3::UintegerValue::Set(uint64_t const & value) [member function]
cls.add_method('Set',
'void',
[param('uint64_t const &', 'value')])
return
def register_Ns3WimaxChannel_methods(root_module, cls):
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel::WimaxChannel(ns3::WimaxChannel const & arg0) [copy constructor]
cls.add_constructor([param('ns3::WimaxChannel const &', 'arg0')])
## wimax-channel.h (module 'wimax'): ns3::WimaxChannel::WimaxChannel() [constructor]
cls.add_constructor([])
## wimax-channel.h (module 'wimax'): void ns3::WimaxChannel::Attach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxChannel::GetDevice(uint32_t i) const [member function]
cls.add_method('GetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_const=True, is_virtual=True)
## wimax-channel.h (module 'wimax'): uint32_t ns3::WimaxChannel::GetNDevices() const [member function]
cls.add_method('GetNDevices',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-channel.h (module 'wimax'): static ns3::TypeId ns3::WimaxChannel::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-channel.h (module 'wimax'): void ns3::WimaxChannel::DoAttach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::WimaxChannel::DoGetDevice(uint32_t i) const [member function]
cls.add_method('DoGetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
## wimax-channel.h (module 'wimax'): uint32_t ns3::WimaxChannel::DoGetNDevices() const [member function]
cls.add_method('DoGetNDevices',
'uint32_t',
[],
is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3WimaxNetDevice_methods(root_module, cls):
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_direction [variable]
cls.add_static_attribute('m_direction', 'uint8_t', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_frameStartTime [variable]
cls.add_static_attribute('m_frameStartTime', 'ns3::Time', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_traceRx [variable]
cls.add_instance_attribute('m_traceRx', 'ns3::TracedCallback< ns3::Ptr< ns3::Packet const >, ns3::Mac48Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', is_const=False)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::m_traceTx [variable]
cls.add_instance_attribute('m_traceTx', 'ns3::TracedCallback< ns3::Ptr< ns3::Packet const >, ns3::Mac48Address const &, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', is_const=False)
## wimax-net-device.h (module 'wimax'): static ns3::TypeId ns3::WimaxNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## wimax-net-device.h (module 'wimax'): ns3::WimaxNetDevice::WimaxNetDevice() [constructor]
cls.add_constructor([])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetTtg(uint16_t ttg) [member function]
cls.add_method('SetTtg',
'void',
[param('uint16_t', 'ttg')])
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetTtg() const [member function]
cls.add_method('GetTtg',
'uint16_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetRtg(uint16_t rtg) [member function]
cls.add_method('SetRtg',
'void',
[param('uint16_t', 'rtg')])
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetRtg() const [member function]
cls.add_method('GetRtg',
'uint16_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Attach(ns3::Ptr<ns3::WimaxChannel> channel) [member function]
cls.add_method('Attach',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'channel')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetPhy(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('SetPhy',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxPhy> ns3::WimaxNetDevice::GetPhy() const [member function]
cls.add_method('GetPhy',
'ns3::Ptr< ns3::WimaxPhy >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetChannel(ns3::Ptr<ns3::WimaxChannel> wimaxChannel) [member function]
cls.add_method('SetChannel',
'void',
[param('ns3::Ptr< ns3::WimaxChannel >', 'wimaxChannel')])
## wimax-net-device.h (module 'wimax'): uint64_t ns3::WimaxNetDevice::GetChannel(uint8_t index) const [member function]
cls.add_method('GetChannel',
'uint64_t',
[param('uint8_t', 'index')],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetNrFrames(uint32_t nrFrames) [member function]
cls.add_method('SetNrFrames',
'void',
[param('uint32_t', 'nrFrames')])
## wimax-net-device.h (module 'wimax'): uint32_t ns3::WimaxNetDevice::GetNrFrames() const [member function]
cls.add_method('GetNrFrames',
'uint32_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetMacAddress(ns3::Mac48Address address) [member function]
cls.add_method('SetMacAddress',
'void',
[param('ns3::Mac48Address', 'address')])
## wimax-net-device.h (module 'wimax'): ns3::Mac48Address ns3::WimaxNetDevice::GetMacAddress() const [member function]
cls.add_method('GetMacAddress',
'ns3::Mac48Address',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetState(uint8_t state) [member function]
cls.add_method('SetState',
'void',
[param('uint8_t', 'state')])
## wimax-net-device.h (module 'wimax'): uint8_t ns3::WimaxNetDevice::GetState() const [member function]
cls.add_method('GetState',
'uint8_t',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::WimaxNetDevice::GetInitialRangingConnection() const [member function]
cls.add_method('GetInitialRangingConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::WimaxNetDevice::GetBroadcastConnection() const [member function]
cls.add_method('GetBroadcastConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetCurrentDcd(ns3::Dcd dcd) [member function]
cls.add_method('SetCurrentDcd',
'void',
[param('ns3::Dcd', 'dcd')])
## wimax-net-device.h (module 'wimax'): ns3::Dcd ns3::WimaxNetDevice::GetCurrentDcd() const [member function]
cls.add_method('GetCurrentDcd',
'ns3::Dcd',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetCurrentUcd(ns3::Ucd ucd) [member function]
cls.add_method('SetCurrentUcd',
'void',
[param('ns3::Ucd', 'ucd')])
## wimax-net-device.h (module 'wimax'): ns3::Ucd ns3::WimaxNetDevice::GetCurrentUcd() const [member function]
cls.add_method('GetCurrentUcd',
'ns3::Ucd',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::ConnectionManager> ns3::WimaxNetDevice::GetConnectionManager() const [member function]
cls.add_method('GetConnectionManager',
'ns3::Ptr< ns3::ConnectionManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetConnectionManager(ns3::Ptr<ns3::ConnectionManager> connectionManager) [member function]
cls.add_method('SetConnectionManager',
'void',
[param('ns3::Ptr< ns3::ConnectionManager >', 'connectionManager')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::BurstProfileManager> ns3::WimaxNetDevice::GetBurstProfileManager() const [member function]
cls.add_method('GetBurstProfileManager',
'ns3::Ptr< ns3::BurstProfileManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetBurstProfileManager(ns3::Ptr<ns3::BurstProfileManager> burstProfileManager) [member function]
cls.add_method('SetBurstProfileManager',
'void',
[param('ns3::Ptr< ns3::BurstProfileManager >', 'burstProfileManager')])
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::BandwidthManager> ns3::WimaxNetDevice::GetBandwidthManager() const [member function]
cls.add_method('GetBandwidthManager',
'ns3::Ptr< ns3::BandwidthManager >',
[],
is_const=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetBandwidthManager(ns3::Ptr<ns3::BandwidthManager> bandwidthManager) [member function]
cls.add_method('SetBandwidthManager',
'void',
[param('ns3::Ptr< ns3::BandwidthManager >', 'bandwidthManager')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::CreateDefaultConnections() [member function]
cls.add_method('CreateDefaultConnections',
'void',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetReceiveCallback() [member function]
cls.add_method('SetReceiveCallback',
'void',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::ForwardUp(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest) [member function]
cls.add_method('ForwardUp',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest')])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_pure_virtual=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::ForwardDown(ns3::Ptr<ns3::PacketBurst> burst, ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('ForwardDown',
'void',
[param('ns3::Ptr< ns3::PacketBurst >', 'burst'), param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetName(std::string const name) [member function]
cls.add_method('SetName',
'void',
[param('std::string const', 'name')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): std::string ns3::WimaxNetDevice::GetName() const [member function]
cls.add_method('GetName',
'std::string',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetIfIndex(uint32_t const index) [member function]
cls.add_method('SetIfIndex',
'void',
[param('uint32_t const', 'index')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): uint32_t ns3::WimaxNetDevice::GetIfIndex() const [member function]
cls.add_method('GetIfIndex',
'uint32_t',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Channel> ns3::WimaxNetDevice::GetPhyChannel() const [member function]
cls.add_method('GetPhyChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Channel> ns3::WimaxNetDevice::GetChannel() const [member function]
cls.add_method('GetChannel',
'ns3::Ptr< ns3::Channel >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetAddress(ns3::Address address) [member function]
cls.add_method('SetAddress',
'void',
[param('ns3::Address', 'address')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetAddress() const [member function]
cls.add_method('GetAddress',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SetMtu(uint16_t const mtu) [member function]
cls.add_method('SetMtu',
'bool',
[param('uint16_t const', 'mtu')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): uint16_t ns3::WimaxNetDevice::GetMtu() const [member function]
cls.add_method('GetMtu',
'uint16_t',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsLinkUp() const [member function]
cls.add_method('IsLinkUp',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('SetLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsBroadcast() const [member function]
cls.add_method('IsBroadcast',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetBroadcast() const [member function]
cls.add_method('GetBroadcast',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsMulticast() const [member function]
cls.add_method('IsMulticast',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast() const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::MakeMulticastAddress(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('MakeMulticastAddress',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsPointToPoint() const [member function]
cls.add_method('IsPointToPoint',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::Send(ns3::Ptr<ns3::Packet> 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')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetNode(ns3::Ptr<ns3::Node> node) [member function]
cls.add_method('SetNode',
'void',
[param('ns3::Ptr< ns3::Node >', 'node')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::Node> ns3::WimaxNetDevice::GetNode() const [member function]
cls.add_method('GetNode',
'ns3::Ptr< ns3::Node >',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::NeedsArp() const [member function]
cls.add_method('NeedsArp',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetReceiveCallback(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) [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)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::AddLinkChangeCallback(ns3::Callback<void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]
cls.add_method('AddLinkChangeCallback',
'void',
[param('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SendFrom(ns3::Ptr<ns3::Packet> 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')],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::SetPromiscReceiveCallback(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) [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)
## wimax-net-device.h (module 'wimax'): 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> ns3::WimaxNetDevice::GetPromiscReceiveCallback() [member function]
cls.add_method('GetPromiscReceiveCallback',
'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 >',
[])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::SupportsSendFrom() const [member function]
cls.add_method('SupportsSendFrom',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast(ns3::Ipv6Address addr) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv6Address', 'addr')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Address ns3::WimaxNetDevice::GetMulticast(ns3::Ipv4Address multicastGroup) const [member function]
cls.add_method('GetMulticast',
'ns3::Address',
[param('ns3::Ipv4Address', 'multicastGroup')],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsBridge() const [member function]
cls.add_method('IsBridge',
'bool',
[],
is_const=True, is_virtual=True)
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::IsPromisc() [member function]
cls.add_method('IsPromisc',
'bool',
[])
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::NotifyPromiscTrace(ns3::Ptr<ns3::Packet> p) [member function]
cls.add_method('NotifyPromiscTrace',
'void',
[param('ns3::Ptr< ns3::Packet >', 'p')])
## wimax-net-device.h (module 'wimax'): bool ns3::WimaxNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-net-device.h (module 'wimax'): void ns3::WimaxNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
is_pure_virtual=True, visibility='private', is_virtual=True)
## wimax-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxChannel> ns3::WimaxNetDevice::DoGetChannel() const [member function]
cls.add_method('DoGetChannel',
'ns3::Ptr< ns3::WimaxChannel >',
[],
is_const=True, visibility='private', is_virtual=True)
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]
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::Ptr<ns3::AttributeValue> 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<ns3::AttributeChecker const> checker) [member function]
cls.add_method('DeserializeFromString',
'bool',
[param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_virtual=True)
## address.h (module 'network'): ns3::Address ns3::AddressValue::Get() const [member function]
cls.add_method('Get',
'ns3::Address',
[],
is_const=True)
## address.h (module 'network'): std::string ns3::AddressValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]
cls.add_method('SerializeToString',
'std::string',
[param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')],
is_const=True, is_virtual=True)
## address.h (module 'network'): void ns3::AddressValue::Set(ns3::Address const & value) [member function]
cls.add_method('Set',
'void',
[param('ns3::Address const &', 'value')])
return
def register_Ns3BaseStationNetDevice_methods(root_module, cls):
## bs-net-device.h (module 'wimax'): static ns3::TypeId ns3::BaseStationNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice() [constructor]
cls.add_constructor([])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice(ns3::Ptr<ns3::Node> node, ns3::Ptr<ns3::WimaxPhy> phy) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy')])
## bs-net-device.h (module 'wimax'): ns3::BaseStationNetDevice::BaseStationNetDevice(ns3::Ptr<ns3::Node> node, ns3::Ptr<ns3::WimaxPhy> phy, ns3::Ptr<ns3::UplinkScheduler> uplinkScheduler, ns3::Ptr<ns3::BSScheduler> bsScheduler) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy'), param('ns3::Ptr< ns3::UplinkScheduler >', 'uplinkScheduler'), param('ns3::Ptr< ns3::BSScheduler >', 'bsScheduler')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetInitialRangingInterval(ns3::Time initialRangInterval) [member function]
cls.add_method('SetInitialRangingInterval',
'void',
[param('ns3::Time', 'initialRangInterval')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::InitBaseStationNetDevice() [member function]
cls.add_method('InitBaseStationNetDevice',
'void',
[])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetInitialRangingInterval() const [member function]
cls.add_method('GetInitialRangingInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetDcdInterval(ns3::Time dcdInterval) [member function]
cls.add_method('SetDcdInterval',
'void',
[param('ns3::Time', 'dcdInterval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetDcdInterval() const [member function]
cls.add_method('GetDcdInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetUcdInterval(ns3::Time ucdInterval) [member function]
cls.add_method('SetUcdInterval',
'void',
[param('ns3::Time', 'ucdInterval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetUcdInterval() const [member function]
cls.add_method('GetUcdInterval',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetIntervalT8(ns3::Time interval) [member function]
cls.add_method('SetIntervalT8',
'void',
[param('ns3::Time', 'interval')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetIntervalT8() const [member function]
cls.add_method('GetIntervalT8',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetMaxRangingCorrectionRetries(uint8_t maxRangCorrectionRetries) [member function]
cls.add_method('SetMaxRangingCorrectionRetries',
'void',
[param('uint8_t', 'maxRangCorrectionRetries')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetMaxRangingCorrectionRetries() const [member function]
cls.add_method('GetMaxRangingCorrectionRetries',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetMaxInvitedRangRetries(uint8_t maxInvitedRangRetries) [member function]
cls.add_method('SetMaxInvitedRangRetries',
'void',
[param('uint8_t', 'maxInvitedRangRetries')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetMaxInvitedRangRetries() const [member function]
cls.add_method('GetMaxInvitedRangRetries',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetRangReqOppSize(uint8_t rangReqOppSize) [member function]
cls.add_method('SetRangReqOppSize',
'void',
[param('uint8_t', 'rangReqOppSize')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetRangReqOppSize() const [member function]
cls.add_method('GetRangReqOppSize',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBwReqOppSize(uint8_t bwReqOppSize) [member function]
cls.add_method('SetBwReqOppSize',
'void',
[param('uint8_t', 'bwReqOppSize')])
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetBwReqOppSize() const [member function]
cls.add_method('GetBwReqOppSize',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetNrDlSymbols(uint32_t dlSymbols) [member function]
cls.add_method('SetNrDlSymbols',
'void',
[param('uint32_t', 'dlSymbols')])
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrDlSymbols() const [member function]
cls.add_method('GetNrDlSymbols',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetNrUlSymbols(uint32_t ulSymbols) [member function]
cls.add_method('SetNrUlSymbols',
'void',
[param('uint32_t', 'ulSymbols')])
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrUlSymbols() const [member function]
cls.add_method('GetNrUlSymbols',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrDcdSent() const [member function]
cls.add_method('GetNrDcdSent',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint32_t ns3::BaseStationNetDevice::GetNrUcdSent() const [member function]
cls.add_method('GetNrUcdSent',
'uint32_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetDlSubframeStartTime() const [member function]
cls.add_method('GetDlSubframeStartTime',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetUlSubframeStartTime() const [member function]
cls.add_method('GetUlSubframeStartTime',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): uint8_t ns3::BaseStationNetDevice::GetRangingOppNumber() const [member function]
cls.add_method('GetRangingOppNumber',
'uint8_t',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSManager> ns3::BaseStationNetDevice::GetSSManager() const [member function]
cls.add_method('GetSSManager',
'ns3::Ptr< ns3::SSManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetSSManager(ns3::Ptr<ns3::SSManager> ssManager) [member function]
cls.add_method('SetSSManager',
'void',
[param('ns3::Ptr< ns3::SSManager >', 'ssManager')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::UplinkScheduler> ns3::BaseStationNetDevice::GetUplinkScheduler() const [member function]
cls.add_method('GetUplinkScheduler',
'ns3::Ptr< ns3::UplinkScheduler >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetUplinkScheduler(ns3::Ptr<ns3::UplinkScheduler> ulScheduler) [member function]
cls.add_method('SetUplinkScheduler',
'void',
[param('ns3::Ptr< ns3::UplinkScheduler >', 'ulScheduler')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BSLinkManager> ns3::BaseStationNetDevice::GetLinkManager() const [member function]
cls.add_method('GetLinkManager',
'ns3::Ptr< ns3::BSLinkManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBSScheduler(ns3::Ptr<ns3::BSScheduler> bsSchedule) [member function]
cls.add_method('SetBSScheduler',
'void',
[param('ns3::Ptr< ns3::BSScheduler >', 'bsSchedule')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BSScheduler> ns3::BaseStationNetDevice::GetBSScheduler() const [member function]
cls.add_method('GetBSScheduler',
'ns3::Ptr< ns3::BSScheduler >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetLinkManager(ns3::Ptr<ns3::BSLinkManager> linkManager) [member function]
cls.add_method('SetLinkManager',
'void',
[param('ns3::Ptr< ns3::BSLinkManager >', 'linkManager')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::IpcsClassifier> ns3::BaseStationNetDevice::GetBsClassifier() const [member function]
cls.add_method('GetBsClassifier',
'ns3::Ptr< ns3::IpcsClassifier >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetBsClassifier(ns3::Ptr<ns3::IpcsClassifier> classifier) [member function]
cls.add_method('SetBsClassifier',
'void',
[param('ns3::Ptr< ns3::IpcsClassifier >', 'classifier')])
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetPsDuration() const [member function]
cls.add_method('GetPsDuration',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): ns3::Time ns3::BaseStationNetDevice::GetSymbolDuration() const [member function]
cls.add_method('GetSymbolDuration',
'ns3::Time',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_virtual=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_virtual=True)
## bs-net-device.h (module 'wimax'): bool ns3::BaseStationNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_virtual=True)
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::BaseStationNetDevice::GetConnection(ns3::Cid cid) [member function]
cls.add_method('GetConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[param('ns3::Cid', 'cid')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::MarkUplinkAllocations() [member function]
cls.add_method('MarkUplinkAllocations',
'void',
[])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::MarkRangingOppStart(ns3::Time rangingOppStartTime) [member function]
cls.add_method('MarkRangingOppStart',
'void',
[param('ns3::Time', 'rangingOppStartTime')])
## bs-net-device.h (module 'wimax'): ns3::Ptr<ns3::BsServiceFlowManager> ns3::BaseStationNetDevice::GetServiceFlowManager() const [member function]
cls.add_method('GetServiceFlowManager',
'ns3::Ptr< ns3::BsServiceFlowManager >',
[],
is_const=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::SetServiceFlowManager(ns3::Ptr<ns3::BsServiceFlowManager> arg0) [member function]
cls.add_method('SetServiceFlowManager',
'void',
[param('ns3::Ptr< ns3::BsServiceFlowManager >', 'arg0')])
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## bs-net-device.h (module 'wimax'): bool ns3::BaseStationNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
visibility='private', is_virtual=True)
## bs-net-device.h (module 'wimax'): void ns3::BaseStationNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
visibility='private', is_virtual=True)
return
def register_Ns3SimpleOfdmWimaxChannel_methods(root_module, cls):
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel(ns3::SimpleOfdmWimaxChannel const & arg0) [copy constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxChannel const &', 'arg0')])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel() [constructor]
cls.add_constructor([])
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::SimpleOfdmWimaxChannel::SimpleOfdmWimaxChannel(ns3::SimpleOfdmWimaxChannel::PropModel propModel) [constructor]
cls.add_constructor([param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propModel')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::Send(ns3::Time BlockTime, uint32_t burstSize, ns3::Ptr<ns3::WimaxPhy> phy, bool isFirstBlock, bool isLastBlock, uint64_t frequency, ns3::WimaxPhy::ModulationType modulationType, uint8_t direction, double txPowerDbm, ns3::Ptr<ns3::PacketBurst> burst) [member function]
cls.add_method('Send',
'void',
[param('ns3::Time', 'BlockTime'), param('uint32_t', 'burstSize'), param('ns3::Ptr< ns3::WimaxPhy >', 'phy'), param('bool', 'isFirstBlock'), param('bool', 'isLastBlock'), param('uint64_t', 'frequency'), param('ns3::WimaxPhy::ModulationType', 'modulationType'), param('uint8_t', 'direction'), param('double', 'txPowerDbm'), param('ns3::Ptr< ns3::PacketBurst >', 'burst')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::SetPropagationModel(ns3::SimpleOfdmWimaxChannel::PropModel propModel) [member function]
cls.add_method('SetPropagationModel',
'void',
[param('ns3::SimpleOfdmWimaxChannel::PropModel', 'propModel')])
## simple-ofdm-wimax-channel.h (module 'wimax'): void ns3::SimpleOfdmWimaxChannel::DoAttach(ns3::Ptr<ns3::WimaxPhy> phy) [member function]
cls.add_method('DoAttach',
'void',
[param('ns3::Ptr< ns3::WimaxPhy >', 'phy')],
visibility='private', is_virtual=True)
## simple-ofdm-wimax-channel.h (module 'wimax'): ns3::Ptr<ns3::NetDevice> ns3::SimpleOfdmWimaxChannel::DoGetDevice(uint32_t i) const [member function]
cls.add_method('DoGetDevice',
'ns3::Ptr< ns3::NetDevice >',
[param('uint32_t', 'i')],
is_const=True, visibility='private', is_virtual=True)
## simple-ofdm-wimax-channel.h (module 'wimax'): uint32_t ns3::SimpleOfdmWimaxChannel::DoGetNDevices() const [member function]
cls.add_method('DoGetNDevices',
'uint32_t',
[],
is_const=True, visibility='private', is_virtual=True)
return
def register_Ns3SubscriberStationNetDevice_methods(root_module, cls):
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::m_linkManager [variable]
cls.add_instance_attribute('m_linkManager', 'ns3::Ptr< ns3::SSLinkManager >', is_const=False)
## ss-net-device.h (module 'wimax'): static ns3::TypeId ns3::SubscriberStationNetDevice::GetTypeId() [member function]
cls.add_method('GetTypeId',
'ns3::TypeId',
[],
is_static=True)
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::SubscriberStationNetDevice() [constructor]
cls.add_constructor([])
## ss-net-device.h (module 'wimax'): ns3::SubscriberStationNetDevice::SubscriberStationNetDevice(ns3::Ptr<ns3::Node> arg0, ns3::Ptr<ns3::WimaxPhy> arg1) [constructor]
cls.add_constructor([param('ns3::Ptr< ns3::Node >', 'arg0'), param('ns3::Ptr< ns3::WimaxPhy >', 'arg1')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::InitSubscriberStationNetDevice() [member function]
cls.add_method('InitSubscriberStationNetDevice',
'void',
[])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLostDlMapInterval(ns3::Time lostDlMapInterval) [member function]
cls.add_method('SetLostDlMapInterval',
'void',
[param('ns3::Time', 'lostDlMapInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetLostDlMapInterval() const [member function]
cls.add_method('GetLostDlMapInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLostUlMapInterval(ns3::Time lostUlMapInterval) [member function]
cls.add_method('SetLostUlMapInterval',
'void',
[param('ns3::Time', 'lostUlMapInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetLostUlMapInterval() const [member function]
cls.add_method('GetLostUlMapInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxDcdInterval(ns3::Time maxDcdInterval) [member function]
cls.add_method('SetMaxDcdInterval',
'void',
[param('ns3::Time', 'maxDcdInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetMaxDcdInterval() const [member function]
cls.add_method('GetMaxDcdInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxUcdInterval(ns3::Time maxUcdInterval) [member function]
cls.add_method('SetMaxUcdInterval',
'void',
[param('ns3::Time', 'maxUcdInterval')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetMaxUcdInterval() const [member function]
cls.add_method('GetMaxUcdInterval',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT1(ns3::Time interval1) [member function]
cls.add_method('SetIntervalT1',
'void',
[param('ns3::Time', 'interval1')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT1() const [member function]
cls.add_method('GetIntervalT1',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT2(ns3::Time interval2) [member function]
cls.add_method('SetIntervalT2',
'void',
[param('ns3::Time', 'interval2')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT2() const [member function]
cls.add_method('GetIntervalT2',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT3(ns3::Time interval3) [member function]
cls.add_method('SetIntervalT3',
'void',
[param('ns3::Time', 'interval3')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT3() const [member function]
cls.add_method('GetIntervalT3',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT7(ns3::Time interval7) [member function]
cls.add_method('SetIntervalT7',
'void',
[param('ns3::Time', 'interval7')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT7() const [member function]
cls.add_method('GetIntervalT7',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT12(ns3::Time interval12) [member function]
cls.add_method('SetIntervalT12',
'void',
[param('ns3::Time', 'interval12')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT12() const [member function]
cls.add_method('GetIntervalT12',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT20(ns3::Time interval20) [member function]
cls.add_method('SetIntervalT20',
'void',
[param('ns3::Time', 'interval20')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT20() const [member function]
cls.add_method('GetIntervalT20',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIntervalT21(ns3::Time interval21) [member function]
cls.add_method('SetIntervalT21',
'void',
[param('ns3::Time', 'interval21')])
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetIntervalT21() const [member function]
cls.add_method('GetIntervalT21',
'ns3::Time',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetMaxContentionRangingRetries(uint8_t maxContentionRangingRetries) [member function]
cls.add_method('SetMaxContentionRangingRetries',
'void',
[param('uint8_t', 'maxContentionRangingRetries')])
## ss-net-device.h (module 'wimax'): uint8_t ns3::SubscriberStationNetDevice::GetMaxContentionRangingRetries() const [member function]
cls.add_method('GetMaxContentionRangingRetries',
'uint8_t',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetBasicConnection(ns3::Ptr<ns3::WimaxConnection> basicConnection) [member function]
cls.add_method('SetBasicConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'basicConnection')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::SubscriberStationNetDevice::GetBasicConnection() const [member function]
cls.add_method('GetBasicConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetPrimaryConnection(ns3::Ptr<ns3::WimaxConnection> primaryConnection) [member function]
cls.add_method('SetPrimaryConnection',
'void',
[param('ns3::Ptr< ns3::WimaxConnection >', 'primaryConnection')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::WimaxConnection> ns3::SubscriberStationNetDevice::GetPrimaryConnection() const [member function]
cls.add_method('GetPrimaryConnection',
'ns3::Ptr< ns3::WimaxConnection >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Cid ns3::SubscriberStationNetDevice::GetBasicCid() const [member function]
cls.add_method('GetBasicCid',
'ns3::Cid',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Cid ns3::SubscriberStationNetDevice::GetPrimaryCid() const [member function]
cls.add_method('GetPrimaryCid',
'ns3::Cid',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetModulationType(ns3::WimaxPhy::ModulationType modulationType) [member function]
cls.add_method('SetModulationType',
'void',
[param('ns3::WimaxPhy::ModulationType', 'modulationType')])
## ss-net-device.h (module 'wimax'): ns3::WimaxPhy::ModulationType ns3::SubscriberStationNetDevice::GetModulationType() const [member function]
cls.add_method('GetModulationType',
'ns3::WimaxPhy::ModulationType',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetAreManagementConnectionsAllocated(bool areManagementConnectionsAllocated) [member function]
cls.add_method('SetAreManagementConnectionsAllocated',
'void',
[param('bool', 'areManagementConnectionsAllocated')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::GetAreManagementConnectionsAllocated() const [member function]
cls.add_method('GetAreManagementConnectionsAllocated',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetAreServiceFlowsAllocated(bool areServiceFlowsAllocated) [member function]
cls.add_method('SetAreServiceFlowsAllocated',
'void',
[param('bool', 'areServiceFlowsAllocated')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::GetAreServiceFlowsAllocated() const [member function]
cls.add_method('GetAreServiceFlowsAllocated',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSScheduler> ns3::SubscriberStationNetDevice::GetScheduler() const [member function]
cls.add_method('GetScheduler',
'ns3::Ptr< ns3::SSScheduler >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetScheduler(ns3::Ptr<ns3::SSScheduler> ssScheduler) [member function]
cls.add_method('SetScheduler',
'void',
[param('ns3::Ptr< ns3::SSScheduler >', 'ssScheduler')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::HasServiceFlows() const [member function]
cls.add_method('HasServiceFlows',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::Enqueue(ns3::Ptr<ns3::Packet> packet, ns3::MacHeaderType const & hdrType, ns3::Ptr<ns3::WimaxConnection> connection) [member function]
cls.add_method('Enqueue',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::MacHeaderType const &', 'hdrType'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection')],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SendBurst(uint8_t uiuc, uint16_t nrSymbols, ns3::Ptr<ns3::WimaxConnection> connection, ns3::MacHeaderType::HeaderType packetType=::ns3::MacHeaderType::HEADER_TYPE_GENERIC) [member function]
cls.add_method('SendBurst',
'void',
[param('uint8_t', 'uiuc'), param('uint16_t', 'nrSymbols'), param('ns3::Ptr< ns3::WimaxConnection >', 'connection'), param('ns3::MacHeaderType::HeaderType', 'packetType', default_value='::ns3::MacHeaderType::HEADER_TYPE_GENERIC')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::Start() [member function]
cls.add_method('Start',
'void',
[],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::Stop() [member function]
cls.add_method('Stop',
'void',
[],
is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::AddServiceFlow(ns3::ServiceFlow * sf) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow *', 'sf')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::AddServiceFlow(ns3::ServiceFlow sf) [member function]
cls.add_method('AddServiceFlow',
'void',
[param('ns3::ServiceFlow', 'sf')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetTimer(ns3::EventId eventId, ns3::EventId & event) [member function]
cls.add_method('SetTimer',
'void',
[param('ns3::EventId', 'eventId'), param('ns3::EventId &', 'event')])
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::IsRegistered() const [member function]
cls.add_method('IsRegistered',
'bool',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): ns3::Time ns3::SubscriberStationNetDevice::GetTimeToAllocation(ns3::Time defferTime) [member function]
cls.add_method('GetTimeToAllocation',
'ns3::Time',
[param('ns3::Time', 'defferTime')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::IpcsClassifier> ns3::SubscriberStationNetDevice::GetIpcsClassifier() const [member function]
cls.add_method('GetIpcsClassifier',
'ns3::Ptr< ns3::IpcsClassifier >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetIpcsPacketClassifier(ns3::Ptr<ns3::IpcsClassifier> arg0) [member function]
cls.add_method('SetIpcsPacketClassifier',
'void',
[param('ns3::Ptr< ns3::IpcsClassifier >', 'arg0')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SSLinkManager> ns3::SubscriberStationNetDevice::GetLinkManager() const [member function]
cls.add_method('GetLinkManager',
'ns3::Ptr< ns3::SSLinkManager >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetLinkManager(ns3::Ptr<ns3::SSLinkManager> arg0) [member function]
cls.add_method('SetLinkManager',
'void',
[param('ns3::Ptr< ns3::SSLinkManager >', 'arg0')])
## ss-net-device.h (module 'wimax'): ns3::Ptr<ns3::SsServiceFlowManager> ns3::SubscriberStationNetDevice::GetServiceFlowManager() const [member function]
cls.add_method('GetServiceFlowManager',
'ns3::Ptr< ns3::SsServiceFlowManager >',
[],
is_const=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::SetServiceFlowManager(ns3::Ptr<ns3::SsServiceFlowManager> arg0) [member function]
cls.add_method('SetServiceFlowManager',
'void',
[param('ns3::Ptr< ns3::SsServiceFlowManager >', 'arg0')])
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::DoDispose() [member function]
cls.add_method('DoDispose',
'void',
[],
visibility='private', is_virtual=True)
## ss-net-device.h (module 'wimax'): bool ns3::SubscriberStationNetDevice::DoSend(ns3::Ptr<ns3::Packet> packet, ns3::Mac48Address const & source, ns3::Mac48Address const & dest, uint16_t protocolNumber) [member function]
cls.add_method('DoSend',
'bool',
[param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::Mac48Address const &', 'source'), param('ns3::Mac48Address const &', 'dest'), param('uint16_t', 'protocolNumber')],
visibility='private', is_virtual=True)
## ss-net-device.h (module 'wimax'): void ns3::SubscriberStationNetDevice::DoReceive(ns3::Ptr<ns3::Packet> packet) [member function]
cls.add_method('DoReceive',
'void',
[param('ns3::Ptr< ns3::Packet >', 'packet')],
visibility='private', is_virtual=True)
return
def register_functions(root_module):
module = root_module
## crc8.h (module 'wimax'): extern uint8_t ns3::CRC8Calculate(uint8_t const * data, int length) [free function]
module.add_function('CRC8Calculate',
'uint8_t',
[param('uint8_t const *', 'data'), param('int', 'length')])
register_functions_ns3_FatalImpl(module.get_submodule('FatalImpl'), root_module)
register_functions_ns3_internal(module.get_submodule('internal'), root_module)
return
def register_functions_ns3_FatalImpl(module, root_module):
return
def register_functions_ns3_internal(module, root_module):
return
def main():
out = FileCodeSink(sys.stdout)
root_module = module_init()
register_types(root_module)
register_methods(root_module)
register_functions(root_module)
root_module.generate(out)
if __name__ == '__main__':
main()
| zy901002-gpsr | src/wimax/bindings/modulegen__gcc_LP64.py | Python | gpl2 | 734,594 |
callback_classes = [
['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'],
['void', 'ns3::Ptr<ns3::PacketBurst const>', '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::NetDevice>', 'ns3::Ptr<ns3::Packet const>', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['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'],
['void', 'bool', 'unsigned long', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
| zy901002-gpsr | src/wimax/bindings/callbacks_list.py | Python | gpl2 | 1,064 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/config.h"
#include "ns3/string.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include "ns3/global-route-manager.h"
#include "ns3/snr-to-block-error-rate-manager.h"
#include <iostream>
using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("WimaxPhyTest");
/*
* Configure a network with 3 SS and 1 BS
* Install a SIMPLE OFDM PHY layer on all nodes and check that all SSs
* could register with the BS
*
*/
class Ns3WimaxSimpleOFDMTestCase : public TestCase
{
public:
Ns3WimaxSimpleOFDMTestCase ();
virtual ~Ns3WimaxSimpleOFDMTestCase ();
private:
virtual void DoRun (void);
bool DoRunOnce (double);
};
Ns3WimaxSimpleOFDMTestCase::Ns3WimaxSimpleOFDMTestCase ()
: TestCase ("Test the Phy model with different frame durations")
{
}
Ns3WimaxSimpleOFDMTestCase::~Ns3WimaxSimpleOFDMTestCase ()
{
}
bool
Ns3WimaxSimpleOFDMTestCase::DoRunOnce (double FrameDuration)
{
WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (3);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes, WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler, FrameDuration);
bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler, FrameDuration);
Simulator::Stop (Seconds (1));
Simulator::Run ();
for (int i = 0; i < 3; i++)
{
if (ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> ()->IsRegistered ()
== false)
{
NS_LOG_DEBUG ("SS[" << i << "] not registered");
return true; // Test fail because SS[i] is not registered
}
}
Simulator::Destroy ();
return (false); // Test was ok, all the SSs are registered
}
void
Ns3WimaxSimpleOFDMTestCase::DoRun (void)
{
double
frameDuratioTab[7] = { 0.0025, 0.004, 0.005, 0.008, 0.01, 0.0125, 0.02 };
for (int i = 0; i < 7; i++)
{
NS_LOG_DEBUG ("Frame Duration = " << frameDuratioTab[i]);
if (DoRunOnce (frameDuratioTab[i]) != false)
{
return;
}
}
}
/*
* Test the SNr tom block error rate module
*/
class Ns3WimaxSNRtoBLERTestCase : public TestCase
{
public:
Ns3WimaxSNRtoBLERTestCase ();
virtual ~Ns3WimaxSNRtoBLERTestCase ();
private:
virtual void DoRun (void);
bool DoRunOnce (uint8_t);
};
Ns3WimaxSNRtoBLERTestCase::Ns3WimaxSNRtoBLERTestCase ()
: TestCase ("Test the SNR to block error rate module")
{
}
Ns3WimaxSNRtoBLERTestCase::~Ns3WimaxSNRtoBLERTestCase ()
{
}
bool Ns3WimaxSNRtoBLERTestCase::DoRunOnce (uint8_t modulationType)
{
SNRToBlockErrorRateManager l_SNRToBlockErrorRateManager;
l_SNRToBlockErrorRateManager.LoadTraces ();
SNRToBlockErrorRateRecord * BLERRec;
for (double i = -5; i < 40; i += 0.1)
{
BLERRec = l_SNRToBlockErrorRateManager.GetSNRToBlockErrorRateRecord (i,
modulationType);
delete BLERRec;
}
return false;
}
void
Ns3WimaxSNRtoBLERTestCase::DoRun (void)
{
for (int i = 0; i < 7; i++)
{
DoRunOnce (i);
}
}
/*
* The test suite
*/
class Ns3WimaxPhyTestSuite : public TestSuite
{
public:
Ns3WimaxPhyTestSuite ();
};
Ns3WimaxPhyTestSuite::Ns3WimaxPhyTestSuite ()
: TestSuite ("wimax-phy-layer", UNIT)
{
AddTestCase (new Ns3WimaxSNRtoBLERTestCase);
AddTestCase (new Ns3WimaxSimpleOFDMTestCase);
}
static Ns3WimaxPhyTestSuite ns3WimaxPhyTestSuite;
| zy901002-gpsr | src/wimax/test/phy-test.cc | C++ | gpl2 | 4,845 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/config.h"
#include "ns3/string.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include <iostream>
#include "ns3/global-route-manager.h"
using namespace ns3;
class Ns3WimaxSchedulingTestCase : public TestCase
{
public:
Ns3WimaxSchedulingTestCase ();
virtual ~Ns3WimaxSchedulingTestCase ();
private:
virtual void DoRun (void);
bool DoRunOnce (WimaxHelper::SchedulerType scheduler);
};
Ns3WimaxSchedulingTestCase::Ns3WimaxSchedulingTestCase ()
: TestCase ("Test the 2 different schedulers")
{
}
Ns3WimaxSchedulingTestCase::~Ns3WimaxSchedulingTestCase ()
{
}
bool
Ns3WimaxSchedulingTestCase::DoRunOnce (WimaxHelper::SchedulerType scheduler)
{
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (2);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
ssDevs.Get (1)->GetObject<SubscriberStationNetDevice> ()->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
InternetStackHelper stack;
stack.Install (bsNodes);
stack.Install (ssNodes);
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer SSinterfaces = address.Assign (ssDevs);
Ipv4InterfaceContainer BSinterface = address.Assign (bsDevs);
/*------------------------------*/
UdpServerHelper udpServer;
ApplicationContainer serverApps;
UdpClientHelper udpClient;
ApplicationContainer clientApps;
udpServer = UdpServerHelper (100);
serverApps = udpServer.Install (ssNodes.Get (0));
serverApps.Start (Seconds (1));
serverApps.Stop (Seconds (2));
udpClient = UdpClientHelper (SSinterfaces.GetAddress (0), 100);
udpClient.SetAttribute ("MaxPackets", UintegerValue (1200));
udpClient.SetAttribute ("Interval", TimeValue (Seconds (0.12)));
udpClient.SetAttribute ("PacketSize", UintegerValue (1024));
clientApps = udpClient.Install (ssNodes.Get (1));
clientApps.Start (Seconds (1));
clientApps.Stop (Seconds (2));
Simulator::Stop (Seconds (2 + 0.1));
IpcsClassifierRecord DlClassifierUgs (Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
SSinterfaces.GetAddress (0),
Ipv4Mask ("255.255.255.255"),
0,
65000,
100,
100,
17,
1);
ServiceFlow DlServiceFlowUgs = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN,
ServiceFlow::SF_TYPE_RTPS,
DlClassifierUgs);
IpcsClassifierRecord UlClassifierUgs (SSinterfaces.GetAddress (1),
Ipv4Mask ("255.255.255.255"),
Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
0,
65000,
100,
100,
17,
1);
ServiceFlow UlServiceFlowUgs = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP,
ServiceFlow::SF_TYPE_RTPS,
UlClassifierUgs);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (DlServiceFlowUgs);
ssDevs.Get (1)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (UlServiceFlowUgs);
Simulator::Run ();
Simulator::Destroy ();
return false;
}
void
Ns3WimaxSchedulingTestCase::DoRun ()
{
if (DoRunOnce (WimaxHelper::SCHED_TYPE_SIMPLE) == true)
{
return;
}
if (DoRunOnce (WimaxHelper::SCHED_TYPE_RTPS) == true)
{
return;
}
}
// =============================================================================
class Ns3WimaxSFTypeTestCase : public TestCase
{
public:
Ns3WimaxSFTypeTestCase ();
virtual ~Ns3WimaxSFTypeTestCase ();
private:
virtual void DoRun (void);
bool DoRunOnce (ServiceFlow::SchedulingType);
};
Ns3WimaxSFTypeTestCase::Ns3WimaxSFTypeTestCase ()
: TestCase ("Test the service flow scheduling types")
{
}
Ns3WimaxSFTypeTestCase::~Ns3WimaxSFTypeTestCase ()
{
}
bool
Ns3WimaxSFTypeTestCase::DoRunOnce (ServiceFlow::SchedulingType schedulingType)
{
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (2);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
WimaxHelper::SCHED_TYPE_SIMPLE);
bsDevs = wimax.Install (bsNodes,
WimaxHelper::DEVICE_TYPE_BASE_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
WimaxHelper::SCHED_TYPE_SIMPLE);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
ssDevs.Get (1)->GetObject<SubscriberStationNetDevice> ()->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
InternetStackHelper stack;
stack.Install (bsNodes);
stack.Install (ssNodes);
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer SSinterfaces = address.Assign (ssDevs);
Ipv4InterfaceContainer BSinterface = address.Assign (bsDevs);
/*------------------------------*/
UdpServerHelper udpServer;
ApplicationContainer serverApps;
UdpClientHelper udpClient;
ApplicationContainer clientApps;
udpServer = UdpServerHelper (100);
serverApps = udpServer.Install (ssNodes.Get (0));
serverApps.Start (Seconds (1));
serverApps.Stop (Seconds (2));
udpClient = UdpClientHelper (SSinterfaces.GetAddress (0), 100);
udpClient.SetAttribute ("MaxPackets", UintegerValue (1200));
udpClient.SetAttribute ("Interval", TimeValue (Seconds (0.12)));
udpClient.SetAttribute ("PacketSize", UintegerValue (1024));
clientApps = udpClient.Install (ssNodes.Get (1));
clientApps.Start (Seconds (1));
clientApps.Stop (Seconds (2));
Simulator::Stop (Seconds (2 + 0.1));
IpcsClassifierRecord DlClassifier (Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
SSinterfaces.GetAddress (0),
Ipv4Mask ("255.255.255.255"),
0,
65000,
100,
100,
17,
1);
ServiceFlow DlServiceFlow = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN, schedulingType, DlClassifier);
IpcsClassifierRecord UlClassifier (SSinterfaces.GetAddress (1),
Ipv4Mask ("255.255.255.255"),
Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
0,
65000,
100,
100,
17,
1);
ServiceFlow UlServiceFlow = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP, schedulingType, UlClassifier);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (DlServiceFlow);
ssDevs.Get (1)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (UlServiceFlow);
Simulator::Run ();
Simulator::Destroy ();
return false;
}
void
Ns3WimaxSFTypeTestCase::DoRun ()
{
if (DoRunOnce (ServiceFlow::SF_TYPE_UGS) == true)
{
return;
}
if (DoRunOnce (ServiceFlow::SF_TYPE_RTPS) == true)
{
return;
}
if (DoRunOnce (ServiceFlow::SF_TYPE_BE) == true)
{
return;
}
}
class Ns3WimaxQoSTestSuite : public TestSuite
{
public:
Ns3WimaxQoSTestSuite ();
};
Ns3WimaxQoSTestSuite::Ns3WimaxQoSTestSuite ()
: TestSuite ("wimax-qos", SYSTEM)
{
AddTestCase (new Ns3WimaxSFTypeTestCase);
AddTestCase (new Ns3WimaxSchedulingTestCase);
}
static Ns3WimaxQoSTestSuite ns3WimaxQoSTestSuite;
| zy901002-gpsr | src/wimax/test/qos-test.cc | C++ | gpl2 | 10,250 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
*
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-header.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include "ns3/global-route-manager.h"
#include "ns3/wimax-tlv.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include <iostream>
using namespace ns3;
/*
* Test the DSA request message.
*/
class DsaRequestTestCase : public TestCase
{
public:
DsaRequestTestCase ();
virtual ~DsaRequestTestCase ();
private:
virtual void DoRun (void);
};
DsaRequestTestCase::DsaRequestTestCase ()
: TestCase ("Test the DSA request messages")
{
}
DsaRequestTestCase::~DsaRequestTestCase ()
{
}
void
DsaRequestTestCase::DoRun (void)
{
IpcsClassifierRecord classifier = IpcsClassifierRecord ();
CsParameters csParam (CsParameters::ADD, classifier);
ServiceFlow sf = ServiceFlow (ServiceFlow::SF_DIRECTION_DOWN);
sf.SetSfid (100);
sf.SetConvergenceSublayerParam (csParam);
sf.SetCsSpecification (ServiceFlow::IPV4);
sf.SetServiceSchedulingType (ServiceFlow::SF_TYPE_UGS);
sf.SetMaxSustainedTrafficRate (1000000);
sf.SetMinReservedTrafficRate (1000000);
sf.SetMinTolerableTrafficRate (1000000);
sf.SetMaximumLatency (10);
sf.SetMaxTrafficBurst (1000);
sf.SetTrafficPriority (1);
DsaReq dsaReq (sf);
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (dsaReq);
DsaReq dsaReqRecv;
packet->RemoveHeader (dsaReqRecv);
ServiceFlow sfRecv = dsaReqRecv.GetServiceFlow ();
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetDirection (), ServiceFlow::SF_DIRECTION_DOWN, "The sfRecv had the wrong direction.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetSfid (), 100, "The sfRecv had the wrong sfid.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetCsSpecification (), ServiceFlow::IPV4, "The sfRecv had the wrong cs specification.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetServiceSchedulingType (), ServiceFlow::SF_TYPE_UGS, "The sfRecv had the wrong service scheduling type.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxSustainedTrafficRate (), 1000000, "The sfRecv had the wrong maximum sustained traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinReservedTrafficRate (), 1000000, "The sfRecv had the wrong minimum reserved traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinTolerableTrafficRate (), 1000000, "The sfRecv had the wrong minimum tolerable traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaximumLatency (), 10, "The sfRecv had the wrong maximum latency.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxTrafficBurst (), 1000, "The sfRecv had the wrong maximum traffic burst.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetTrafficPriority (), 1, "The sfRecv had the wrong traffic priority.");
}
// ==============================================================================
class Ns3WimaxMacMessagesTestSuite : public TestSuite
{
public:
Ns3WimaxMacMessagesTestSuite ();
};
Ns3WimaxMacMessagesTestSuite::Ns3WimaxMacMessagesTestSuite ()
: TestSuite ("wimax-mac-messages", UNIT)
{
AddTestCase (new DsaRequestTestCase);
}
static Ns3WimaxMacMessagesTestSuite ns3WimaxMacMessagesTestSuite;
| zy901002-gpsr | src/wimax/test/mac-messages-test.cc | C++ | gpl2 | 4,221 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-header.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include "ns3/global-route-manager.h"
#include "ns3/wimax-tlv.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include <iostream>
using namespace ns3;
/*
* Test the service flow creation.
*/
class Ns3WimaxSfCreationTestCase : public TestCase
{
public:
Ns3WimaxSfCreationTestCase ();
virtual ~Ns3WimaxSfCreationTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxSfCreationTestCase::Ns3WimaxSfCreationTestCase ()
: TestCase ("Test the service flow tlv implementation.")
{
}
Ns3WimaxSfCreationTestCase::~Ns3WimaxSfCreationTestCase ()
{
}
void
Ns3WimaxSfCreationTestCase::DoRun (void)
{
// default values
int duration = 2;
WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (1);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
bsDevs.Get (0)->GetObject<BaseStationNetDevice> ();
InternetStackHelper stack;
stack.Install (bsNodes);
stack.Install (ssNodes);
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer SSinterfaces = address.Assign (ssDevs);
Ipv4InterfaceContainer BSinterface = address.Assign (bsDevs);
// Create one UGS Downlink service flow between the ss and the bs
ServiceFlow * DlServiceFlowUgs = new ServiceFlow (ServiceFlow::SF_DIRECTION_DOWN);
IpcsClassifierRecord DlClassifierUgs (Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
3000,
3000,
0,
35000,
17,
1);
CsParameters DlcsParam (CsParameters::ADD, DlClassifierUgs);
DlServiceFlowUgs->SetConvergenceSublayerParam (DlcsParam);
DlServiceFlowUgs->SetCsSpecification (ServiceFlow::IPV4);
DlServiceFlowUgs->SetServiceSchedulingType (ServiceFlow::SF_TYPE_UGS);
DlServiceFlowUgs->SetMaxSustainedTrafficRate (1000000);
DlServiceFlowUgs->SetMinReservedTrafficRate (1000000);
DlServiceFlowUgs->SetMinTolerableTrafficRate (1000000);
DlServiceFlowUgs->SetMaximumLatency (10);
DlServiceFlowUgs->SetMaxTrafficBurst (1000);
DlServiceFlowUgs->SetTrafficPriority (1);
// Create one UGS Uplink service flow between the ss and the bs
ServiceFlow * UlServiceFlowUgs = new ServiceFlow (ServiceFlow::SF_DIRECTION_UP);
IpcsClassifierRecord UlClassifierUgs (Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
0,
35000,
3000,
3000,
17,
1);
CsParameters UlcsParam (CsParameters::ADD, UlClassifierUgs);
UlServiceFlowUgs->SetConvergenceSublayerParam (UlcsParam);
UlServiceFlowUgs->SetCsSpecification (ServiceFlow::IPV4);
UlServiceFlowUgs->SetServiceSchedulingType (ServiceFlow::SF_TYPE_UGS);
UlServiceFlowUgs->SetMaxSustainedTrafficRate (1000000);
UlServiceFlowUgs->SetMinReservedTrafficRate (1000000);
UlServiceFlowUgs->SetMinTolerableTrafficRate (1000000);
UlServiceFlowUgs->SetMaximumLatency (10);
UlServiceFlowUgs->SetMaxTrafficBurst (1000);
UlServiceFlowUgs->SetTrafficPriority (1);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (DlServiceFlowUgs);
ssDevs.Get (0)->GetObject<SubscriberStationNetDevice> ()->AddServiceFlow (UlServiceFlowUgs);
Simulator::Stop (Seconds (duration));
Simulator::Run ();
Simulator::Destroy ();
}
// ==============================================================================
class Ns3WimaxServiceFlowTestSuite : public TestSuite
{
public:
Ns3WimaxServiceFlowTestSuite ();
};
Ns3WimaxServiceFlowTestSuite::Ns3WimaxServiceFlowTestSuite ()
: TestSuite ("wimax-service-flow", UNIT)
{
AddTestCase (new Ns3WimaxSfCreationTestCase);
}
static Ns3WimaxServiceFlowTestSuite ns3WimaxServiceFlowTestSuite;
| zy901002-gpsr | src/wimax/test/wimax-service-flow-test.cc | C++ | gpl2 | 6,223 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009-2010 TELEMATICS LAB - Poliotecnico di Bari
*
* 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
*
* Giuseppe Piro <g.piro@poliba.it>
* <peppe.piro@gmail.com>
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-header.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include "ns3/global-route-manager.h"
#include "ns3/wimax-tlv.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include "ns3/wimax-connection.h"
#include <iostream>
using namespace ns3;
/*
* Test the wimax packet fragmentation.
*/
class Ns3WimaxFragmentationTestCase : public TestCase
{
public:
Ns3WimaxFragmentationTestCase ();
virtual ~Ns3WimaxFragmentationTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxFragmentationTestCase::Ns3WimaxFragmentationTestCase ()
: TestCase ("Test the packet fragmentation and defragmentation.")
{
}
Ns3WimaxFragmentationTestCase::~Ns3WimaxFragmentationTestCase ()
{
}
void
Ns3WimaxFragmentationTestCase::DoRun (void)
{
GenericMacHeader gnrcMacHdr;
ManagementMessageType msgType;
FragmentationSubheader fragSubhdr;
GenericMacHeader hdr;
Cid cid;
WimaxConnection *connectionTx = new WimaxConnection (cid, Cid::TRANSPORT);
WimaxConnection *connectionRx = new WimaxConnection (cid, Cid::TRANSPORT);
// A Packet of 1000 bytes has been created.
// It will be fragmentated into 4 fragments and then defragmentated into fullPacket.
Ptr<Packet> packet = Create<Packet> (1000);
Ptr<Packet> fragment;
Ptr<Packet> fullPacket = Create<Packet> ();
// Enqueued packet
hdr.SetLen (packet->GetSize () + hdr.GetSerializedSize ());
hdr.SetCid (connectionTx->GetCid ());
MacHeaderType::HeaderType packetType = MacHeaderType::HEADER_TYPE_GENERIC;
connectionTx->Enqueue (packet, packetType, hdr);
uint32_t availableByteForFragment = 280;
for (int i = 0; i < 4; i++)
{
// dequeue a fragment
if (connectionTx->GetQueue ()->GetFirstPacketRequiredByte (packetType) > availableByteForFragment)
{
fragment = connectionTx->Dequeue (packetType, availableByteForFragment);
}
else
{
fragment = connectionTx->Dequeue (packetType);
}
// *** send packet -----> receive packet ----**
// check if receive packet is a fragment
fragment->RemoveHeader (gnrcMacHdr);
uint8_t type = gnrcMacHdr.GetType ();
if (type)
{
// Check if there is a fragmentation Subheader
NS_TEST_EXPECT_MSG_EQ (((type >> 2) & 1), 1, "The packet is not a fragment");
}
// remove header from the received fragment
fragment->RemoveHeader (fragSubhdr);
uint32_t fc = fragSubhdr.GetFc ();
NS_TEST_EXPECT_MSG_EQ ((fc == 1 && i != 0), false, "The fragment in not the first one");
NS_TEST_EXPECT_MSG_EQ ((fc == 2 && i != 3), false, "The fragment in not the latest one");
NS_TEST_EXPECT_MSG_EQ (((fc == 3 && i != 1) && (fc == 3 && i != 2)), false, "The fragment in not the middle one");
if (fc != 2)
{
// This is the first or middle fragment.
// Take the fragment queue, store the fragment into the queue
connectionRx->FragmentEnqueue (fragment);
}
else
{
// This is the latest fragment.
// Take the fragment queue, defragment a packet and send it to the upper layer
connectionRx->FragmentEnqueue (fragment);
WimaxConnection::FragmentsQueue fragmentsQueue = connectionRx->GetFragmentsQueue ();
// DEFRAGMENTATION
for (std::list<Ptr<const Packet> >::const_iterator iter = fragmentsQueue.begin ();
iter != fragmentsQueue.end (); ++iter)
{
// Create the whole Packet
fullPacket->AddAtEnd (*iter);
}
connectionRx->ClearFragmentsQueue ();
NS_TEST_EXPECT_MSG_EQ (fullPacket->GetSize (), 1000, "The defragmentation is incorrect");
}
}
delete connectionTx;
delete connectionRx;
Simulator::Destroy ();
}
// ==============================================================================
class Ns3WimaxFragmentationTestSuite : public TestSuite
{
public:
Ns3WimaxFragmentationTestSuite ();
};
Ns3WimaxFragmentationTestSuite::Ns3WimaxFragmentationTestSuite ()
: TestSuite ("wimax-fragmentation", UNIT)
{
AddTestCase (new Ns3WimaxFragmentationTestCase);
}
static Ns3WimaxFragmentationTestSuite ns3WimaxFragmentationTestSuite;
| zy901002-gpsr | src/wimax/test/wimax-fragmentation-test.cc | C++ | gpl2 | 5,538 |
#! /usr/bin/env python
## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
# A list of C++ examples to run in order to ensure that they remain
# buildable and runnable over time. Each tuple in the list contains
#
# (example_name, do_run, do_valgrind_run).
#
# See test.py for more information.
cpp_examples = [
("wimax-simple", "True", "True"),
("wimax-ipv4", "True", "True"),
("wimax-multicast", "True", "True"),
]
# A list of Python examples to run in order to ensure that they remain
# runnable over time. Each tuple in the list contains
#
# (example_name, do_run).
#
# See test.py for more information.
python_examples = []
| zy901002-gpsr | src/wimax/test/examples-to-run.py | Python | gpl2 | 684 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2009 INRIA, UDcast
*
* 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
*
* Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-header.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include "ns3/global-route-manager.h"
#include "ns3/wimax-tlv.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include <iostream>
using namespace ns3;
/*
* Test the wimax tlv implementation.
*/
class Ns3WimaxCsParamTlvTestCase : public TestCase
{
public:
Ns3WimaxCsParamTlvTestCase ();
virtual ~Ns3WimaxCsParamTlvTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxCsParamTlvTestCase::Ns3WimaxCsParamTlvTestCase ()
: TestCase ("Test the CS parameters tlv implementation.")
{
}
Ns3WimaxCsParamTlvTestCase::~Ns3WimaxCsParamTlvTestCase ()
{
}
void
Ns3WimaxCsParamTlvTestCase::DoRun (void)
{
IpcsClassifierRecord classifier (Ipv4Address ("10.0.0.0"),
Ipv4Mask ("255.0.0.0"),
Ipv4Address ("11.0.0.0"),
Ipv4Mask ("255.0.0.0"),
1000,
1100,
3000,
3100,
17,
1);
classifier.AddSrcAddr (Ipv4Address ("1.0.0.0"), Ipv4Mask ("255.0.0.0"));
classifier.AddDstAddr (Ipv4Address ("16.0.0.0"), Ipv4Mask ("255.0.0.0"));
classifier.AddProtocol (6);
classifier.AddSrcPortRange (1, 2);
classifier.AddDstPortRange (4000, 4100);
classifier.SetIndex (1);
CsParameters csParam (CsParameters::ADD, classifier);
SfVectorTlvValue sfVectorTlvValue;
sfVectorTlvValue.Add (csParam.ToTlv ());
Tlv tlvSent (145, sfVectorTlvValue.GetSerializedSize (), sfVectorTlvValue);
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (tlvSent);
Tlv tlvReceived;
packet->RemoveHeader (tlvReceived);
if (tlvReceived.GetType () == Tlv::UPLINK_SERVICE_FLOW)
{
SfVectorTlvValue * sfVecValue =
(SfVectorTlvValue *) tlvReceived.PeekValue ();
for (std::vector<Tlv*>::const_iterator iter = sfVecValue->Begin (); iter
!= sfVecValue->End (); ++iter)
{
if ((*iter)->GetType () == SfVectorTlvValue::IPV4_CS_Parameters)
{
CsParameters csParamsRecv (*(*iter));
IpcsClassifierRecord classifier =
csParamsRecv.GetPacketClassifierRule ();
NS_TEST_ASSERT_MSG_EQ (!classifier.CheckMatch (Ipv4Address ("10.1.1.1"),
Ipv4Address ("16.1.1.1"),
1050,
3050,
17), false, "The classifier address did not match.");
NS_TEST_ASSERT_MSG_EQ (!classifier.CheckMatch (Ipv4Address ("10.1.5.1"),
Ipv4Address ("11.1.1.23"),
1070,
3040,
6), false, "The classifier address did not match.");
NS_TEST_ASSERT_MSG_EQ (classifier.CheckMatch (Ipv4Address ("11.1.1.1"),
Ipv4Address ("17.1.1.1"),
1050,
3050,
17), false, "The classifier addresses matched.");
NS_TEST_ASSERT_MSG_EQ (classifier.CheckMatch (Ipv4Address ("10.1.1.1"),
Ipv4Address ("16.1.1.1"),
1050,
3050,
8), false, "The classifier addresses matched.");
}
}
}
}
// ==============================================================================
/*
* Test the service flow tlv implementation.
*/
class Ns3WimaxSfTlvTestCase : public TestCase
{
public:
Ns3WimaxSfTlvTestCase ();
virtual ~Ns3WimaxSfTlvTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxSfTlvTestCase::Ns3WimaxSfTlvTestCase ()
: TestCase ("Test the service flow tlv implementation.")
{
}
Ns3WimaxSfTlvTestCase::~Ns3WimaxSfTlvTestCase ()
{
}
void
Ns3WimaxSfTlvTestCase::DoRun (void)
{
IpcsClassifierRecord classifier = IpcsClassifierRecord ();
CsParameters csParam (CsParameters::ADD, classifier);
ServiceFlow sf = ServiceFlow (ServiceFlow::SF_DIRECTION_DOWN);
sf.SetSfid (100);
sf.SetConvergenceSublayerParam (csParam);
sf.SetCsSpecification (ServiceFlow::IPV4);
sf.SetServiceSchedulingType (ServiceFlow::SF_TYPE_UGS);
sf.SetMaxSustainedTrafficRate (1000000);
sf.SetMinReservedTrafficRate (1000000);
sf.SetMinTolerableTrafficRate (1000000);
sf.SetMaximumLatency (10);
sf.SetMaxTrafficBurst (1000);
sf.SetTrafficPriority (1);
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (sf.ToTlv ());
Tlv tlvReceived;
packet->RemoveHeader (tlvReceived);
ServiceFlow sfRecv = ServiceFlow (tlvReceived);
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetDirection (), ServiceFlow::SF_DIRECTION_DOWN, "The sfRecv had the wrong direction.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetSfid (), 100, "The sfRecv had the wrong sfid.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetCsSpecification (), ServiceFlow::IPV4, "The sfRecv had the wrong cs specification.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetServiceSchedulingType (), ServiceFlow::SF_TYPE_UGS, "The sfRecv had the wrong service scheduling type.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxSustainedTrafficRate (), 1000000, "The sfRecv had the wrong maximum sustained traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinReservedTrafficRate (), 1000000, "The sfRecv had the wrong minimum reserved traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinTolerableTrafficRate (), 1000000, "The sfRecv had the wrong minimum tolerable traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaximumLatency (), 10, "The sfRecv had the wrong maximum latency.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxTrafficBurst (), 1000, "The sfRecv had the wrong maximum traffic burst.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetTrafficPriority (), 1, "The sfRecv had the wrong traffic priority.");
}
// ==============================================================================
class Ns3WimaxTlvTestSuite : public TestSuite
{
public:
Ns3WimaxTlvTestSuite ();
};
Ns3WimaxTlvTestSuite::Ns3WimaxTlvTestSuite ()
: TestSuite ("wimax-tlv", UNIT)
{
AddTestCase (new Ns3WimaxCsParamTlvTestCase);
AddTestCase (new Ns3WimaxSfTlvTestCase);
}
static Ns3WimaxTlvTestSuite ns3WimaxTlvTestSuite;
| zy901002-gpsr | src/wimax/test/wimax-tlv-test.cc | C++ | gpl2 | 8,204 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
#include "ns3/log.h"
#include "ns3/abort.h"
#include "ns3/test.h"
#include "ns3/config.h"
#include "ns3/string.h"
#include "ns3/uinteger.h"
#include "ns3/inet-socket-address.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/ipv4-header.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-header.h"
#include "ns3/simulator.h"
#include "ns3/wimax-helper.h"
#include "ns3/mobility-helper.h"
#include <iostream>
#include "ns3/global-route-manager.h"
using namespace ns3;
/*
* 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
*
*/
class Ns3WimaxNetworkEntryTestCase : public TestCase
{
public:
Ns3WimaxNetworkEntryTestCase ();
virtual ~Ns3WimaxNetworkEntryTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxNetworkEntryTestCase::Ns3WimaxNetworkEntryTestCase ()
: TestCase ("Test the network entry procedure")
{
}
Ns3WimaxNetworkEntryTestCase::~Ns3WimaxNetworkEntryTestCase ()
{
}
void
Ns3WimaxNetworkEntryTestCase::DoRun (void)
{
WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (10);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
bsDevs = wimax.Install (bsNodes,
WimaxHelper::DEVICE_TYPE_BASE_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
Simulator::Stop (Seconds (1));
Simulator::Run ();
for (int i = 0; i < 10; i++)
{
NS_TEST_EXPECT_MSG_EQ (ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> ()->IsRegistered (),true,
"SS[" << i << "] IsNotRegistered");
}
Simulator::Destroy ();
}
/*
* 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:
Ns3WimaxManagementConnectionsTestCase ();
virtual ~Ns3WimaxManagementConnectionsTestCase ();
private:
virtual void DoRun (void);
};
Ns3WimaxManagementConnectionsTestCase::Ns3WimaxManagementConnectionsTestCase ()
: TestCase ("Test if the management connections are correctly setup")
{
}
Ns3WimaxManagementConnectionsTestCase::~Ns3WimaxManagementConnectionsTestCase ()
{
}
void
Ns3WimaxManagementConnectionsTestCase::DoRun (void)
{
WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (10);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
bsDevs = wimax.Install (bsNodes,
WimaxHelper::DEVICE_TYPE_BASE_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
Simulator::Stop (Seconds (1));
Simulator::Run ();
for (int i = 0; i < 10; i++)
{
NS_TEST_EXPECT_MSG_EQ (ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> ()->GetAreManagementConnectionsAllocated (),
true, "Management connections for SS[" << i << "] are not allocated");
}
Simulator::Destroy ();
}
class Ns3WimaxSSMacTestSuite : public TestSuite
{
public:
Ns3WimaxSSMacTestSuite ();
};
Ns3WimaxSSMacTestSuite::Ns3WimaxSSMacTestSuite ()
: TestSuite ("wimax-ss-mac-layer", UNIT)
{
AddTestCase (new Ns3WimaxNetworkEntryTestCase);
AddTestCase (new Ns3WimaxManagementConnectionsTestCase);
}
static Ns3WimaxSSMacTestSuite ns3WimaxSSMacTestSuite;
| zy901002-gpsr | src/wimax/test/ss-mac-test.cc | C++ | gpl2 | 5,039 |
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2007,2008, 2009 INRIA, UDcast
*
* 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
* <amine.ismail@udcast.com>
*/
//
// Default network topology includes a base station (BS) and 2
// subscriber station (SS).
// +-----+
// | SS0 |
// +-----+
// 10.1.1.1
// -------
// ((*))
//
// 10.1.1.7
// +------------+
// |Base Station| ==((*))
// +------------+
//
// ((*))
// -------
// 10.1.1.2
// +-----+
// | SS1 |
// +-----+
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/mobility-module.h"
#include "ns3/config-store-module.h"
#include "ns3/wimax-module.h"
#include "ns3/internet-module.h"
#include "ns3/global-route-manager.h"
#include "ns3/ipcs-classifier-record.h"
#include "ns3/service-flow.h"
#include <iostream>
NS_LOG_COMPONENT_DEFINE ("WimaxSimpleExample");
using namespace ns3;
int main (int argc, char *argv[])
{
bool verbose = false;
int duration = 7, schedType = 0;
WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
CommandLine cmd;
cmd.AddValue ("scheduler", "type of scheduler to use with the network devices", schedType);
cmd.AddValue ("duration", "duration of the simulation in seconds", duration);
cmd.AddValue ("verbose", "turn on all WimaxNetDevice log components", verbose);
cmd.Parse (argc, argv);
LogComponentEnable ("UdpClient", LOG_LEVEL_INFO);
LogComponentEnable ("UdpServer", LOG_LEVEL_INFO);
switch (schedType)
{
case 0:
scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
break;
case 1:
scheduler = WimaxHelper::SCHED_TYPE_MBQOS;
break;
case 2:
scheduler = WimaxHelper::SCHED_TYPE_RTPS;
break;
default:
scheduler = WimaxHelper::SCHED_TYPE_SIMPLE;
}
NodeContainer ssNodes;
NodeContainer bsNodes;
ssNodes.Create (2);
bsNodes.Create (1);
WimaxHelper wimax;
NetDeviceContainer ssDevs, bsDevs;
ssDevs = wimax.Install (ssNodes,
WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION,
WimaxHelper::SIMPLE_PHY_TYPE_OFDM,
scheduler);
bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler);
wimax.EnableAscii ("bs-devices", bsDevs);
wimax.EnableAscii ("ss-devices", ssDevs);
Ptr<SubscriberStationNetDevice> ss[2];
for (int i = 0; i < 2; i++)
{
ss[i] = ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> ();
ss[i]->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12);
}
Ptr<BaseStationNetDevice> bs;
bs = bsDevs.Get (0)->GetObject<BaseStationNetDevice> ();
InternetStackHelper stack;
stack.Install (bsNodes);
stack.Install (ssNodes);
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer SSinterfaces = address.Assign (ssDevs);
Ipv4InterfaceContainer BSinterface = address.Assign (bsDevs);
if (verbose)
{
wimax.EnableLogComponents (); // Turn on all wimax logging
}
/*------------------------------*/
UdpServerHelper udpServer;
ApplicationContainer serverApps;
UdpClientHelper udpClient;
ApplicationContainer clientApps;
udpServer = UdpServerHelper (100);
serverApps = udpServer.Install (ssNodes.Get (0));
serverApps.Start (Seconds (6));
serverApps.Stop (Seconds (duration));
udpClient = UdpClientHelper (SSinterfaces.GetAddress (0), 100);
udpClient.SetAttribute ("MaxPackets", UintegerValue (1200));
udpClient.SetAttribute ("Interval", TimeValue (Seconds (0.5)));
udpClient.SetAttribute ("PacketSize", UintegerValue (1024));
clientApps = udpClient.Install (ssNodes.Get (1));
clientApps.Start (Seconds (6));
clientApps.Stop (Seconds (duration));
Simulator::Stop (Seconds (duration + 0.1));
wimax.EnablePcap ("wimax-simple-ss0", ssNodes.Get (0)->GetId (), ss[0]->GetIfIndex ());
wimax.EnablePcap ("wimax-simple-ss1", ssNodes.Get (1)->GetId (), ss[1]->GetIfIndex ());
wimax.EnablePcap ("wimax-simple-bs0", bsNodes.Get (0)->GetId (), bs->GetIfIndex ());
IpcsClassifierRecord DlClassifierUgs (Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
SSinterfaces.GetAddress (0),
Ipv4Mask ("255.255.255.255"),
0,
65000,
100,
100,
17,
1);
ServiceFlow DlServiceFlowUgs = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN,
ServiceFlow::SF_TYPE_RTPS,
DlClassifierUgs);
IpcsClassifierRecord UlClassifierUgs (SSinterfaces.GetAddress (1),
Ipv4Mask ("255.255.255.255"),
Ipv4Address ("0.0.0.0"),
Ipv4Mask ("0.0.0.0"),
0,
65000,
100,
100,
17,
1);
ServiceFlow UlServiceFlowUgs = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP,
ServiceFlow::SF_TYPE_RTPS,
UlClassifierUgs);
ss[0]->AddServiceFlow (DlServiceFlowUgs);
ss[1]->AddServiceFlow (UlServiceFlowUgs);
NS_LOG_INFO ("Starting simulation.....");
Simulator::Run ();
ss[0] = 0;
ss[1] = 0;
bs = 0;
Simulator::Destroy ();
NS_LOG_INFO ("Done.");
return 0;
}
| zy901002-gpsr | src/wimax/examples/wimax-simple.cc | C++ | gpl2 | 6,789 |