| ns3::AarfcdWifiManager | Implementation of the AARF-CD algorithm |
| ns3::AarfWifiManager | AARF Rate control algorithm |
| ns3::Address | Polymophic address class |
| ns3::AddressValue | Hold objects of type ns3::Address |
| ns3::AdhocWifiMac | Adhoc state machine |
| ns3::rapidnet::Aggregator | An base class for all database aggregate operations |
| ns3::rapidnet::AggrMax | Implements the database aggregate operation MAX |
| ns3::rapidnet::AggrMin | Implements the database aggregate operation MIN |
| ns3::rapidnet::AggWrap | A base class for all aggregate-wrap implementation |
| ns3::rapidnet::AggWrapCount | Aggregate wrap implementation for the count aggregate |
| ns3::rapidnet::AggWrapMax | Aggregate wrap for the max aggregate operation |
| ns3::rapidnet::AggWrapMin | Aggregate wrap for the min aggregate operation |
| ns3::rapidnet::AggWrapMinMax | A single aggregate wrap for both Min/Max. We use the template method pattern to let the base classes implement the |
| ns3::AmrrWifiManager | AMRR Rate control algorithm |
| ns3::rapidnet::AppDecoratorTrigger | A generic trigger defined for emitting decorator- frontend events for visualization |
| ns3::Application | The base class for all ns3 applications |
| ns3::ApplicationContainer | Holds a vector of ns3::Application pointers |
| ns3::rapidnet::AppLinkStateTrigger | A trigger to record a link specific event |
| ns3::rapidnet::AppNodeStateTrigger | A trigger to record a node specific event |
| ns3::rapidnet::AppTrigger | An application specific trigger |
| ns3::rapidnet::AppTupleStateTrigger | A trigger to record a tuple event at a node |
| ns3::ArfWifiManager | ARF Rate control algorithm |
| ns3::ArpCache | An ARP cache |
| ns3::ArpCache::ArpCache::Entry | A record that that holds information about an ArpCache entry |
| ns3::ArpHeader | The packet header for an ARP packet |
| ns3::ArpL3Protocol | An implementation of the ARP protocol |
| ns3::rapidnet::Assignor | Implements the database assignment operation. An assignor assigns an attribute with a given name to a tuple by evaluating an |
| ns3::AttributeAccessor | Allow setting and getting the value of an attribute |
| ns3::AttributeChecker | Represent the type of an attribute |
| 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::Backoff | The backoff class is used for calculating backoff times when many net devices can write to the same channel |
| ns3::rapidnet::BlowfishEncryptionManager | A blowfish based encryption manager implementation |
| ns3::BooleanValue | Hold a bool native type |
| ns3::rapidnet::BoolValue | A value type for booleans |
| 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::Buffer | Automatically resized byte buffer |
| ns3::Buffer::Buffer::Iterator | Iterator in a Buffer instance |
| ns3::rapidnet::ByteArrayValue | A value type for uint8_t array (byte buffer) |
| ns3::ByteTagIterator | Iterator over the set of tags in a packet |
| ns3::ByteTagIterator::ByteTagIterator::Item | |
| ns3::ByteTagList | Keep track of the tags stored in a packet |
| ns3::CalendarScheduler | Calendar queue event scheduler |
| ns3::Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | Callback template class |
| ns3::CandidateQueue | A Candidate Queue used in static routing |
| ns3::CaraWifiManager | Implement the CARA rate control algorithm |
| ns3::Channel | Abstract Channel Base Class |
| ns3::Chunk | Abstract base class for ns3::Header and ns3::Trailer |
| ns3::CommandLine | Parse command-line arguments Instances 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::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 constant Class ConstantVariable defines a random number generator that returns the same value every sample |
| 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::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::rapidnet::Database | A RapidNet database |
| ns3::DataRate | Class for representing data rates |
| ns3::DataRateValue | Hold objects of type ns3::DataRate |
| ns3::DcaTxop | Handle packet fragmentation and retransmissions |
| ns3::DcfManager | Manage a set of ns3::DcfState |
| ns3::DcfState | Keep track of the state needed for a single DCF function |
| ns3::DelayJitterEstimation | Quick and dirty delay and jitter estimation |
| ns3::rapidnet::DeleteTrigger | A trigger that is invoked when a tuple is deleted |
| ns3::DeterministicVariable | Non-random variable Defines 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::DoubleValue | Hold an floating point type |
| ns3::DropTailQueue | A FIFO packet queue that drops tail-end packets on overflow |
| ns3::olsr::DuplicateTuple | The type "list of interface addresses" |
| ns3::rapidnet_compiler::EcaContext | Converts a localized representation into ECA or Event Condition Action representation |
| ns3::rapidnet_compiler::EcaRule | An individual ECA rule structure |
| ns3::EmpiricalVariable | EmpiricalVariable distribution random var Defines 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 probabililty, and the return value is interpreted linerarly 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::EnumValue | Hold variables of type 'enum' |
| ns3::ErlangVariable | Erlang Distributed Random Variable ErlangVariable defines a random variable with Erlang distribution |
| ns3::ErrorModel | General error model that can be used to corrupt packets |
| ns3::EthernetHeader | Packet header for Ethernet |
| ns3::EthernetTrailer | Packet trailer for Ethernet |
| 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::rapidnet::EvpKey | Encapsulates EVP_KEY* type from OpenSSL for automatic memory management and load utilities |
| ns3::rapidnet::EvpKeyCache | A read-only cache for loading EvpKey objects |
| ns3::ExponentialVariable | Exponentially Distributed random var This 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::rapidnet::Expression | Abstract base class for all expressions |
| ns3::rapidnet::FAppend | A RapidNet function that returns a list with the given value(s) appended in it |
| ns3::rapidnet::FConcat | A RapidNet function that concatenates two list values |
| ns3::rapidnet::FDiffTime | A RadidNet function that returns the difference of two time strings (in seconds) as an integer |
| ns3::rapidnet::FHslsTtl | A RadidNet function that returns the TTL or the number of hops that a triggered update should propogate in triggered HSLS implementation |
| ns3::FixedRssLossModel | The propagation loss is fixed. The user can set received power level |
| ns3::rapidnet::FLast | A RapidNet function that returns the last element of a list |
| ns3::rapidnet::FMember | A RapidNet function that tests if a given value is the member of a list |
| ns3::rapidnet::FNow | A RapidNet function that returns the current time as a string |
| ns3::rapidnet::FRand | A RapidNet function that returns a random number as a string |
| ns3::rapidnet::FRemoveLast | A RapidNet function that removes and returns last element of a list |
| ns3::FriisPropagationLossModel | Friis propagation loss model |
| ns3::rapidnet::FSha1 | A RadpidNet function that returns the SHA1 hash of the string representation of the given value |
| ns3::rapidnet::FSize | A RapidNet function that returns the size of a list |
| ns3::rapidnet::FSvAndNot | A RapidNet function that computes the andNot result of two summary vectors: (SV_1 & (~ SV_2)) |
| ns3::rapidnet::FSvAppend | A RapidNet function that hashes a given ID (string) into a new summary vector |
| ns3::rapidnet::FSvIn | A RapidNet function that tests whether a given ID (string) is hashed in a summary vector |
| ns3::rapidnet::FSvRemove | FA RapidNet function that hashes a given ID (string) out from a new summary vector |
| ns3::rapidnet::FTypeOf | A RapidNet function that returns the string representation of the type of the given expression |
| ns3::rapidnet::FunctionExpr | Function call as an expression. This class is merely a a marker interface for all functions, it does not provide any functionality |
| ns3::GammaVariable | Gamma Distributed Random Variable GammaVariable defines a random variable with gamma distribution |
| 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::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::rapidnet::HeapRelation | A special type of relation that is similar to a min-heap or a max-heap |
| ns3::HeapScheduler | Binary heap event scheduler |
| ns3::HierarchicalMobilityModel | Hierachical mobility model |
| ns3::IdealWifiManager | Ideal rate control algorithm |
| ns3::rapidnet::IdValue | A value type for 160-bit SHA1 hash values used by chord |
| ns3::olsr::IfaceAssocTuple | An Interface Association Tuple |
| ns3::Inet6SocketAddress | An Inet6 address class |
| ns3::InetSocketAddress | Inet address class |
| ns3::rapidnet::InsertTrigger | A trigger that is invoked when a tuple is inserted |
| ns3::rapidnet::Int32Value | RapidNet value type for 32-bit integers |
| ns3::IntegerValue | Hold a signed integer type |
| ns3::IntEmpiricalVariable | Integer-based empirical distribution Defines 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::InternetStackHelper | Aggregate IP/TCP/UDP functionality to existing Nodes |
| ns3::IntToType< v > | |
| 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::Ipv4AddressHelper | A helper class to make life easier while doing simple IPv4 address assignment in scripts |
| 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::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 | Keep track of a set of ipv4 interfaces |
| 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::Ipv4RawSocketFactory | API to create RAW socket instances |
| ns3::Ipv4Route | Ipv4 route cache entry (similar to Linux struct rtable) |
| ns3::Ipv4RoutingHelper | Factory to create ns3::Ipv4RoutingProtocol objects |
| ns3::Ipv4RoutingTableEntry | |
| ns3::Ipv4StaticRouting | Static routing protocol for IP version 4 stacks |
| ns3::Ipv4StaticRoutingHelper | Helper class that adds ns3::Ipv4StaticRouting objects |
| ns3::rapidnet::Ipv4Value | A value type for IP v4 addresses |
| ns3::Ipv6Address | Describes an IPv6 address |
| ns3::Ipv6AddressValue | Hold objects of type ns3::Ipv6Address |
| ns3::Ipv6Header | Packet header for IPv6 |
| ns3::Ipv6Prefix | Describes an IPv6 prefix. It is just a bitmask like Ipv4Mask |
| ns3::Ipv6PrefixValue | Hold objects of type ns3::Ipv6Prefix |
| ns3::JakesPropagationLossModel | Jakes propagation loss model |
| ns3::olsr::LinkTuple | A Link Tuple |
| 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::rapidnet::ListValue | A value type that is a list of RapidNet value types |
| ns3::LlcSnapHeader | Header for the LLC/SNAP encapsulation |
| ns3::rapidnet_compiler::LocalizeContext | Translates the parsed NDlog protocol in OlContext to a localized representation |
| ns3::LogDistancePropagationLossModel | Log distance propagation model |
| ns3::LogNormalVariable | Log-normal Distributed random var LogNormalVariable 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::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::MacLow | Handle RTS/CTS/DATA/ACK transactions |
| ns3::MacLowDcfListener | Listen to NAV events |
| ns3::MacLowTransmissionListener | Listen to events coming from ns3::MacLow |
| ns3::MacLowTransmissionParameters | Control how a packet is transmitted |
| ns3::MapScheduler | Std::map event scheduler |
| ns3::Config::MatchContainer | Hold a set of objects which match a specific search string |
| ns3::MobilityHelper | Assign positions and mobility models to nodes |
| ns3::MobilityModel | Keep track of the current position of an object |
| ns3::olsr::MprSelectorTuple | An MPR-Selector Tuple |
| ns3::MsduAggregator | Abstract class that concrete msdu aggregators have to implement |
| 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::olsr::NeighborTuple | A Neighbor Tuple |
| ns3::NetDevice | Network layer to device interface |
| ns3::NetDeviceContainer | Holds a vector of ns3::NetDevice pointers |
| ns3::rapidnet::NilValue | A value type that represents a null value |
| ns3::Node | A network Node |
| ns3::NodeContainer | Keep track of a set of node pointers |
| ns3::NodeList | List of simulation nodes |
| 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::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::Object::Object::AggregateIterator | Iterate over the objects aggregated to an ns3::Object |
| ns3::ObjectBase | Implement the ns-3 type and attribute system |
| ns3::ObjectFactory | Instantiate subclasses of ns3::Object |
| ns3::ObjectFactoryValue | Hold objects of type ns3::ObjectFactory |
| ns3::ObjectVectorValue | Contain a vector of ns3::Object pointers |
| ns3::rapidnet_compiler::OlContext | A parsed form of the entire protocol in NDlog |
| ns3::rapidnet_compiler::OlContext::OlContext::Context | The meta-data of SeNDlog context |
| ns3::rapidnet_compiler::OlContext::OlContext::ExtStageSpec | |
| ns3::rapidnet_compiler::OlContext::OlContext::Rule | |
| ns3::rapidnet_compiler::OlContext::OlContext::TableInfo | The meta-data of the table |
| ns3::rapidnet_compiler::OlLexer | A C++ wrapper for the RapidNet lexical analyzer |
| ns3::OlsrHelper | Helper class that adds OLSR routing to nodes |
| 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 | Instanciate an ns3::OnOffApplication on a set of nodes |
| ns3::rapidnet::Operation | An operation over one (unary) or two (binary) operands which are in turn expressions |
| ns3::Packet | Network packets |
| ns3::PacketSink | Receive and consume traffic generated to an IP address and port |
| 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::PacketTagIterator::PacketTagIterator::Item | |
| ns3::ParetoVariable | ParetoVariable distributed random var This 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::rapidnet_compiler::ParseExpr | A ParseExpr represents expressions in the Overlog language |
| ns3::rapidnet_compiler::ParseVal | Boxing up a ValuePtr so we can pass it through the Bison parser |
| ns3::PcapWriter | Pcap output for Packet logger |
| ns3::PendingData | Class for managing I/O between applications and TCP |
| ns3::rapidnet::PkiAuthenticationManager | A PKI based authentication manager implementation |
| ns3::PointerValue | Hold objects of type Ptr<T> |
| ns3::PointToPointChannel | Simple Point To Point Channel |
| ns3::PointToPointHelper | Build a set of PointToPointNetDevice objects |
| ns3::PointToPointNetDevice | A Device for a Point to Point Network Link |
| ns3::PositionAllocator | Allocate a set of positions. The allocation strategy is implemented in subclasses |
| ns3::PppHeader | Packet header for PPP |
| ns3::PropagationDelayModel | Calculate a propagation delay |
| ns3::PropagationLossModel | Modelize the propagation loss through a transmission medium |
| ns3::Ptr< T > | Smart pointer class similar to boost::intrusive_ptr |
| 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::Queue | Abstract base class for packet Queues |
| ns3::RandomDirection2dMobilityModel | RandomDirection mobility model |
| ns3::RandomDiscPositionAllocator | Allocate random positions within a disc according to a pair of random variables |
| 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::rapidnet::RangeExpr | Range expression. It is one of the 4 types as defined by Interval |
| ns3::rapidnet::RapidNetApplicationBase | A base class for all RapidNet applications |
| ns3::rapidnet::RapidNetApplicationHelper | A base helper for all RapidNet applications |
| ns3::rapidnet_compiler::RapidNetContext | Rewrites from the EcaContext to C++ code for RapidNet |
| ns3::rapidnet::RapidNetDecoratorFrontend | A RapidNet extension to the decorator frontend used for visualization |
| ns3::rapidnet::RapidNetHeader | RapidNet extension of |
| ns3::rapidnet_compiler::RapidNetTable | Represents the definition of a materialized table with its name and key attributes |
| ns3::rapidnet_compiler::RapidNetTuple | Represents the tuples (similar to ParseFunctor) that is manipulated in the rule method bodies |
| ns3::RateErrorModel | Determine which packets are errored corresponding to an underlying distribution, rate, and unit |
| ns3::rapidnet::RealValue | A value type for a floating point value |
| ns3::Rectangle | 2d rectangle |
| ns3::RectangleValue | Hold objects of type ns3::Rectangle |
| ns3::RefCountBase | Base class that provides implementations of reference counting operations |
| ns3::rapidnet::RefreshTrigger | A trigger that is invoked when a tuple is refreshed |
| ns3::rapidnet::Relation | A database relation with key attributes defined |
| ns3::rapidnet::RelationBase | A base class for relation objects. A relation has a name and is a collection of |
| ns3::RngStream | Combined Multiple-Recursive Generator MRG32k3a |
| ns3::olsr::RoutingTableEntry | An OLSR's routing table entry |
| ns3::RraaWifiManager | Robust Rate Adaptation Algorithm |
| ns3::RttHistory | Implements several variations of round trip time estimators |
| ns3::Scheduler | Maintain the event list |
| ns3::rapidnet::Selector | Implements the database select operation. It evaluates an expression against the given tuple and returns true if the tuple should be selected, false otherwise |
| ns3::rapidnet::SendlogAuthenticationManager | RapidNet applications delegate the authentication features to the SendlogAuthenticationManager. RapidNet applications written in SeNDlog (and not NDlog) require authentication capabilities. This object represents an interface to the authentication operations "sign" and "verify". Concrete implementations of this interface can be associated to the RapidNet applications at the time of initialization |
| ns3::rapidnet::SendlogEncryptionManager | RapidNet applications delegate the encryption features to the SendlogEncryptionManager. RapidNet applications written in SeNDlog (and not NDlog) require encryption capabilities. This object represents an interface to the encryption operations "encrypt" and "decrypt". Concrete implementations of this interface can be associated to the RapidNet applications at the time of initialization |
| SequenceNumber | Class to manage arithmetic operations on sequence numbers (mod 2^32) |
| ns3::SequentialVariable | Return a sequential list of values Class 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 monotonicaly increasing again |
| ns3::SimpleChannel | A simple channel, for simple things and testing |
| ns3::SimpleNetDevice | Simple net device for simple things and testing |
| ns3::SimulationSingleton< T > | |
| ns3::Simulator | Control the scheduling of simulation events |
| ns3::Singleton< T > | Template singleton |
| 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:
|
| 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::SPFVertex | Vertex used in shortest path first (SPF) computations. See RFC 2328, Section 16 |
| ns3::Ssid | IEEE 802.11 SSID |
| ns3::SsidValue | Hold objects of type ns3::Ssid |
| ns3::StringValue | Hold variables of type string |
| ns3::rapidnet::StrValue | A value type for strings |
| ns3::rapidnet::SvValue | A value type for summary vector. This value type is used by the Epidemic protocol for delay tolerant networks |
| 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 wall-clock time in milliseconds |
| ns3::rapidnet_compiler::TableStore | Stores the definition of materialized tables for the protocol |
| ns3::Tag | Tag a set of bytes in a packet |
| ns3::TagBuffer | Read and write tag data |
| ns3::TapBridge | A bridge to make it appear that a real host process is connected to an ns-3 net device |
| 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::rapidnet::TempRelation | A relation that is implemented as a list of tuples |
| ns3::Test | Base class for new regressions tests |
| ns3::TestManager | Gather and run all regression tests |
| 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::TimeUnit< N > | Keep track of time unit |
| ns3::TimeValue | Hold objects of type ns3::Time |
| ns3::olsr::TopologyTuple | A Topology Tuple |
| ns3::TracedCallback< T1, T2, T3, T4, T5, T6, T7, T8 > | Forward calls to a chain of Callback An 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 var This distribution is a triangular distribution. The probablility density is in the shape of a triangle |
| ns3::rapidnet::Trigger | A callback function object that serves as a database trigger |
| ns3::rapidnet::TriggerList | A list of triggers |
| ns3::rapidnet::Tuple | A RapidNet tuple. A RapidNet tuple is a collection of |
| ns3::rapidnet::TupleAttribute | Represents an attribute of a tuple. An attribute is a name-value pair |
| ns3::olsr::TwoHopNeighborTuple | A 2-hop Tuple |
| ns3::TypeId | Unique identifier for an interface |
| ns3::TypeId::TypeId::AttributeInfo | Store together a set of attribute properties |
| ns3::TypeIdValue | Hold objects of type ns3::TypeId |
| ns3::UdpEchoClient | A Udp Echo client |
| ns3::UdpEchoServer | A Udp Echo server |
| ns3::UdpHeader | Packet header for UDP packets |
| ns3::UdpL4Protocol | Implementation of the UDP protocol |
| 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::UintegerValue | Hold an unsigned integer type |
| 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::rapidnet::Value | The base for all RapidNet value types |
| ns3::rapidnet::ValueExpr | A value expression. Evaluates to the value itself |
| ns3::rapidnet::VarExpr | A variable expression. The variable name is the name of a tuple attribute. It evaluates to the value of that attribute in the given tuple |
| ns3::Vector | 3d cartesian position vector |
| ns3::VectorValue | Hold objects of type ns3::Vector |
| 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::WeibullVariable | WeibullVariable distributed random var This 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::WifiChannel | A 802.11 Channel |
| ns3::WifiHelper | Helps to create WifiNetDevice objects |
| ns3::WifiMac | Base class for all MAC-level wifi objects |
| ns3::WifiMacHelper | Create MAC objects |
| ns3::WifiMacQueue | 802.11e-specific queue |
| ns3::WifiMode | Represent a single transmission mode |
| ns3::WifiModeFactory | Create WifiMode class instances and keep track of them |
| ns3::WifiModeFactory::WifiModeFactory::WifiModeItem | |
| 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::WifiRemoteStation | Hold per-remote-station state |
| ns3::WifiRemoteStationManager | Hold a list of per-remote-station state |
| 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::ZipfVariable | Zipf Distributed random var (between 1 and n included) |
1.5.8