| _cairo_quorem128 | |
| _cairo_quorem64 | |
| _cairo_uquorem128 | |
| _cairo_uquorem64 | |
| ns3::AarfcdWifiManager | Implementation of the AARF-CD algorithm |
| ns3::AarfWifiManager | AARF Rate control algorithm |
| ns3::AccessorHelper< T, U > | |
| ns3::AccessorTrait< T > | |
| ns3::WifiActionHeader::ActionValue | |
| ns3::Address | Polymophic address class |
| ns3::AddressValue | Hold objects of type ns3::Address |
| ns3::AdhocWifiMac | Adhoc state machine |
| ns3::Object::AggregateIterator | Iterate over the objects aggregated to an ns3::Object |
| ns3::dot11s::AirtimeLinkMetricCalculator | Airtime link metric calculator |
| ns3::Ipv6OptionHeader::Alignment | Alignment requirements of an option header |
| ns3::AmrrWifiManager | AMRR Rate control algorithm |
| ns3::AmsduSubframeHeader | |
| ns3::AnimationInterface | Interface to network animator |
| ns3::internal::AnObjectVectorChecker< T > | |
| ns3::AodvHelper | Helper class that adds AODV routing to nodes |
| ns3::internal::APointerChecker< T > | |
| ns3::Application | The base class for all ns3 applications |
| ns3::ApplicationContainer | Holds a vector of ns3::Application pointers |
| ns3::ArfWifiManager | ARF Rate control algorithm |
| ns3::ArpCache | An ARP cache |
| ns3::ArpHeader | The packet header for an ARP packet |
| ns3::ArpL3Protocol | An implementation of the ARP protocol |
| ns3::AsciiTraceHelper | Manage ASCII trace files for device models |
| ns3::AsciiTraceHelperForDevice | Base class providing common user-level ascii trace operations for helpers representing net devices |
| ns3::AsciiTraceHelperForIpv4 | Base class providing common user-level ascii trace operations for helpers representing IPv4 protocols |
| ns3::AsciiTraceHelperForIpv6 | Base class providing common user-level ascii trace operations for helpers representing IPv6 protocols |
| ns3::olsr::MessageHeader::Hna::Association | |
| ns3::AthstatsHelper | Create AthstatsWifiTraceSink instances and connect them to wifi devices |
| ns3::AthstatsWifiTraceSink | Trace sink for wifi device that mimics madwifi's athstats tool |
| ns3::AttributeAccessor | Allow setting and getting the value of an attribute |
| ns3::AttributeChecker | Represent the type of an attribute |
| ns3::AttributeDefaultIterator | |
| ns3::TypeId::AttributeInfo | Store together a set of attribute properties |
| ns3::AttributeIterator | |
| ns3::AttributeList | Container of attributes to be used during object's construction and in ns3::Object::Set |
| ns3::AttributeValue | Hold a value for an Attribute |
| ns3::Average< T > | Simple average, min, max and std. deviation calculator |
| ns3::Backoff | The backoff class is used for calculating backoff times when many net devices can write to the same channel |
| ns3::BandwidthManager | 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 |
| ns3::BandwidthRequestHeader | 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 |
| ns3::Bar | |
| ns3::BaseStationNetDevice | |
| ns3::BlockAckAgreement | Maintains information for a block ack agreement |
| ns3::BlockAckManager | Manages all block ack agreements for an originator station |
| ns3::BooleanValue | Hold a bool native type |
| ns3::BoundFunctorCallbackImpl< T, R, TX, T1, T2, T3, T4, T5, T6, T7, T8 > | |
| ns3::Box | 3d box |
| ns3::BoxValue | Hold objects of type ns3::Box |
| ns3::BridgeChannel | Virtual channel implementation for bridges (BridgeNetDevice) |
| ns3::BridgeHelper | Add capability to bridge multiple LAN segments (IEEE 802.1D bridging) |
| ns3::BridgeNetDevice | Virtual net device that bridges multiple LAN segments |
| ns3::BSLinkManager | |
| ns3::BSScheduler | |
| ns3::BSSchedulerRtps | This class implements a simple downlink scheduler for rtPS flows |
| ns3::BSSchedulerSimple | |
| ns3::BsServiceFlowManager | |
| ns3::Buffer | Automatically resized byte buffer |
| ns3::BurstProfileManager | |
| ns3::ByteTagIterator | Iterator over the set of tags in a packet |
| ns3::ByteTagList | Keep track of the tags stored in a packet |
| cairo_uint128 | |
| ns3::CalendarScheduler | Calendar queue event scheduler |
| ns3::Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | Callback template class |
| ns3::CallbackBase | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| ns3::CallbackImpl< R, empty, empty, empty, empty, empty, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, empty, empty, empty, empty, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, empty, empty, empty, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, empty, empty, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, empty, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, T5, empty, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, T5, T6, empty, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, T5, T6, T7, empty, empty > | |
| ns3::CallbackImpl< R, T1, T2, T3, T4, T5, T6, T7, T8, empty > | |
| ns3::CallbackImplBase | |
| ns3::CallbackTraits< Ptr< T > > | |
| ns3::CallbackTraits< T * > | |
| ns3::CallbackValue | |
| ns3::CandidateQueue | A Candidate Queue used in static routing |
| ns3::CanvasLocation | Keep track of the current location of an object |
| ns3::CapabilityInformation | |
| ns3::CaraWifiManager | Implement the CARA rate control algorithm |
| ns3::Channel | Abstract Channel Base Class |
| ns3::ChannelList | List of simulation channels |
| ns3::Chunk | Abstract base class for ns3::Header and ns3::Trailer |
| ns3::Cid | |
| ns3::CidFactory | |
| ns3::ClassificationRuleVectorTlvValue | |
| ns3::CommandLine | Parse command-line argumentsInstances of this class can be used to parse command-line arguments: users can register new arguments with CommandLine::AddValue but the most important functionality provided by this class is that it can be used to set the 'initial value' of every attribute in the system with the --TypeIdNameAttributeName=value syntax and it can be used to set the value of every GlobalValue in the system with the --GlobalValueName=value syntax |
| ns3::ConfigStore | Store and load simulation attribute configuration |
| ns3::ConnectionManager | |
| ns3::ConstantAccelerationMobilityModel | Position model for which the current acceleration does not change once it has been set and until it is set again explicitely to a new value |
| ns3::ConstantPositionMobilityModel | Position model for which the current position does not change once it has been set and until it is set again explicitely to a new value |
| ns3::ConstantRateWifiManager | Use constant rates for data and control transmissions |
| ns3::ConstantSpeedPropagationDelayModel | Propagation speed is constant |
| ns3::ConstantVariable | A random variable that returns a constantClass ConstantVariable defines a random number generator that returns the same value every sample |
| ns3::ConstantVelocityHelper | |
| ns3::ConstantVelocityMobilityModel | Position model for which the current speed does not change once it has been set and until it is set again explicitely to a new value |
| ns3::Cost231PropagationLossModel | |
| ns3::CounterCalculator< T > | |
| ns3::CriticalSection | A class which provides a simple way to implement a Critical Section |
| ns3::CsmaChannel | Csma Channel |
| ns3::CsmaDeviceRec | CsmaNetDevice Record |
| ns3::CsmaHelper | Build a set of CsmaNetDevice objects |
| ns3::CsmaNetDevice | A Device for a Csma Network Link |
| ns3::CsmaStarHelper | A helper to make it easier to create a star topology with Csma links |
| ns3::CsParameters | |
| ns3::CsParamVectorTlvValue | |
| ns3::CtrlBAckRequestHeader | |
| ns3::CtrlBAckResponseHeader | |
| ns3::DataCalculator | |
| ns3::DataCollector | |
| ns3::DataOutputCallback | |
| ns3::DataOutputInterface | |
| ns3::DataRate | Class for representing data rates |
| ns3::DataRateValue | Hold objects of type ns3::DataRate |
| ns3::DcaTxop | Handle packet fragmentation and retransmissions |
| ns3::Dcd | |
| ns3::DcdChannelEncodings | |
| ns3::Dcf | |
| ns3::DcfManager | Manage a set of ns3::DcfState |
| ns3::DcfState | Keep track of the state needed for a single DCF function |
| ns3::DefaultDeleter< T > | Template used to delete objects by the *RefCount<> templates when the last reference to an object they manage disappears |
| ns3::DefaultSimulatorImpl | |
| ns3::DelayJitterEstimation | Quick and dirty delay and jitter estimation |
| ns3::dot11s::DestinationAddressUnit | Describes an address unit in PREQ information element See 7.3.2.96 for more details |
| ns3::DeterministicVariable | Non-random variableDefines a random variable that has a specified, predetermined sequence. This would be useful when trying to force the RNG to return a known sequence, perhaps to compare NS-3 to some other simulator |
| ns3::DistributedSimulatorImpl | |
| ns3::DlFramePrefixIe | This class implements the DL Frame Prefix IE as described by IEEE-802.16 standard |
| ns3::DlMap | |
| ns3::dot11s::Dot11sMeshCapability | See 7.3.2.86.7 in 802.11s draft 3.0 |
| ns3::Dot11sStack | Helper class to allow easy installation of 802.11s stack |
| ns3::DoubleValue | Hold an floating point type |
| ns3::DropTailQueue | A FIFO packet queue that drops tail-end packets on overflow |
| ns3::DsaAck | |
| ns3::DsaReq | |
| ns3::DsaRsp | |
| ns3::aodv::DuplicatePacketDetection | Helper class used to remember already seen packets and detect duplicates |
| ns3::EdcaTxopN | |
| ns3::EmpiricalVariable | EmpiricalVariable distribution random varDefines a random variable that has a specified, empirical distribution. The distribution is specified by a series of calls to the CDF member function, specifying a value and the probability that the function value is less than the specified value. When values are requested, a uniform random variable is used to select a probability, and the return value is interpreted linearly between the two appropriate points in the CDF. The method is known as inverse transform sampling: (http://en.wikipedia.org/wiki/Inverse_transform_sampling) |
| ns3::empty | Make Callback use a separate empty type |
| ns3::EmptyAttributeValue | A class for an empty attribute value |
| ns3::EmuHelper | Build a set of EmuNetDevice objects |
| ns3::EmuNetDevice | A Device for an Emu Network Link |
| ns3::ArpCache::Entry | A record that that holds information about an ArpCache entry |
| ns3::NdiscCache::Entry | A record that holds information about an NdiscCache entry |
| ns3::EnumChecker | |
| ns3::EnumValue | Hold variables of type 'enum' |
| ns3::ErlangVariable | Erlang Distributed Random VariableErlangVariable defines a random variable with Erlang distribution |
| ns3::ErrorModel | General error model that can be used to corrupt packets |
| ns3::ErrorRateModel | |
| ns3::EthernetHeader | Packet header for Ethernet |
| ns3::EthernetTrailer | Packet trailer for Ethernet |
| ns3::InterferenceHelper::Event | |
| ns3::Scheduler::Event | |
| ns3::EventGarbageCollector | An object that tracks scheduled events and automatically cancels them when it is destroyed. It is useful in situations where multiple instances of the same type of event can simultaneously be scheduled, and when the events should be limited to the lifetime of a container object |
| ns3::EventId | Identifier for simulation events |
| ns3::EventImpl | Simulation event |
| ns3::Scheduler::EventKey | |
| ns3::EventMemberImplObjTraits< Ptr< T > > | |
| ns3::EventMemberImplObjTraits< T * > | |
| ns3::ExponentialVariable | Exponentially Distributed random varThis class supports the creation of objects that return random numbers from a fixed exponential distribution. It also supports the generation of single random numbers from various exponential distributions |
| ns3::dot11s::HwmpProtocol::FailedDestination | Structure of unreachable destination - address and sequence number |
| ns3::FileConfig | |
| ns3::Ipv4FlowClassifier::FiveTuple | |
| ns3::FixedRssLossModel | The propagation loss is fixed. The user can set received power level |
| ns3::flame::FlameHeader | Flame header |
| ns3::flame::FlameProtocol | FLAME routing protocol |
| ns3::flame::FlameProtocolMac | Interface MAC plugin FLAME routing protocol |
| ns3::flame::FlameRtable | Routing table for FLAME |
| ns3::FlameStack | Helper class used to install FLAME mesh stack (actually single protocol in this stack) |
| ns3::flame::FlameTag | Transmitter and receiver addresses |
| ns3::FlowClassifier | |
| ns3::FlowIdTag | |
| ns3::FlowMonitor | An object that monitors and reports back packet flows observed during a simulation |
| ns3::FlowMonitorHelper | Helper to enable IPv4 flow monitoring on a set of Nodes |
| ns3::FlowProbe | |
| ns3::FlowMonitor::FlowStats | Structure that represents the measured metrics of an individual packet flow |
| ns3::FlowProbe::FlowStats | |
| ns3::FragmentationSubheader | 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 |
| ns3::FriisPropagationLossModel | Friis propagation loss model |
| ns3::FunctorCallbackImpl< T, R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| ns3::GammaVariable | Gamma Distributed Random VariableGammaVariable defines a random variable with gamma distribution |
| ns3::GaussMarkovMobilityModel | Description of gauss markov mobility model |
| ns3::GenericMacHeader | 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 |
| ns3::GlobalRouteManager | A global global router |
| ns3::GlobalRouteManagerImpl | A global router implementation |
| ns3::GlobalRouteManagerLSDB | The Link State DataBase (LSDB) of the Global Route Manager |
| ns3::GlobalRouter | An interface aggregated to a node to provide global routing info |
| ns3::GlobalRoutingLinkRecord | A single link record for a link state advertisement |
| ns3::GlobalRoutingLSA | Link State Advertisement (LSA) for a router, used in global routing |
| ns3::GlobalValue | Hold a so-called 'global value' |
| ns3::Gnuplot | Simple class to generate gnuplot-ready plotting commands from a set of datasets |
| ns3::Gnuplot2dDataset | Class to represent a 2D points plot. Set the line or points style using SetStyle() and set points using Add() |
| ns3::Gnuplot2dFunction | Class to represent a 2D function expression plot |
| ns3::Gnuplot3dDataset | Class to represent a 3D points plot. Set the line or points style using SetStyle() and set points using Add() |
| ns3::Gnuplot3dFunction | Class to represent a 3D function expression plot |
| ns3::GnuplotCollection | Simple class to group together multiple gnuplots into one file, e.g. for PDF multi-page output terminals |
| ns3::GnuplotDataset | Abstract class to store a plot line to be used by ns3::Gnuplot |
| ns3::GrantManagementSubheader | |
| ns3::GridPositionAllocator | Allocate positions on a rectangular 2d grid |
| ns3::GtkConfigStore | A class that provides a GTK-based front end to ns3::ConfigStore |
| ns3::Header | Protocol header serialization and deserialization |
| ns3::HeapScheduler | Binary heap event scheduler |
| ns3::olsr::MessageHeader::Hello | |
| ns3::HierarchicalMobilityModel | Hierarchical mobility model |
| ns3::Histogram | |
| ns3::olsr::MessageHeader::Hna | |
| ns3::dot11s::HwmpProtocol | Hybrid wireless mesh protocol -- a routing protocol of IEEE 802.11s draft |
| ns3::dot11s::HwmpProtocolMac | Interface MAC plugin for HWMP -- 802.11s routing protocol |
| ns3::dot11s::HwmpRtable | Routing table for HWMP -- 802.11s routing protocol |
| ns3::dot11s::HwmpTag | Hwmp tag implements interaction between HWMP protocol and MeshWifiMac |
| ns3::Icmpv4DestinationUnreachable | |
| ns3::Icmpv4Echo | |
| ns3::Icmpv4Header | |
| ns3::Icmpv4L4Protocol | |
| ns3::Icmpv4TimeExceeded | |
| ns3::Icmpv6DestinationUnreachable | ICMPv6 Error Destination Unreachable header |
| ns3::Icmpv6Echo | ICMPv6 Echo message |
| ns3::Icmpv6Header | ICMPv6 header |
| ns3::Icmpv6L4Protocol | An implementation of the ICMPv6 protocol |
| ns3::Icmpv6NA | ICMPv6 Neighbor Advertisement header |
| ns3::Icmpv6NS | ICMPv6 Neighbor Solicitation header |
| ns3::Icmpv6OptionHeader | ICMPv6 option header |
| ns3::Icmpv6OptionLinkLayerAddress | ICMPv6 link-layer address option |
| ns3::Icmpv6OptionMtu | ICMPv6 MTU option |
| ns3::Icmpv6OptionPrefixInformation | ICMPv6 Option Prefix Information |
| ns3::Icmpv6OptionRedirected | ICMPv6 redirected option |
| ns3::Icmpv6ParameterError | ICMPv6 Error Parameter Error header |
| ns3::Icmpv6RA | ICMPv6 Router Advertisement header |
| ns3::Icmpv6Redirection | ICMPv6 Redirection header |
| ns3::Icmpv6RS | ICMPv6 Router Solicitation header |
| ns3::Icmpv6TimeExceeded | ICMPv6 Error Time Exceeded header |
| ns3::Icmpv6TooBig | ICMPv6 Error Too Big header |
| ns3::aodv::IdCache | Unique packets identification cache used for simple duplicate detection |
| ns3::IdealWifiManager | Ideal rate control algorithm |
| ns3::dot11s::IeBeaconTiming | See 7.3.2.89 of 802.11s draft 2.07 |
| ns3::dot11s::IeBeaconTimingUnit | Describes one unit of beacon timing element |
| ns3::dot11s::IeConfiguration | Describes Mesh Configuration Element see 7.3.2.86 of 802.11s draft 3.0 |
| ns3::dot11s::IeLinkMetricReport | IEEE 802.11s Mesh ID 7.3.2.88 of 802.11s draft 3.0 |
| ns3::dot11s::IeMeshId | IEEE 802.11s Mesh ID 7.3.287 of 802.11s draft 3.0 |
| ns3::IeMeshIdValue | Hold objects of type ns3::IeMeshId |
| ns3::dot11s::IePeeringProtocol | |
| ns3::dot11s::IePeerManagement | See 7.3.2.85 of draft 2.07 |
| ns3::dot11s::IePerr | See 7.3.2.98 of 802.11s draft 2.07 |
| ns3::dot11s::IePrep | See 7.3.2.97 of 802.11s draft 2.07 |
| ns3::dot11s::IePreq | See 7.3.2.96 of 802.11s draft 2.07 |
| ns3::dot11s::IeRann | See 7.3.2.95 of 802.11s draft 2.07 |
| IInterruptCallback | |
| ns3::Inet6SocketAddress | An Inet6 address class |
| INetDatagramSocket | |
| ns3::InetSocketAddress | Inet address class |
| INetStack | |
| INetStreamSocket | |
| ns3::InetTopologyReader | Topology file reader (Inet-format type) |
| ns3::IntegerValue | Hold a signed integer type |
| ns3::IntEmpiricalVariable | Integer-based empirical distributionDefines an empirical distribution where all values are integers. Indentical to EmpiricalVariable, except that the inverse transform sampling interpolation described in the EmpiricalVariable documentation is modified to only return integers |
| ns3::InterferenceHelper | |
| ns3::InternetStackHelper | Aggregate IP/TCP/UDP functionality to existing Nodes |
| ns3::IntToType< v > | |
| ns3::IpcsClassifier | |
| ns3::IpcsClassifierRecord | |
| ns3::Ipv4 | Access to the Ipv4 forwarding table, interfaces, and configuration |
| ns3::Ipv4AddressTlvValue::ipv4Addr | |
| ns3::Ipv4Address | Ipv4 addresses are stored in host order in this class |
| ns3::Ipv4AddressGenerator | This generator assigns addresses sequentially from a provided network address; used in topology code |
| ns3::Ipv4AddressHash | |
| ns3::Ipv4AddressHelper | A helper class to make life easier while doing simple IPv4 address assignment in scripts |
| ns3::Ipv4AddressTlvValue | |
| ns3::Ipv4AddressValue | Hold objects of type ns3::Ipv4Address |
| ns3::Ipv4EndPoint | A representation of an internet endpoint/connection |
| ns3::Ipv4EndPointDemux | Demultiplexes packets to various transport layer endpoints |
| ns3::Ipv4FlowClassifier | |
| ns3::Ipv4FlowProbe | Class that monitors flows at the IPv4 layer of a Node |
| ns3::Ipv4GlobalRouting | Global routing protocol for IP version 4 stacks |
| ns3::Ipv4GlobalRoutingHelper | Helper class that adds ns3::Ipv4GlobalRouting objects |
| ns3::Ipv4Header | Packet header for IPv4 |
| ns3::Ipv4Interface | The IPv4 representation of a network interface |
| ns3::Ipv4InterfaceAddress | Class to store IPv4 address information on an interface |
| ns3::Ipv4InterfaceContainer | Holds a vector of std::pair of Ptr<Ipv4> and interface index |
| ns3::Ipv4L3Protocol | Implement the Ipv4 layer |
| ns3::Ipv4L4Protocol | L4 Protocol abstract base class |
| ns3::Ipv4ListRouting | |
| ns3::Ipv4ListRoutingHelper | Helper class that adds ns3::Ipv4ListRouting objects |
| ns3::Ipv4Mask | Class to represent an Ipv4 address mask |
| ns3::Ipv4MaskValue | Hold objects of type ns3::Ipv4Mask |
| ns3::Ipv4MulticastRoute | Ipv4 multicast route cache entry (similar to Linux struct mfc_cache) |
| ns3::Ipv4MulticastRoutingTableEntry | A record of an IPv4 multicast route for Ipv4GlobalRouting and Ipv4StaticRouting |
| ns3::Ipv4NixVectorHelper | Helper class that adds Nix-vector routing to nodes |
| ns3::Ipv4NixVectorRouting | |
| ns3::Ipv4RawSocketFactory | API to create RAW socket instances |
| ns3::Ipv4RawSocketFactoryImpl | |
| ns3::Ipv4RawSocketImpl | |
| ns3::Ipv4Route | Ipv4 route cache entry (similar to Linux struct rtable) |
| ns3::Ipv4RoutingHelper | Factory to create ns3::Ipv4RoutingProtocol objects |
| ns3::Ipv4RoutingProtocol | Abstract base class for IPv4 routing protocols |
| ns3::Ipv4RoutingTableEntry | |
| ns3::Ipv4StaticRouting | Static routing protocol for IP version 4 stacks |
| ns3::Ipv4StaticRoutingHelper | Helper class that adds ns3::Ipv4StaticRouting objects |
| ns3::Ipv6 | Access to the IPv6 forwarding table, interfaces, and configuration |
| ns3::Ipv6Address | Describes an IPv6 address |
| ns3::Ipv6AddressHash | Hash function class for IPv6 addresses |
| ns3::Ipv6AddressHelper | Helper class to assign IPv6 address statically |
| ns3::Ipv6AddressValue | Hold objects of type ns3::Ipv6Address |
| ns3::Ipv6AutoconfiguredPrefix | Router prefix information |
| ns3::Ipv6EndPoint | An IPv6 end point, four tuples identification |
| ns3::Ipv6EndPointDemux | Demultiplexor for end points |
| ns3::Ipv6Extension | IPv6 Extension base If you want to implement a new IPv6 extension, all you have to do is implement a subclass of this class and add it to an Ipv6ExtensionDemux |
| ns3::Ipv6ExtensionAH | IPv6 Extension AH (Authentication Header) |
| ns3::Ipv6ExtensionAHHeader | Header of IPv6 Extension AH |
| ns3::Ipv6ExtensionDemux | Demultiplexes IPv6 extensions |
| ns3::Ipv6ExtensionDestination | IPv6 Extension Destination |
| ns3::Ipv6ExtensionDestinationHeader | Header of IPv6 Extension Destination |
| ns3::Ipv6ExtensionESP | IPv6 Extension ESP (Encapsulating Security Payload) |
| ns3::Ipv6ExtensionESPHeader | Header of IPv6 Extension ESP |
| ns3::Ipv6ExtensionFragment | IPv6 Extension Fragment |
| ns3::Ipv6ExtensionFragmentHeader | Header of IPv6 Extension Fragment |
| ns3::Ipv6ExtensionHeader | Header for IPv6 Extension |
| ns3::Ipv6ExtensionHopByHop | IPv6 Extension "Hop By Hop" |
| ns3::Ipv6ExtensionHopByHopHeader | Header of IPv6 Extension "Hop by Hop" |
| ns3::Ipv6ExtensionLooseRouting | IPv6 Extension Loose Routing |
| ns3::Ipv6ExtensionLooseRoutingHeader | Header of IPv6 Extension Routing : Type 0 (Loose Routing) |
| ns3::Ipv6ExtensionRouting | IPv6 Extension Routing If you want to implement a new IPv6 routing extension, all you have to do is implement a subclass of this class and add it to an Ipv6ExtensionRoutingDemux |
| ns3::Ipv6ExtensionRoutingDemux | IPv6 Extension Routing Demux |
| ns3::Ipv6ExtensionRoutingHeader | Header of IPv6 Extension Routing |
| ns3::Ipv6Header | Packet header for IPv6 |
| ns3::Ipv6Interface | The IPv6 representation of a network interface |
| ns3::Ipv6InterfaceAddress | IPv6 address associated with an interface |
| ns3::Ipv6InterfaceContainer | Keep track of a set of IPv6 interfaces |
| ns3::Ipv6L3Protocol | IPv6 layer implementation |
| ns3::Ipv6L4Protocol | IPv6 L4 protocol abstract class |
| ns3::Ipv6ListRouting | Hold list of Ipv6RoutingProtocol objects |
| ns3::Ipv6ListRoutingHelper | Helper class that adds ns3::Ipv6ListRouting objects |
| ns3::Ipv6MulticastRoute | IPv6 multicast route entry |
| ns3::Ipv6MulticastRoutingTableEntry | A record of an IPv6 multicast route |
| ns3::Ipv6Option | IPv6 Option base |
| ns3::Ipv6OptionDemux | IPv6 Option Demux |
| ns3::Ipv6OptionHeader | Header for IPv6 Option |
| ns3::Ipv6OptionJumbogram | IPv6 Option Jumbogram |
| ns3::Ipv6OptionJumbogramHeader | Header of IPv6 Option Jumbogram |
| ns3::Ipv6OptionPad1 | IPv6 Option Pad1 |
| ns3::Ipv6OptionPad1Header | Header of IPv6 Option Pad1 |
| ns3::Ipv6OptionPadn | IPv6 Option Padn |
| ns3::Ipv6OptionPadnHeader | Header of IPv6 Option Padn |
| ns3::Ipv6OptionRouterAlert | IPv6 Option Router Alert |
| ns3::Ipv6OptionRouterAlertHeader | Header of IPv6 Option Router Alert |
| ns3::Ipv6Prefix | Describes an IPv6 prefix. It is just a bitmask like Ipv4Mask |
| ns3::Ipv6PrefixValue | Hold objects of type ns3::Ipv6Prefix |
| ns3::Ipv6RawSocketFactory | API to create IPv6 RAW socket instances |
| ns3::Ipv6RawSocketFactoryImpl | Implementation of IPv6 raw socket factory |
| ns3::Ipv6RawSocketImpl | IPv6 raw socket |
| ns3::Ipv6Route | IPv6 route cache entry |
| ns3::Ipv6RoutingHelper | A factory to create ns3::Ipv6RoutingProtocol objects |
| ns3::Ipv6RoutingProtocol | Abstract base class for Ipv6 routing protocols |
| ns3::Ipv6RoutingTableEntry | A record of an IPv6 route |
| ns3::Ipv6StaticRouting | Static routing protocol for IP version 6 stack |
| ns3::Ipv6StaticRoutingHelper | Helper class that adds ns3::Ipv6StaticRouting objects |
| ISendCallback | |
| ns3::PacketMetadata::Item | |
| ns3::ByteTagList::Iterator::Item | |
| ns3::ByteTagIterator::Item | |
| ns3::PacketTagIterator::Item | |
| ns3::PacketMetadata::ItemIterator | |
| ns3::Buffer::Iterator | Iterator in a Buffer instance |
| ns3::ByteTagList::Iterator | |
| ns3::JakesPropagationLossModel | Jakes propagation loss model |
| ns3::LbtsMessage | |
| ns3::TopologyReader::Link | Inner class holding the details about a link between two nodes |
| ns3::olsr::MessageHeader::Hello::LinkMessage | |
| ns3::ListErrorModel | Provide a list of Packet uids to corrupt |
| ns3::ListPositionAllocator | Allocate positions from a deterministic list specified by the user |
| ns3::ListScheduler | Std::list event scheduler |
| ns3::LlcSnapHeader | Header for the LLC/SNAP encapsulation |
| ns3::LogComponent | |
| ns3::LogDistancePropagationLossModel | Log distance propagation model |
| ns3::LogNormalVariable | Log-normal Distributed random varLogNormalVariable defines a random variable with log-normal distribution. If one takes the natural logarithm of random variable following the log-normal distribution, the obtained values follow a normal distribution. This class supports the creation of objects that return random numbers from a fixed lognormal distribution. It also supports the generation of single random numbers from various lognormal distributions |
| ns3::dot11s::HwmpRtable::LookupResult | Route lookup result, return type of LookupXXX methods |
| ns3::flame::FlameRtable::LookupResult | Route lookup result, return type of LookupXXX methods |
| ns3::LoopbackNetDevice | Virtual network interface that loops back any data sent to it to be immediately received on the same interface |
| ns3::Mac48Address | EUI-48 address |
| ns3::Mac48AddressValue | Hold objects of type ns3::Mac48Address |
| ns3::Mac64Address | EUI-64 address |
| ns3::MacHeaderType | |
| ns3::MacLow | Handle RTS/CTS/DATA/ACK transactions |
| ns3::MacLowBlockAckEventListener | Listen for block ack events |
| ns3::MacLowDcfListener | Listen to NAV events |
| ns3::MacLowTransmissionListener | Listen to events coming from ns3::MacLow |
| ns3::MacLowTransmissionParameters | Control how a packet is transmitted |
| ns3::MacRxMiddle | |
| ns3::MacTxMiddle | |
| ns3::ManagementMessageType | |
| ns3::MapScheduler | Std::map event scheduler |
| ns3::Config::MatchContainer | Hold a set of objects which match a specific search string |
| ns3::MatrixPropagationLossModel | The propagation loss is fixed for each pair of nodes and doesn't depend on their actual positions |
| ns3::MemPtrCallbackImpl< OBJ_PTR, MEM_PTR, R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| ns3::dot11s::MeshHeader | Mesh Control field, see IEEE 802.11s draft 3.0 section 7.1.3.5b |
| ns3::MeshHelper | Helper to create IEEE 802.11s mesh networks |
| ns3::MeshL2RoutingProtocol | Interface for L2 mesh routing protocol and mesh point communication |
| ns3::MeshPointDevice | Virtual net device modeling mesh point |
| ns3::MeshStack | Prototype for class, which helps to install MAC-layer routing stack to ns3::MeshPointDevice |
| ns3::MeshWifiBeacon | Beacon is beacon header + list of arbitrary information elements |
| ns3::MeshWifiInterfaceMac | Basic MAC of mesh point Wi-Fi interface. Its function is extendable through plugins mechanism |
| ns3::MeshWifiInterfaceMacPlugin | Common interface for mesh point interface MAC plugins |
| ns3::olsr::MessageHeader | |
| ns3::MgtAddBaRequestHeader | |
| ns3::MgtAddBaResponseHeader | |
| ns3::MgtAssocRequestHeader | |
| ns3::MgtAssocResponseHeader | |
| ns3::MgtBeaconHeader | |
| ns3::MgtDelBaHeader | |
| ns3::MgtProbeRequestHeader | |
| ns3::MgtProbeResponseHeader | |
| ns3::olsr::MessageHeader::Mid | |
| ns3::MinMaxAvgTotalCalculator< T > | |
| ns3::MinstrelWifiManager | |
| ns3::MobilityHelper | Assign positions and mobility models to nodes |
| ns3::MobilityModel | Keep track of the current position of an object |
| ns3::ModelCreator | |
| ns3::ModelNode | |
| ns3::ModelTypeid | |
| ns3::ModelTypeidCreator | |
| ns3::MpiInterface | |
| ns3::MsduAggregator | Abstract class that concrete msdu aggregators have to implement |
| ns3::MsduStandardAggregator | |
| ns3::NakagamiPropagationLossModel | Nakagami-m fast fading propagation loss model |
| ns3::Names | A directory of name and Ptr<Object> associations that allows us to give any ns3 Object a name |
| ns3::NdiscCache | IPv6 Neighbor Discovery cache |
| ns3::aodv::Neighbors::Neighbor | Neighbor description |
| ns3::aodv::Neighbors | Maintain list of active neighbors |
| ns3::NetDevice | Network layer to device interface |
| ns3::NetDeviceContainer | Holds a vector of ns3::NetDevice pointers |
| ns3::NixVector | Neighbor-index data structure for nix-vector routing |
| ns3::Node | A network Node |
| ns3::NodeContainer | Keep track of a set of node pointers |
| ns3::NodeList | List of simulation nodes |
| ns3::NoneFileConfig | |
| ns3::NormalVariable | Class NormalVariable defines a random variable with a normal (Gaussian) distribution.This class supports the creation of objects that return random numbers from a fixed normal distribution. It also supports the generation of single random numbers from various normal distributions |
| ns3::NqapWifiMac | Non-QoS AP state machine |
| ns3::NqosWifiMacHelper | Create non-qos MAC layers for a ns3::WifiNetDevice. This class can create MACs of type ns3::NqapWifiMac, ns3::NqstaWifiMac, and, ns3::AdhocWifiMac |
| ns3::NqstaWifiMac | Non-QoS STA state machine |
| ns3::Ns2CalendarScheduler | Calendar queue event scheduler |
| ns3::Ns2MobilityHelper | Topology object which can read ns2's movement files generated by the CMU setdest tool |
| ns3::Ns3NscStack | |
| ns3::NscTcpL4Protocol | Nsc wrapper glue, to interface with the Ipv4 protocol underneath |
| ns3::NscTcpSocketFactoryImpl | Socket factory implementation for creating instances of NSC TCP |
| ns3::NscTcpSocketImpl | Socket logic for the NSC TCP sockets |
| ns3::Object | Base class which provides memory management and object aggregation |
| ns3::ObjectBase | Implement the ns-3 type and attribute system |
| ns3::ObjectDeleter | |
| ns3::ObjectFactory | Instantiate subclasses of ns3::Object |
| ns3::ObjectFactoryValue | Hold objects of type ns3::ObjectFactory |
| ns3::ObjectVectorAccessor | |
| ns3::ObjectVectorChecker | |
| ns3::ObjectVectorValue | Contain a vector of ns3::Object pointers |
| ns3::OfdmDcdChannelEncodings | |
| ns3::OfdmDlBurstProfile | |
| ns3::OfdmDlMapIe | |
| ns3::OfdmDownlinkFramePrefix | |
| ns3::OfdmSendParams | |
| ns3::OfdmUcdChannelEncodings | |
| ns3::OfdmUlBurstProfile | |
| ns3::OfdmUlMapIe | |
| ns3::OlsrHelper | Helper class that adds OLSR routing to nodes |
| ns3::olsr::OlsrMprTestCase | Testcase for MPR computation mechanism |
| ns3::OmnetDataOutput | |
| ns3::OnoeWifiManager | Implementation of rate control algorithm developed by Atsushi Onoe |
| ns3::OnOffApplication | Generate traffic to a single destination according to an OnOff pattern |
| ns3::OnOffHelper | A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes |
| ns3::OptionField | Option field for an IPv6ExtensionHeader Enables adding options to an IPv6ExtensionHeader |
| ns3::OrbisTopologyReader | Topology file reader (Orbis-format type) |
| ns3::OriginatorBlockAckAgreement | |
| ns3::OutputStreamWrapper | |
| ns3::Packet | Network packets |
| ns3::PacketBurst | |
| ns3::PacketCounterCalculator | |
| ns3::olsr::PacketHeader | |
| ns3::PacketLossCounter | |
| ns3::PacketMetadata | |
| ns3::PacketSink | Receive and consume traffic generated to an IP address and port |
| ns3::PacketSinkHelper | A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes |
| ns3::PacketSizeMinMaxAvgTotalCalculator | |
| ns3::PacketSocket | A PacketSocket is a link between an application and a net device |
| ns3::PacketSocketAddress | Address for a packet socket |
| ns3::PacketSocketFactory | |
| ns3::PacketSocketHelper | Give ns3::PacketSocket powers to ns3::Node |
| ns3::PacketTagIterator | Iterator over the set of 'packet' tags in a packet |
| ns3::PacketTagList | |
| ns3::ParameterLogger | |
| ns3::ParetoVariable | ParetoVariable distributed random varThis class supports the creation of objects that return random numbers from a fixed pareto distribution. It also supports the generation of single random numbers from various pareto distributions |
| ns3::PbbAddressBlock | An Address Block and its associated Address TLV Blocks |
| ns3::PbbAddressBlockIpv4 | Concrete IPv4 specific PbbAddressBlock |
| ns3::PbbAddressBlockIpv6 | Concrete IPv6 specific PbbAddressBlock |
| ns3::PbbAddressTlv | An Address TLV |
| ns3::PbbAddressTlvBlock | A block of Address TLVs (PbbAddressTlv) |
| ns3::PbbMessage | A message within a PbbPacket packet |
| ns3::PbbMessageIpv4 | Concrete IPv4 specific PbbMessage |
| ns3::PbbMessageIpv6 | Concrete IPv6 specific PbbMessage class |
| ns3::PbbPacket | Main PacketBB Packet object |
| ns3::PbbTlv | A packet or message TLV |
| ns3::PbbTlvBlock | A block of packet or message TLVs (PbbTlv) |
| ns3::PcapFile | |
| ns3::PcapFileWrapper | |
| ns3::PcapHelper | Manage pcap files for device models |
| ns3::PcapHelperForDevice | Base class providing common user-level pcap operations for helpers representing net devices |
| ns3::PcapHelperForIpv4 | Base class providing common user-level pcap operations for helpers representing IPv4 protocols |
| ns3::PcapHelperForIpv6 | Base class providing common user-level pcap operations for helpers representing IPv6 protocols |
| ns3::dot11s::PeerLink | Peer link model for 802.11s Peer Management protocol |
| ns3::dot11s::PeerLinkFrameStart | 802.11s Peer link management frame: |
| ns3::dot11s::PeerManagementProtocol | 802.11s Peer Management Protocol model |
| ns3::dot11s::PeerManagementProtocolMac | This is plugin to Mesh WiFi MAC, which implements interface to dot11s peer management protocol: it takes proper frames from MAC-layer, extracts peer link management information element and mesh configuration element and passes it to main part of protocol |
| ns3::PendingData | Class for managing I/O between applications and TCP |
| ns3::Ping6 | A ping6 application |
| ns3::Ping6Helper | Ping6 application helper |
| ns3::dot11s::PeerLinkFrameStart::PlinkFrameStartFields | Fields: |
| ns3::PointerChecker | |
| ns3::PointerValue | Hold objects of type Ptr<T> |
| ns3::PointToPointChannel | Simple Point To Point Channel |
| ns3::PointToPointDumbbellHelper | A helper to make it easier to create a dumbbell topology with p2p links |
| ns3::PointToPointGridHelper | A helper to make it easier to create a grid topology with p2p links |
| ns3::PointToPointHelper | Build a set of PointToPointNetDevice objects |
| ns3::PointToPointNetDevice | A Device for a Point to Point Network Link |
| ns3::PointToPointRemoteChannel | |
| ns3::PointToPointStarHelper | A helper to make it easier to create a star topology with PointToPoint links |
| ns3::PortRangeTlvValue::PortRange | |
| ns3::PortRangeTlvValue | |
| ns3::PositionAllocator | Allocate a set of positions. The allocation strategy is implemented in subclasses |
| ns3::PppHeader | Packet header for PPP |
| ns3::PriorityUlJob | |
| ns3::PropagationDelayModel | Calculate a propagation delay |
| ns3::PropagationLossModel | Modelize the propagation loss through a transmission medium |
| ns3::ProtocolTlvValue | |
| ns3::Ptr< T > | Smart pointer class similar to boost::intrusive_ptr |
| ns3::QadhocWifiMac | |
| ns3::QapWifiMac | |
| ns3::QosBlockedDestinations | |
| ns3::QosTag | |
| ns3::QosWifiMacHelper | Create qos MAC layers for a ns3::WifiNetDevice. This class can create MACs of type ns3::QapWifiMac, ns3::QstaWifiMac, and, ns3::QadhocWifiMac |
| ns3::QstaWifiMac | |
| ns3::Queue | Abstract base class for packet Queues |
| ns3::aodv::QueueEntry | AODV Queue Entry |
| ns3::RadiotapHeader | Radiotap header implementation |
| ns3::Radvd | Router advertisement daemon |
| ns3::RadvdInterface | Radvd interface configuration |
| ns3::RadvdPrefix | Router prefix for radvd application |
| ns3::RandomBoxPositionAllocator | Allocate random positions within a 3D box according to a set of three random variables |
| ns3::RandomDirection2dMobilityModel | RandomDirection mobility model |
| ns3::RandomDiscPositionAllocator | Allocate random positions within a disc according to a given distribution for the polar coordinates of each node with respect to the provided center of the disc |
| ns3::RandomPropagationDelayModel | Propagation delay is random |
| ns3::RandomPropagationLossModel | The propagation loss follows a random distribution |
| ns3::RandomRectanglePositionAllocator | Allocate random positions within a rectangle according to a pair of random variables |
| ns3::RandomStream | |
| ns3::RandomVariable | The basic RNG for NS-3.Note: The underlying random number generation method used by NS-3 is the RngStream code by Pierre L'Ecuyer at the University of Montreal |
| ns3::RandomVariableValue | Hold objects of type ns3::RandomVariable |
| ns3::RandomWalk2dMobilityModel | 2D random walk position model |
| ns3::RandomWaypointMobilityModel | Random waypoint mobility model |
| ns3::RateErrorModel | Determine which packets are errored corresponding to an underlying distribution, rate, and unit |
| ns3::RawTextConfigLoad | |
| ns3::RawTextConfigSave | |
| ns3::RealRandomStream | |
| ns3::RealtimeSimulatorImpl | |
| ns3::Rectangle | 2d rectangle |
| ns3::RectangleValue | Hold objects of type ns3::Rectangle |
| ns3::RefCountBase | A deprecated way to get reference-counting powers |
| ns3::aodv::RequestQueue | AODV route request queue |
| ns3::aodv::RerrHeader | Route Error (RERR) Message Format |
| ns3::RngReq | |
| ns3::RngRsp | |
| ns3::RngStream | Combined Multiple-Recursive Generator MRG32k3a |
| ns3::aodv::RoutingProtocol | AODV routing protocol |
| ns3::olsr::RoutingProtocol | OLSR routing protocol for IPv4 |
| ns3::aodv::RoutingTable | The Routing table used by AODV protocol |
| ns3::aodv::RoutingTableEntry | Routing table entry |
| ns3::olsr::RoutingTableEntry | An OLSR's routing table entry |
| ns3::RraaWifiManager | Robust Rate Adaptation Algorithm |
| ns3::aodv::RrepAckHeader | Route Reply Acknowledgment (RREP-ACK) Message Format |
| ns3::aodv::RrepHeader | Route Reply (RREP) Message Format |
| ns3::aodv::RreqHeader | Route Request (RREQ) Message Format |
| ns3::RttEstimator | |
| ns3::RttHistory | Implements several variations of round trip time estimators |
| ns3::RttMeanDeviation | |
| ns3::SA | |
| ns3::Scheduler | Maintain the event list |
| ns3::SeedManager | |
| ns3::SendParams | |
| ns3::SentBuffer | |
| ns3::SeqTsHeader | Packet header for Udp client/server application The header is made of a 32bits sequence number followed by a 64bits time stamp |
| SequenceNumber | Class to manage arithmetic operations on sequence numbers (mod 2^32) |
| ns3::SequentialVariable | Return a sequential list of valuesClass SequentialVariable defines a random number generator that returns a sequential sequence. The sequence monotonically increases for a period, then wraps around to the low value and begins monotonically increasing again |
| ns3::ServiceFlow | |
| ns3::ServiceFlowManager | |
| ns3::ServiceFlowRecord | |
| ns3::SfVectorTlvValue | |
| ns3::SimpleChannel | A simple channel, for simple things and testing |
| ns3::SimpleNetDevice | Simple net device for simple things and testing |
| ns3::simpleOfdmSendParam | |
| ns3::SimpleOfdmWimaxChannel | |
| ns3::SimpleOfdmWimaxPhy | |
| ns3::SimpleRefCount< T, PARENT, DELETER > | A template-based reference counting class |
| ns3::SimulationSingleton< T > | |
| ns3::Simulator | Control the scheduling of simulation events |
| ns3::SimulatorImpl | |
| ns3::Singleton< T > | Template singleton |
| ns3::InterferenceHelper::SnrPer | |
| ns3::SNRToBlockErrorRateManager | |
| ns3::SNRToBlockErrorRateRecord | |
| ns3::Socket | A low-level Socket API based loosely on the BSD Socket API.A few things to keep in mind about this type of socket:
- it uses ns-3 API constructs such as class ns3::Address instead of C-style structs
- in contrast to the original BSD socket API, this API is asynchronous: it does not contain blocking calls. Sending and receiving operations must make use of the callbacks provided.
- It also uses class ns3::Packet as a fancy byte buffer, allowing data to be passed across the API using an ns-3 Packet instead of a raw data pointer.
- Not all of the full POSIX sockets API is supported
|
| ns3::SocketAddressTag | This class implements a tag that carries an address of a packet across the socket interface |
| ns3::SocketFactory | Object to create transport layer instances that provide a socket API to applications |
| ns3::SocketIpTtlTag | This class implements a tag that carries the socket-specific TTL of a packet to the IP layer |
| ns3::SocketSetDontFragmentTag | Indicated whether packets should be sent out with the DF flag set |
| ns3::SortProcess | |
| ns3::SortProcessPtr | |
| ns3::SPFVertex | Vertex used in shortest path first (SPF) computations. See RFC 2328, Section 16 |
| ns3::SqliteDataOutput | |
| ns3::Ssid | IEEE 802.11 SSID |
| ns3::SsidValue | Hold objects of type ns3::Ssid |
| ns3::SSLinkManager | |
| ns3::SSManager | |
| ns3::SSRecord | |
| ns3::SSScheduler | |
| ns3::SsServiceFlowManager | |
| ns3::StatisticalSummary | |
| ns3::StatusCode | |
| ns3::SteadyStateRandomWaypointMobilityModel | Steady-state random waypoint mobility model |
| ns3::StringValue | Hold variables of type string |
| ns3::SubscriberStationNetDevice | |
| ns3::SupportedRates | |
| ns3::Synchronizer | Base class used for synchronizing the simulation events to some real time "wall clock." |
| ns3::SystemCondition | A class which provides a relatively platform-independent conditional-wait thread synchronization primitive |
| ns3::SystemMutex | A class which provides a relatively platform-independent Mutual Exclusion thread synchronization primitive |
| ns3::SystemThread | A class which provides a relatively platform-independent thread primitive |
| ns3::SystemWallClockMs | Measure elapsed time in milliseconds |
| ns3::Tag | Tag a set of bytes in a packet |
| ns3::TagBuffer | Read and write tag data |
| ns3::PacketTagList::TagData | |
| ns3::TapBridge | A bridge to make it appear that a real host process is connected to an ns-3 net device |
| ns3::TapBridgeHelper | Build TapBridge to allow ns-3 simulations to interact with Linux tap devices and processes on the Linux host |
| ns3::olsr::MessageHeader::Tc | |
| ns3::TcpHeader | Header for the Transmission Control Protocol |
| ns3::TcpL4Protocol | A layer between the sockets interface and IP |
| ns3::TcpSocket | (abstract) base class of all TcpSockets |
| ns3::TcpSocketFactory | API to create TCP socket instances |
| ns3::TcpSocketFactoryImpl | Socket factory implementation for native ns-3 TCP |
| ns3::TcpSocketImpl | An implementation of a stream socket using TCP |
| ns3::TcpStateMachine | |
| ns3::TestCase | A single test case |
| ns3::TestRandomStream | |
| ns3::TestRunner | A runner to execute tests |
| ns3::TestSuite | A suite of tests to run |
| ns3::TestVectors< T > | A simple way to store test vectors (for stimulus or from responses) |
| ns3::ThreeLogDistancePropagationLossModel | A log distance path loss propagation model with three distance fields. This model is the same as ns3::LogDistancePropagationLossModel except that it has three distance fields: near, middle and far with different exponents |
| ns3::TimeMinMaxAvgTotalCalculator | |
| ns3::Timer | Simple Timer class |
| ns3::TimerImpl | |
| ns3::TimerImplFive< T1, T2, T3, T4, T5 > | |
| ns3::TimerImplFour< T1, T2, T3, T4 > | |
| ns3::TimerImplMemberTraits< T * > | |
| ns3::TimerImplOne< T1 > | |
| ns3::TimerImplSix< T1, T2, T3, T4, T5, T6 > | |
| ns3::TimerImplThree< T1, T2, T3 > | |
| ns3::TimerImplTwo< T1, T2 > | |
| ns3::TimerTraits< T > | |
| ns3::TimeUnit< N > | Keep track of time unit |
| ns3::TimeUnit< 0 > | |
| ns3::TimeUnit< 1 > | |
| ns3::TimeValue | Hold objects of type ns3::Time |
| ns3::Tlv | |
| ns3::TlvValue | |
| ns3::TopologyReader | Interface for input file readers management |
| ns3::TopologyReaderHelper | Helper class which makes it easier to configure and use a generic TopologyReader |
| ns3::TosTlvValue | |
| ns3::TracedCallback< T1, T2, T3, T4, T5, T6, T7, T8 > | Forward calls to a chain of CallbackAn ns3::TracedCallback has almost exactly the same API as a normal ns3::Callback but instead of forwarding calls to a single function (as an ns3::Callback normally does), it forwards calls to a chain of ns3::Callback. TracedCallback::Connect adds a ns3::Callback at the end of the chain of callbacks. TracedCallback::Disconnect removes a ns3::Callback from the chain of callbacks |
| ns3::TracedValue< T > | Trace classes with value semantics |
| ns3::TraceSourceAccessor | Control access to objects' trace sources |
| ns3::Trailer | Protocol trailer serialization and deserialization |
| ns3::TriangularVariable | Triangularly Distributed random varThis distribution is a triangular distribution. The probability density is in the shape of a triangle |
| ns3::TwoRayGroundPropagationLossModel | |
| ns3::aodv::TypeHeader | AODV types |
| ns3::TypeId | Unique identifier for an interface |
| ns3::TypeIdValue | Hold objects of type ns3::TypeId |
| TypeTraits< T > | |
| ns3::U16TlvValue | |
| ns3::U32TlvValue | |
| ns3::U8TlvValue | |
| ns3::Ucd | |
| ns3::UcdChannelEncodings | |
| ns3::UdpClient | A Udp client. Sends UDP packet carrying sequence number and time stamp in their payloads |
| ns3::UdpClientHelper | Create a client application which sends udp packets carrying a 32bit sequence number and a 64 bit time stamp |
| ns3::UdpEchoClient | A Udp Echo client |
| ns3::UdpEchoClientHelper | Create an application which sends a udp packet and waits for an echo of this packet |
| ns3::UdpEchoServer | A Udp Echo server |
| ns3::UdpEchoServerHelper | Create a server application which waits for input udp packets and sends them back to the original sender |
| ns3::UdpHeader | Packet header for UDP packets |
| ns3::UdpL4Protocol | Implementation of the UDP protocol |
| ns3::UdpServer | A Udp server. Receives UDP packets from a remote host. UDP packets carry a 32bits sequence number followed by a 64bits time stamp in their payloads. The application uses, the sequence number to determine if a packet is lost, and the time stamp to compute the delay |
| ns3::UdpServerHelper | Create a server application which waits for input udp packets and uses the information carried into their payload to compute delay and to determine if some packets are lost |
| ns3::UdpSocket | (abstract) base class of all UdpSockets |
| ns3::UdpSocketFactory | API to create UDP socket instances |
| ns3::UdpSocketFactoryImpl | Object to create UDP socket instances |
| ns3::UdpSocketImpl | A sockets interface to UDP |
| ns3::UdpTraceClient | A trace based streamer |
| ns3::UdpTraceClientHelper | |
| ns3::UintegerValue | Hold an unsigned integer type |
| ns3::UlJob | |
| ns3::UlMap | |
| ns3::UniformDiscPositionAllocator | |
| ns3::UniformVariable | The uniform distribution RNG for NS-3.This class supports the creation of objects that return random numbers from a fixed uniform distribution. It also supports the generation of single random numbers from various uniform distributions |
| ns3::UnsafeAttributeList | |
| ns3::UplinkScheduler | Virtual class for uplink scheduler |
| ns3::UplinkSchedulerMBQoS | This class implements a Migration-based Quality of Service uplink scheduler(MBQoS) |
| ns3::UplinkSchedulerRtps | This class implements a simple uplink scheduler for rtPS flows |
| ns3::UplinkSchedulerSimple | |
| ns3::V4Ping | Application which sends one ICMP ECHO request, waits for a REPLYs and reports the calculated RTT |
| ns3::V4PingHelper | Create a pinger application and associate it to a node |
| ns3::Vector2D | 3d vector |
| ns3::Vector2DValue | Hold objects of type ns3::Vector2D |
| ns3::Vector3D | 3d vector |
| ns3::Vector3DValue | Hold objects of type ns3::Vector3D |
| ns3::VectorTlvValue | |
| ns3::VirtualNetDevice | A virtual device, similar to Linux TUN/TAP interfaces |
| ns3::WallClockSynchronizer | Class used for synchronizing the simulation events to a real-time "wall clock" using Posix Clock functions |
| ns3::Watchdog | Very simple watchdog |
| ns3::Waypoint | (time, location) pair |
| ns3::WaypointMobilityModel | Waypoint-based mobility model |
| ns3::WaypointValue | Hold objects of type ns3::Waypoint |
| ns3::WeibullVariable | WeibullVariable distributed random varThis class supports the creation of objects that return random numbers from a fixed weibull distribution. It also supports the generation of single random numbers from various weibull distributions |
| ns3::WifiActionHeader | See IEEE 802.11 chapter 7.3.1.11 |
| ns3::WifiChannel | A 802.11 Channel |
| ns3::WifiHelper | Helps to create WifiNetDevice objects |
| ns3::WifiInformationElement | Information element, as defined in 802.11-2007 standard |
| ns3::WifiInformationElementVector | Information element vector |
| ns3::WifiMac | Base class for all MAC-level wifi objects |
| ns3::WifiMacHeader | |
| ns3::WifiMacHelper | Create MAC objects |
| ns3::WifiMacQueue | 802.11e-specific queue |
| ns3::WifiMacTrailer | |
| ns3::WifiMode | Represent a single transmission mode |
| ns3::WifiModeFactory | Create WifiMode class instances and keep track of them |
| ns3::WifiModeValue | Hold objects of type ns3::WifiMode |
| ns3::WifiNetDevice | Hold together all Wifi-related objects |
| ns3::WifiPhy | 802.11 PHY layer model |
| ns3::WifiPhyHelper | Create PHY objects |
| ns3::WifiPhyListener | Receive notifications about phy events |
| ns3::WifiPhyStateHelper | |
| ns3::WifiRemoteStation | Hold per-remote-station state |
| ns3::WifiRemoteStationInfo | Tid independent remote station statistics |
| ns3::WifiRemoteStationManager | Hold a list of per-remote-station state |
| ns3::WifiRemoteStationState | |
| ns3::WimaxChannel | |
| ns3::WimaxConnection | |
| ns3::WimaxHelper | Helps to manage and create WimaxNetDevice objects |
| ns3::WimaxMacQueue | |
| ns3::WimaxMacToMacHeader | This class implements the mac to mac header needed to dump a wimax pcap file The header format 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 |
| ns3::WimaxNetDevice | |
| ns3::WimaxPhy | |
| ns3::XmlConfigLoad | |
| ns3::XmlConfigSave | |
| ns3::YansErrorRateModel | Model the error rate for different modulations |
| ns3::YansWifiChannel | A Yans wifi channel |
| ns3::YansWifiChannelHelper | Manage and create wifi channel objects for the yans model |
| ns3::YansWifiPhy | 802.11 PHY layer model |
| ns3::YansWifiPhyHelper | Make it easy to create and manage PHY objects for the yans model |
| ns3::ZetaVariable | Zeta Distributed Distributed Random VariableZetaVariable defines a discrete random variable with Zeta distribution |
| ns3::ZipfVariable | Zipf Distributed Random VariableZipfVariable defines a discrete random variable with Zipf distribution |
