2 # -*- coding: utf-8 -*-
4 from nepi.util import tags
5 from nepi.util.constants import AF_INET, ApplicationStatus as AS, \
6 FactoryCategories as FC
7 from nepi.util.tunchannel_impl import \
8 preconfigure_tunchannel, postconfigure_tunchannel, \
9 wait_tunchannel, create_tunchannel
12 wifi_standards = dict({
13 "WIFI_PHY_STANDARD_holland": 5,
14 "WIFI_PHY_STANDARD_80211p_SCH": 7,
15 "WIFI_PHY_STANDARD_80211_5Mhz": 4,
16 "WIFI_PHY_UNKNOWN": 8,
17 "WIFI_PHY_STANDARD_80211_10Mhz": 3,
18 "WIFI_PHY_STANDARD_80211g": 2,
19 "WIFI_PHY_STANDARD_80211p_CCH": 6,
20 "WIFI_PHY_STANDARD_80211a": 0,
21 "WIFI_PHY_STANDARD_80211b": 1
25 "Icmpv4L4Protocol": 1,
30 service_flow_direction = dict({
32 "SF_DIRECTION_DOWN": 0,
35 service_flow_scheduling_type = dict ({
45 def _get_ipv4_protocol_guid(testbed_instance, node_guid):
46 # search for the Ipv4L3Protocol asociated with the device
47 protos_guids = testbed_instance.get_connected(node_guid, "protos", "node")
48 if len(protos_guids) == 0:
49 raise RuntimeError("No protocols where found for the node %d" % node_guid)
51 for proto_guid in protos_guids:
52 proto_factory_id = testbed_instance._create[proto_guid]
53 if proto_factory_id == "ns3::Ipv4L3Protocol":
54 ipv4_guid = proto_guid
57 raise RuntimeError("No Ipv4L3Protocol associated to node %d. \
58 can't add Ipv4 addresses" % node_guid)
61 def _get_node_guid(testbed_instance, guid):
62 # search for the node asociated with the device
63 node_guids = testbed_instance.get_connected(guid, "node", "devs")
64 if len(node_guids) == 0:
65 raise RuntimeError("Can't instantiate interface %d outside netns \
67 node_guid = node_guids[0]
70 def _get_dev_number(testbed_instance, guid):
71 node_guid = _get_node_guid(testbed_instance, guid)
72 dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
74 for guid_ in dev_guids:
78 return interface_number
80 def _follow_trace(testbed_instance, guid, trace_id, filename):
81 testbed_instance.follow_trace(guid, trace_id, filename)
82 filepath = testbed_instance.trace_filepath(guid, trace_id)
85 ### create traces functions ###
87 def p2pascii_trace(testbed_instance, guid, trace_id):
88 node_guid = _get_node_guid(testbed_instance, guid)
89 interface_number = _get_dev_number(testbed_instance, guid)
90 element = testbed_instance._elements[guid]
91 filename = "trace-p2p-node-%d-dev-%d.tr" % (node_guid, interface_number)
92 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
93 helper = testbed_instance.ns3.PointToPointHelper()
94 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
95 stream = asciiHelper.CreateFileStream(filepath)
96 helper.EnableAscii(stream, element)
98 def p2ppcap_trace(testbed_instance, guid, trace_id):
99 node_guid = _get_node_guid(testbed_instance, guid)
100 interface_number = _get_dev_number(testbed_instance, guid)
101 element = testbed_instance._elements[guid]
102 filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_guid, interface_number)
103 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
104 helper = testbed_instance.ns3.PointToPointHelper()
105 helper.EnablePcap(filepath, element, explicitFilename = True)
107 def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
108 node_guid = _get_node_guid(testbed_instance, guid)
109 interface_number = _get_dev_number(testbed_instance, guid)
110 element = testbed_instance._elements[guid]
111 filename = "trace-csma-node-%d-dev-%d.pcap" % (node_guid, interface_number)
112 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
113 helper = testbed_instance.ns3.CsmaHelper()
114 helper.EnablePcap(filepath, element, promiscuous = promisc,
115 explicitFilename = True)
117 def csmapcap_trace(testbed_instance, guid, trace_id):
119 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
121 def csmapcap_promisc_trace(testbed_instance, guid, trace_id):
123 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
125 def fdpcap_trace(testbed_instance, guid, trace_id):
126 node_guid = _get_node_guid(testbed_instance, guid)
127 interface_number = _get_dev_number(testbed_instance, guid)
128 element = testbed_instance._elements[guid]
129 filename = "trace-fd-node-%d-dev-%d.pcap" % (node_guid, interface_number)
130 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
131 helper = testbed_instance.ns3.FileDescriptorHelper()
132 helper.EnablePcap(filepath, element, explicitFilename = True)
134 def yanswifipcap_trace(testbed_instance, guid, trace_id):
135 dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
136 node_guid = _get_node_guid(testbed_instance, dev_guid)
137 interface_number = _get_dev_number(testbed_instance, dev_guid)
138 element = testbed_instance._elements[dev_guid]
139 filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
140 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
141 helper = testbed_instance.ns3.YansWifiPhyHelper()
142 helper.EnablePcap(filepath, element, explicitFilename = True)
144 def wimaxascii_trace(testbed_instance, guid, trace_id):
145 node_guid = _get_node_guid(testbed_instance, guid)
146 interface_number = _get_dev_number(testbed_instance, guid)
147 element = testbed_instance._elements[guid]
148 filename = "trace-wimax-node-%d-dev-%d.tr" % (node_guid, interface_number)
149 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
150 helper = testbed_instance.ns3.WimaxHelper()
151 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
152 stream = asciiHelper.CreateFileStream (filepath)
153 helper.EnableAscii(stream, element)
154 #helper.EnableLogComponents()
156 def wimaxpcap_trace(testbed_instance, guid, trace_id):
157 node_guid = _get_node_guid(testbed_instance, guid)
158 interface_number = _get_dev_number(testbed_instance, guid)
159 element = testbed_instance._elements[guid]
160 filename = "trace-wimax-node-%d-dev-%d.pcap" % (node_guid, interface_number)
161 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
162 helper = testbed_instance.ns3.WimaxHelper()
163 helper.EnablePcap(filepath, element, explicitFilename = True)
165 def rtt_trace(testbed_instance, guid, trace_id):
166 element = testbed_instance._elements[guid]
167 helper = testbed_instance.ns3.PlotHelper()
168 prefix = "trace-app-%d" % (guid, )
169 filename = helper.GetFilenameFromSource(prefix, element, trace_id)
170 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
171 prefix = filepath[:filepath.find(prefix)+len(prefix)]
172 helper.EnableTrace(element, trace_id, prefix, "T")
174 trace_functions = dict({
175 "P2PPcapTrace": p2ppcap_trace,
176 "P2PAsciiTrace": p2pascii_trace,
177 "CsmaPcapTrace": csmapcap_trace,
178 "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
179 "FileDescriptorPcapTrace": fdpcap_trace,
180 "YansWifiPhyPcapTrace": yanswifipcap_trace,
181 "WimaxPcapTrace": wimaxpcap_trace,
182 "WimaxAsciiTrace": wimaxascii_trace,
186 ### Creation functions ###
188 def create_element(testbed_instance, guid):
189 element_factory = testbed_instance.ns3.ObjectFactory()
190 factory_id = testbed_instance._create[guid]
191 element_factory.SetTypeId(factory_id)
192 construct_parameters = testbed_instance._get_construct_parameters(guid)
193 for name, value in construct_parameters.iteritems():
194 ns3_value = testbed_instance._to_ns3_value(guid, name, value)
195 element_factory.Set(name, ns3_value)
196 element = element_factory.Create()
197 testbed_instance._elements[guid] = element
199 def create_node(testbed_instance, guid):
200 create_element(testbed_instance, guid)
201 element = testbed_instance._elements[guid]
202 element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
204 def create_wifi_standard_model(testbed_instance, guid):
205 create_element(testbed_instance, guid)
206 element = testbed_instance._elements[guid]
207 parameters = testbed_instance._get_parameters(guid)
208 standard = parameters.get("Standard")
210 raise RuntimeError("No wifi standard set for %d" % guid)
211 element.ConfigureStandard(wifi_standards[standard])
213 def create_waypoint_mobility(testbed_instance, guid):
214 create_element(testbed_instance, guid)
215 element = testbed_instance._elements[guid]
216 parameters = testbed_instance._get_parameters(guid)
217 ns3 = testbed_instance.ns3
218 waypoints = parameters.get("WaypointList", "")
219 waypoints = re.sub(" |\(|\)", "", waypoints)
220 for swp in waypoints.split(","):
224 pos = ns3.Vector(float(dwp[1]), float(dwp[2]), float(dwp[3]))
225 waypoint = ns3.Waypoint(time, pos)
226 element.AddWaypoint(waypoint)
228 def create_ipv4protocol(testbed_instance, guid):
229 create_element(testbed_instance, guid)
230 element = testbed_instance._elements[guid]
231 list_routing = testbed_instance.ns3.Ipv4ListRouting()
232 element.SetRoutingProtocol(list_routing)
233 static_routing = testbed_instance.ns3.Ipv4StaticRouting()
234 list_routing.AddRoutingProtocol(static_routing, 1)
236 def create_element_no_constructor(testbed_instance, guid):
237 """ Create function for ns3 classes for which
238 TypeId.HasConstructor == False"""
239 factory_id = testbed_instance._create[guid]
240 factory_name = factory_id.replace("ns3::", "")
241 constructor = getattr(testbed_instance.ns3, factory_name)
242 element = constructor()
243 testbed_instance._elements[guid] = element
245 def create_base_station(testbed_instance, guid):
246 node_guid = _get_node_guid(testbed_instance, guid)
247 node = testbed_instance._elements[node_guid]
248 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
249 if len(phy_guids) == 0:
250 raise RuntimeError("No PHY was found for station %d" % guid)
251 phy = testbed_instance._elements[phy_guids[0]]
252 uplnk_guids = testbed_instance.get_connected(guid, "uplnk", "dev")
253 if len(uplnk_guids) == 0:
254 raise RuntimeError("No uplink scheduler was found for station %d" % guid)
255 uplnk = testbed_instance._elements[uplnk_guids[0]]
256 dwnlnk_guids = testbed_instance.get_connected(guid, "dwnlnk", "dev")
257 if len(dwnlnk_guids) == 0:
258 raise RuntimeError("No downlink scheduler was found for station %d" % guid)
259 dwnlnk = testbed_instance._elements[dwnlnk_guids[0]]
260 element = testbed_instance.ns3.BaseStationNetDevice(node, phy, uplnk, dwnlnk)
261 testbed_instance._elements[guid] = element
263 def create_subscriber_station(testbed_instance, guid):
264 node_guid = _get_node_guid(testbed_instance, guid)
265 node = testbed_instance._elements[node_guid]
266 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
267 if len(phy_guids) == 0:
268 raise RuntimeError("No PHY was found for station %d" % guid)
269 phy = testbed_instance._elements[phy_guids[0]]
270 element = testbed_instance.ns3.SubscriberStationNetDevice(node, phy)
271 element.SetModulationType(testbed_instance.ns3.WimaxPhy.MODULATION_TYPE_QAM16_12)
272 testbed_instance._elements[guid] = element
274 def create_wimax_channel(testbed_instance, guid):
275 element = testbed_instance.ns3.SimpleOfdmWimaxChannel(testbed_instance.ns3.SimpleOfdmWimaxChannel.COST231_PROPAGATION)
276 testbed_instance._elements[guid] = element
278 def create_wimax_phy(testbed_instance, guid):
279 element = testbed_instance.ns3.SimpleOfdmWimaxPhy()
280 testbed_instance._elements[guid] = element
282 def create_service_flow(testbed_instance, guid):
283 parameters = testbed_instance._get_parameters(guid)
284 direction = parameters.get("Direction")
285 if direction == None:
286 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
287 sched = parameters.get("SchedulingType")
289 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
290 ServiceFlow = testbed_instance.ns3.ServiceFlow
291 direction = service_flow_direction[direction]
292 sched = service_flow_scheduling_type[sched]
293 element = ServiceFlow(direction)
294 element.SetCsSpecification(ServiceFlow.IPV4)
295 element.SetServiceSchedulingType(sched)
296 element.SetMaxSustainedTrafficRate(100)
297 element.SetMinReservedTrafficRate(1000000)
298 element.SetMinTolerableTrafficRate(1000000)
299 element.SetMaximumLatency(100)
300 element.SetMaxTrafficBurst(2000)
301 element.SetTrafficPriority(1)
302 element.SetUnsolicitedGrantInterval(1)
303 element.SetMaxSustainedTrafficRate(70)
304 element.SetToleratedJitter(10)
305 element.SetSduSize(49)
306 element.SetRequestTransmissionPolicy(0)
307 testbed_instance._elements[guid] = element
309 def create_ipcs_classifier_record(testbed_instance, guid):
310 parameters = testbed_instance._get_parameters(guid)
311 src_address = parameters.get("SrcAddress")
312 if src_address == None:
313 raise RuntimeError("No SrcAddress was found for classifier %d" % guid)
314 src_address = testbed_instance.ns3.Ipv4Address(src_address)
315 src_mask = parameters.get("SrcMask")
317 raise RuntimeError("No SrcMask was found for classifier %d" % guid)
318 src_mask = testbed_instance.ns3.Ipv4Mask(src_mask)
319 dst_address = parameters.get("DstAddress")
320 if dst_address == None:
321 raise RuntimeError("No Dstddress was found for classifier %d" % guid)
322 dst_address = testbed_instance.ns3.Ipv4Address(dst_address)
323 dst_mask = parameters.get("DstMask")
325 raise RuntimeError("No DstMask was found for classifier %d" % guid)
326 dst_mask = testbed_instance.ns3.Ipv4Mask(dst_mask)
327 src_port_low = parameters.get("SrcPortLow")
328 if src_port_low == None:
329 raise RuntimeError("No SrcPortLow was found for classifier %d" % guid)
330 src_port_high = parameters.get("SrcPortHigh")
331 if src_port_high == None:
332 raise RuntimeError("No SrcPortHigh was found for classifier %d" % guid)
333 dst_port_low = parameters.get("DstPortLow")
334 if dst_port_low == None:
335 raise RuntimeError("No DstPortLow was found for classifier %d" % guid)
336 dst_port_high = parameters.get("DstPortHigh")
337 if dst_port_high == None:
338 raise RuntimeError("No DstPortHigh was found for classifier %d" % guid)
339 protocol = parameters.get("Protocol")
340 if protocol == None or protocol not in l4_protocols:
341 raise RuntimeError("No Protocol was found for classifier %d" % guid)
342 priority = parameters.get("Priority")
344 raise RuntimeError("No Priority was found for classifier %d" % guid)
345 element = testbed_instance.ns3.IpcsClassifierRecord(src_address, src_mask,
346 dst_address, dst_mask, src_port_low, src_port_high, dst_port_low,
347 dst_port_high, l4_protocols[protocol], priority)
348 testbed_instance._elements[guid] = element
350 ### Start/Stop functions ###
352 def start_application(testbed_instance, guid):
353 element = testbed_instance.elements[guid]
354 # BUG: without doing this explicit call it doesn't start!!!
355 # Shouldn't be enough to set the StartTime?
358 def stop_application(testbed_instance, guid):
359 element = testbed_instance.elements[guid]
360 now = testbed_instance.ns3.Simulator.Now()
361 element.SetStopTime(now)
363 ### Status functions ###
365 def status_application(testbed_instance, guid):
366 if guid not in testbed_instance.elements.keys():
367 raise RuntimeError("Can't get status on guid %d" % guid )
368 now = testbed_instance.ns3.Simulator.Now()
370 return AS.STATUS_NOT_STARTED
371 app = testbed_instance.elements[guid]
372 parameters = testbed_instance._get_parameters(guid)
373 start_value = parameters.get("StartTime")
374 if start_value != None:
375 start_time = testbed_instance.ns3.Time(start_value)
376 if now.Compare(start_time) < 0:
377 return AS.STATUS_NOT_STARTED
378 stop_value = parameters.get("StopTime")
379 if stop_value != None:
380 stop_time = testbed_instance.ns3.Time(stop_value)
381 if now.Compare(stop_time) < 0:
382 return AS.STATUS_RUNNING
384 return AS.STATUS_FINISHED
385 return AS.STATUS_UNDETERMINED
387 ### Configure functions ###
389 def configure_traces(testbed_instance, guid):
390 traces = testbed_instance._get_traces(guid)
391 for trace_id in traces:
392 trace_func = trace_functions[trace_id]
393 trace_func(testbed_instance, guid, trace_id)
395 def configure_element(testbed_instance, guid):
396 configure_traces(testbed_instance, guid)
398 def configure_device(testbed_instance, guid):
399 configure_traces(testbed_instance, guid)
401 element = testbed_instance._elements[guid]
403 parameters = testbed_instance._get_parameters(guid)
404 address = parameters.get("macAddress")
406 macaddr = testbed_instance.ns3.Mac48Address(address)
408 macaddr = testbed_instance.ns3.Mac48Address.Allocate()
409 element.SetAddress(macaddr)
411 if not guid in testbed_instance._add_address:
413 # search for the node asociated with the device
414 node_guid = _get_node_guid(testbed_instance, guid)
415 node = testbed_instance.elements[node_guid]
416 # search for the Ipv4L3Protocol asociated with the device
417 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
418 ipv4 = testbed_instance._elements[ipv4_guid]
419 ns3 = testbed_instance.ns3
421 addresses = testbed_instance._add_address[guid]
422 for address in addresses:
423 (address, netprefix, broadcast) = address
424 # TODO: missing IPV6 addresses!!
425 ifindex = ipv4.AddInterface(element)
426 inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
427 ns3.Ipv4Mask("/%d" % netprefix))
428 ipv4.AddAddress(ifindex, inaddr)
429 ipv4.SetMetric(ifindex, 1)
432 def _add_static_route(ns3, static_routing,
433 address, netprefix, nexthop_address, ifindex):
435 # Default route: 0.0.0.0/0
436 static_routing.SetDefaultRoute(nexthop_address, ifindex)
437 elif netprefix == 32:
438 # Host route: x.y.z.w/32
439 static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
441 # Network route: x.y.z.w/n
442 mask = ns3.Ipv4Mask("/%d" % netprefix)
443 static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
446 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
448 # Default route: 0.0.0.0/0
449 static_routing.SetDefaultRoute(ifindex)
450 elif netprefix == 32:
451 # Host route: x.y.z.w/32
452 static_routing.AddHostRouteTo(address, ifindex)
454 # Network route: x.y.z.w/n
455 mask = ns3.Ipv4Mask("/%d" % netprefix)
456 static_routing.AddNetworkRouteTo(address, mask, ifindex)
458 def configure_node(testbed_instance, guid):
459 configure_traces(testbed_instance, guid)
461 element = testbed_instance._elements[guid]
462 if not guid in testbed_instance._add_route:
464 # search for the Ipv4L3Protocol asociated with the device
465 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
466 ipv4 = testbed_instance._elements[ipv4_guid]
467 list_routing = ipv4.GetRoutingProtocol()
468 (static_routing, priority) = list_routing.GetRoutingProtocol(0)
469 ns3 = testbed_instance.ns3
470 routes = testbed_instance._add_route[guid]
472 (destination, netprefix, nexthop, metric) = route
473 address = ns3.Ipv4Address(destination)
475 nexthop_address = ns3.Ipv4Address(nexthop)
477 # TODO: HACKISH way of getting the ifindex... improve this
478 nifaces = ipv4.GetNInterfaces()
479 for ifidx in xrange(nifaces):
480 iface = ipv4.GetInterface(ifidx)
481 naddress = iface.GetNAddresses()
482 for addridx in xrange(naddress):
483 ifaddr = iface.GetAddress(addridx)
484 ifmask = ifaddr.GetMask()
485 ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
489 # Check previous ptp routes
490 for chaindest, chainprefix, chainhop in routes:
491 if chaindest == nexthop and chainprefix == 32:
492 chainhop_address = ns3.Ipv4Address(chainhop)
493 for ifidx in xrange(nifaces):
494 iface = ipv4.GetInterface(ifidx)
495 naddress = iface.GetNAddresses()
496 for addridx in xrange(naddress):
497 ifaddr = iface.GetAddress(addridx)
498 ifmask = ifaddr.GetMask()
499 ifindex = ipv4.GetInterfaceForPrefix(chainhop_address, ifmask)
503 raise RuntimeError, "Cannot associate interface for routing entry:" \
504 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
505 _add_static_route(ns3, static_routing,
506 address, netprefix, nexthop_address, ifindex)
508 mask = ns3.Ipv4Mask("/%d" % netprefix)
509 ifindex = ipv4.GetInterfaceForPrefix(address, mask)
511 raise RuntimeError, "Cannot associate interface for routing entry:" \
512 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
513 _add_static_route_if(ns3, static_routing,
514 address, netprefix, nexthop_address, ifindex)
516 def configure_station(testbed_instance, guid):
517 configure_device(testbed_instance, guid)
518 element = testbed_instance._elements[guid]
523 factories_order = ["ns3::BasicEnergySource",
524 "ns3::WifiRadioEnergyModel",
525 "ns3::BSSchedulerRtps",
526 "ns3::BSSchedulerSimple",
527 "ns3::UdpTraceClient",
533 "ns3::flame::FlameProtocol",
534 "ns3::flame::FlameRtable",
535 "ns3::dot11s::AirtimeLinkMetricCalculator",
536 "ns3::dot11s::HwmpProtocol",
537 "ns3::dot11s::HwmpRtable",
538 "ns3::dot11s::PeerManagementProtocol",
539 "ns3::dot11s::PeerLink",
540 "ns3::MeshWifiInterfaceMac",
541 "ns3::MeshPointDevice",
544 "ns3::UanPhyCalcSinrDual",
545 "ns3::UanPhyPerGenDefault",
547 "ns3::UanPropModelThorp",
549 "ns3::UanNoiseModelDefault",
551 "ns3::UanPropModelIdeal",
552 "ns3::UanTransducerHd",
553 "ns3::UanPhyCalcSinrDefault",
555 "ns3::UanPhyCalcSinrFhFsk",
556 "ns3::UanPhyPerUmodem",
559 "ns3::AthstatsWifiTraceSink",
562 "ns3::NonCommunicatingNetDevice",
563 "ns3::HalfDuplexIdealPhy",
564 "ns3::AlohaNoackNetDevice",
565 "ns3::SpectrumAnalyzer",
566 "ns3::WaveformGenerator",
567 "ns3::MultiModelSpectrumChannel",
568 "ns3::SingleModelSpectrumChannel",
569 "ns3::MsduStandardAggregator",
573 "ns3::QadhocWifiMac",
574 "ns3::MinstrelWifiManager",
575 "ns3::CaraWifiManager",
576 "ns3::AarfcdWifiManager",
577 "ns3::OnoeWifiManager",
578 "ns3::AmrrWifiManager",
579 "ns3::ConstantRateWifiManager",
580 "ns3::IdealWifiManager",
581 "ns3::AarfWifiManager",
582 "ns3::ArfWifiManager",
583 "ns3::WifiNetDevice",
589 "ns3::YansWifiChannel",
591 "ns3::NistErrorRateModel",
592 "ns3::YansErrorRateModel",
593 "ns3::WaypointMobilityModel",
594 "ns3::ConstantAccelerationMobilityModel",
595 "ns3::RandomDirection2dMobilityModel",
596 "ns3::RandomWalk2dMobilityModel",
597 "ns3::SteadyStateRandomWaypointMobilityModel",
598 "ns3::RandomWaypointMobilityModel",
599 "ns3::GaussMarkovMobilityModel",
600 "ns3::ConstantVelocityMobilityModel",
601 "ns3::ConstantPositionMobilityModel",
602 "ns3::ListPositionAllocator",
603 "ns3::GridPositionAllocator",
604 "ns3::RandomRectanglePositionAllocator",
605 "ns3::RandomBoxPositionAllocator",
606 "ns3::RandomDiscPositionAllocator",
607 "ns3::UniformDiscPositionAllocator",
608 "ns3::HierarchicalMobilityModel",
609 "ns3::aodv::RoutingProtocol",
610 "ns3::UdpEchoServer",
611 "ns3::UdpEchoClient",
613 "ns3::OnOffApplication",
614 "ns3::VirtualNetDevice",
615 "ns3::FileDescriptorNetDevice",
616 "ns3::Nepi::TunChannel",
618 "ns3::BridgeChannel",
619 "ns3::BridgeNetDevice",
622 "ns3::CsmaNetDevice",
623 "ns3::PointToPointRemoteChannel",
624 "ns3::PointToPointChannel",
625 "ns3::PointToPointNetDevice",
626 "ns3::NscTcpL4Protocol",
627 "ns3::Icmpv6L4Protocol",
628 "ns3::Ipv6OptionPad1",
629 "ns3::Ipv6OptionPadn",
630 "ns3::Ipv6OptionJumbogram",
631 "ns3::Ipv6OptionRouterAlert",
632 "ns3::Ipv6ExtensionHopByHop",
633 "ns3::Ipv6ExtensionDestination",
634 "ns3::Ipv6ExtensionFragment",
635 "ns3::Ipv6ExtensionRouting",
636 "ns3::Ipv6ExtensionLooseRouting",
637 "ns3::Ipv6ExtensionESP",
638 "ns3::Ipv6ExtensionAH",
639 "ns3::Ipv6L3Protocol",
640 "ns3::LoopbackNetDevice",
641 "ns3::Icmpv4L4Protocol",
642 "ns3::RttMeanDeviation",
643 "ns3::ArpL3Protocol",
644 "ns3::TcpL4Protocol",
645 "ns3::UdpL4Protocol",
646 "ns3::Ipv4L3Protocol",
647 "ns3::SimpleNetDevice",
648 "ns3::SimpleChannel",
650 "ns3::DropTailQueue",
652 "ns3::FriisSpectrumPropagationLossModel",
653 "ns3::Cost231PropagationLossModel",
654 "ns3::JakesPropagationLossModel",
655 "ns3::RandomPropagationLossModel",
656 "ns3::FriisPropagationLossModel",
657 "ns3::TwoRayGroundPropagationLossModel",
658 "ns3::LogDistancePropagationLossModel",
659 "ns3::ThreeLogDistancePropagationLossModel",
660 "ns3::NakagamiPropagationLossModel",
661 "ns3::FixedRssLossModel",
662 "ns3::MatrixPropagationLossModel",
663 "ns3::RangePropagationLossModel",
664 "ns3::RandomPropagationDelayModel",
665 "ns3::ConstantSpeedPropagationDelayModel",
666 "ns3::RateErrorModel",
667 "ns3::ListErrorModel",
668 "ns3::ReceiveListErrorModel",
670 "ns3::EnergySourceContainer",
671 "ns3::BSSchedulerRtps",
672 "ns3::BSSchedulerSimple",
673 "ns3::SimpleOfdmWimaxChannel",
674 "ns3::SimpleOfdmWimaxPhy",
675 "ns3::UplinkSchedulerMBQoS",
676 "ns3::UplinkSchedulerRtps",
677 "ns3::UplinkSchedulerSimple",
678 "ns3::IpcsClassifierRecord",
680 "ns3::BaseStationNetDevice",
681 "ns3::SubscriberStationNetDevice",
684 factories_info = dict({
686 "category": FC.CATEGORY_APPLICATIONS,
687 "create_function": create_element,
688 "configure_function": configure_element,
689 "stop_function": stop_application,
690 "start_function": start_application,
691 "status_function": status_application,
693 "connector_types": [],
694 "box_attributes": ["MaxPackets",
701 "tags": [tags.APPLICATION],
703 "ns3::UdpL4Protocol": dict({
704 "category": FC.CATEGORY_PROTOCOLS,
705 "create_function": create_element,
706 "configure_function": configure_element,
708 "connector_types": ["node"],
709 "box_attributes": ["ProtocolNumber"],
710 "tags": [tags.PROTOCOL],
712 "ns3::RandomDiscPositionAllocator": dict({
713 "category": FC.CATEGORY_MOBILITY_MODELS,
714 "create_function": create_element,
715 "configure_function": configure_element,
717 "connector_types": [],
718 "box_attributes": ["Theta",
722 "tags": [tags.MOBILE],
725 "category": FC.CATEGORY_NODES,
726 "create_function": create_node,
727 "configure_function": configure_node,
729 "connector_types": ["devs", "apps", "protos", "mobility"],
730 "tags": [tags.NODE, tags.ALLOW_ROUTES],
732 "ns3::GridPositionAllocator": dict({
733 "category": FC.CATEGORY_MOBILITY_MODELS,
734 "create_function": create_element,
735 "configure_function": configure_element,
737 "connector_types": [],
738 "box_attributes": ["GridWidth",
745 "ns3::TapBridge": dict({
746 "category": FC.CATEGORY_DEVICES,
747 "create_function": create_element,
748 "configure_function": configure_element,
750 "connector_types": [],
751 "box_attributes": ["Mtu",
759 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
761 "ns3::FlowMonitor": dict({
762 "category": FC.CATEGORY_SERVICE_FLOWS,
763 "create_function": create_element,
764 "configure_function": configure_element,
766 "connector_types": [],
767 "box_attributes": ["MaxPerHopDelay",
770 "PacketSizeBinWidth",
771 "FlowInterruptionsBinWidth",
772 "FlowInterruptionsMinTime"],
774 "ns3::ConstantVelocityMobilityModel": dict({
775 "category": FC.CATEGORY_MOBILITY_MODELS,
776 "create_function": create_element,
777 "configure_function": configure_element,
779 "connector_types": ["node"],
780 "box_attributes": ["Position",
782 "tags": [tags.MOBILE],
784 "ns3::V4Ping": dict({
785 "category": FC.CATEGORY_APPLICATIONS,
786 "create_function": create_element,
787 "configure_function": configure_element,
789 "connector_types": ["node"],
790 "stop_function": stop_application,
791 "start_function": start_application,
792 "status_function": status_application,
793 "box_attributes": ["Remote",
800 "tags": [tags.APPLICATION],
802 "ns3::dot11s::PeerLink": dict({
804 "create_function": create_element,
805 "configure_function": configure_element,
807 "connector_types": [],
808 "box_attributes": ["RetryTimeout",
815 "ns3::PointToPointNetDevice": dict({
816 "category": FC.CATEGORY_DEVICES,
817 "create_function": create_element,
818 "configure_function": configure_device,
820 "connector_types": ["node", "err", "queue", "chan"],
821 "box_attributes": ["Mtu",
825 "traces": ["p2ppcap", "p2pascii"],
826 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
828 "ns3::NakagamiPropagationLossModel": dict({
829 "category": FC.CATEGORY_LOSS_MODELS,
830 "create_function": create_element,
831 "configure_function": configure_element,
833 "connector_types": [],
834 "box_attributes": ["Distance1",
840 "ns3::AarfWifiManager": dict({
841 "category": FC.CATEGORY_MANAGERS,
842 "create_function": create_element,
843 "configure_function": configure_element,
845 "connector_types": ["dev"],
846 "box_attributes": ["SuccessK",
848 "MaxSuccessThreshold",
850 "MinSuccessThreshold",
855 "FragmentationThreshold",
858 "ns3::Ipv6OptionJumbogram": dict({
860 "create_function": create_element,
861 "configure_function": configure_element,
863 "connector_types": [],
864 "box_attributes": ["OptionNumber"],
866 "ns3::TwoRayGroundPropagationLossModel": dict({
867 "category": FC.CATEGORY_LOSS_MODELS,
868 "create_function": create_element,
869 "configure_function": configure_element,
871 "connector_types": [],
872 "box_attributes": ["Lambda",
877 "ns3::OnOffApplication": dict({
878 "category": FC.CATEGORY_APPLICATIONS,
879 "create_function": create_element,
880 "configure_function": configure_element,
882 "connector_types": ["node"],
883 "stop_function": stop_application,
884 "start_function": start_application,
885 "status_function": status_application,
886 "box_attributes": ["DataRate",
895 "tags": [tags.APPLICATION],
897 "ns3::AdhocWifiMac": dict({
898 "category": FC.CATEGORY_MAC_MODELS,
899 "create_function": create_element,
900 "configure_function": configure_element,
902 "connector_types": [],
903 "box_attributes": ["CtsTimeout",
905 "BasicBlockAckTimeout",
906 "CompressedBlockAckTimeout",
911 "MaxPropagationDelay",
914 "ns3::ConstantAccelerationMobilityModel": dict({
915 "category": FC.CATEGORY_MOBILITY_MODELS,
916 "create_function": create_element,
917 "configure_function": configure_element,
919 "connector_types": ["node"],
920 "box_attributes": ["Position",
922 "tags": [tags.MOBILE],
924 "ns3::GaussMarkovMobilityModel": dict({
925 "category": FC.CATEGORY_MOBILITY_MODELS,
926 "create_function": create_element,
927 "configure_function": configure_element,
929 "connector_types": [],
930 "box_attributes": ["Bounds",
941 "tags": [tags.MOBILE],
943 "ns3::dot11s::HwmpProtocol": dict({
944 "category": FC.CATEGORY_PROTOCOLS,
945 "create_function": create_element,
946 "configure_function": configure_element,
948 "connector_types": [],
949 "box_attributes": ["RandomStart",
951 "Dot11MeshHWMPmaxPREQretries",
952 "Dot11MeshHWMPnetDiameterTraversalTime",
953 "Dot11MeshHWMPpreqMinInterval",
954 "Dot11MeshHWMPperrMinInterval",
955 "Dot11MeshHWMPactiveRootTimeout",
956 "Dot11MeshHWMPactivePathTimeout",
957 "Dot11MeshHWMPpathToRootInterval",
958 "Dot11MeshHWMPrannInterval",
960 "UnicastPerrThreshold",
961 "UnicastPreqThreshold",
962 "UnicastDataThreshold",
966 "ns3::NscTcpL4Protocol": dict({
967 "category": FC.CATEGORY_PROTOCOLS,
968 "create_function": create_element,
969 "configure_function": configure_element,
971 "connector_types": [],
972 "box_attributes": ["Library",
975 "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
977 "create_function": create_element,
978 "configure_function": configure_element,
980 "connector_types": [],
981 "box_attributes": ["Dot11sMeshHeaderLength"],
983 "ns3::UanMacCw": dict({
985 "create_function": create_element,
986 "configure_function": configure_element,
988 "connector_types": [],
989 "box_attributes": ["CW",
992 "ns3::AthstatsWifiTraceSink": dict({
994 "create_function": create_element,
995 "configure_function": configure_element,
997 "connector_types": [],
998 "box_attributes": ["Interval"],
1000 "ns3::FlameStack": dict({
1002 "create_function": create_element,
1003 "configure_function": configure_element,
1005 "connector_types": [],
1006 "box_attributes": [],
1008 "ns3::UanMacRc": dict({
1010 "create_function": create_element,
1011 "configure_function": configure_element,
1013 "connector_types": [],
1014 "box_attributes": ["RetryRate",
1021 "NumberOfRetryRates",
1024 "ns3::WaypointMobilityModel": dict({
1025 "category": FC.CATEGORY_MOBILITY_MODELS,
1026 "create_function": create_waypoint_mobility,
1027 "configure_function": configure_element,
1028 "help": "Waypoint-based mobility model.",
1029 "connector_types": ["node"],
1030 "box_attributes": ["WaypointsLeft",
1034 "tags": [tags.MOBILE],
1036 "ns3::FileDescriptorNetDevice": dict({
1037 "category": FC.CATEGORY_DEVICES,
1038 "create_function": create_element,
1039 "configure_function": configure_device,
1040 "help": "Network interface associated to a file descriptor",
1041 "connector_types": ["node", "->fd"],
1042 "box_attributes": ["Address",
1043 "LinuxSocketAddress",
1044 "tun_proto", "tun_addr", "tun_port", "tun_key"],
1045 "traces": ["fdpcap"],
1046 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1048 "ns3::Nepi::TunChannel": dict({
1049 "category": FC.CATEGORY_TUNNELS,
1050 "create_function": create_tunchannel,
1051 "preconfigure_function": preconfigure_tunchannel,
1052 "configure_function": postconfigure_tunchannel,
1053 "prestart_function": wait_tunchannel,
1054 "help": "Channel to forward FileDescriptorNetDevice data to "
1055 "other TAP interfaces supporting the NEPI tunneling protocol.",
1056 "connector_types": ["fd->", "udp", "tcp"],
1057 "allow_addresses": False,
1058 "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key"],
1059 "tags": [tags.TUNNEL],
1062 "ns3::CsmaNetDevice": dict({
1063 "category": FC.CATEGORY_DEVICES,
1064 "create_function": create_element,
1065 "configure_function": configure_device,
1066 "help": "CSMA (carrier sense, multiple access) interface",
1067 "connector_types": ["node", "chan", "err", "queue"],
1068 "box_attributes": ["Address",
1072 "traces": ["csmapcap", "csmapcap_promisc"],
1073 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1075 "ns3::UanPropModelThorp": dict({
1077 "create_function": create_element,
1078 "configure_function": configure_element,
1080 "connector_types": [],
1081 "box_attributes": ["SpreadCoef"],
1083 "ns3::NqstaWifiMac": dict({
1084 "category": FC.CATEGORY_MAC_MODELS,
1085 "create_function": create_wifi_standard_model,
1086 "configure_function": configure_element,
1088 "connector_types": ["dev"],
1089 "box_attributes": ["ProbeRequestTimeout",
1090 "AssocRequestTimeout",
1094 "BasicBlockAckTimeout",
1095 "CompressedBlockAckTimeout",
1100 "MaxPropagationDelay",
1103 "ns3::Icmpv6L4Protocol": dict({
1104 "category": FC.CATEGORY_PROTOCOLS,
1105 "create_function": create_element,
1106 "configure_function": configure_element,
1108 "connector_types": ["node"],
1109 "box_attributes": ["DAD",
1112 "ns3::SimpleNetDevice": dict({
1113 "category": FC.CATEGORY_DEVICES,
1114 "create_function": create_element,
1115 "configure_function": configure_element,
1117 "connector_types": ["node", "chan"],
1118 "box_attributes": [],
1119 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1121 "ns3::FriisPropagationLossModel": dict({
1122 "category": FC.CATEGORY_LOSS_MODELS,
1123 "create_function": create_element,
1124 "configure_function": configure_element,
1126 "connector_types": [],
1127 "box_attributes": ["Lambda",
1131 "ns3::Ipv6OptionRouterAlert": dict({
1133 "create_function": create_element,
1134 "configure_function": configure_element,
1136 "connector_types": [],
1137 "box_attributes": ["OptionNumber"],
1139 "ns3::UniformDiscPositionAllocator": dict({
1140 "category": FC.CATEGORY_MOBILITY_MODELS,
1141 "create_function": create_element,
1142 "configure_function": configure_element,
1144 "connector_types": [],
1145 "box_attributes": ["rho",
1148 "tags": [tags.MOBILE],
1150 "ns3::RandomBoxPositionAllocator": dict({
1151 "category": FC.CATEGORY_MOBILITY_MODELS,
1152 "create_function": create_element,
1153 "configure_function": configure_element,
1155 "connector_types": [],
1156 "box_attributes": ["X",
1159 "tags": [tags.MOBILE],
1161 "ns3::Ipv6ExtensionDestination": dict({
1163 "create_function": create_element,
1164 "configure_function": configure_element,
1166 "connector_types": [],
1167 "box_attributes": ["ExtensionNumber"],
1169 "ns3::LoopbackNetDevice": dict({
1170 "category": FC.CATEGORY_DEVICES,
1171 "create_function": create_element,
1172 "configure_function": configure_element,
1174 "connector_types": [],
1175 "box_attributes": [],
1176 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1178 "ns3::ConstantSpeedPropagationDelayModel": dict({
1179 "category": FC.CATEGORY_DELAY_MODELS,
1180 "create_function": create_element,
1181 "configure_function": configure_element,
1183 "connector_types": ["chan"],
1184 "box_attributes": ["Speed"],
1186 "ns3::Ipv6ExtensionHopByHop": dict({
1188 "create_function": create_element,
1189 "configure_function": configure_element,
1191 "connector_types": [],
1192 "box_attributes": ["ExtensionNumber"],
1194 "ns3::BridgeChannel": dict({
1195 "category": FC.CATEGORY_CHANNELS,
1196 "create_function": create_element,
1197 "configure_function": configure_element,
1199 "connector_types": [],
1200 "box_attributes": [],
1202 "ns3::Radvd": dict({
1204 "create_function": create_element,
1205 "configure_function": configure_element,
1207 "connector_types": [],
1208 "box_attributes": ["StartTime",
1211 "ns3::PacketSocket": dict({
1213 "create_function": create_element,
1214 "configure_function": configure_element,
1216 "connector_types": [],
1217 "box_attributes": ["RcvBufSize"],
1219 "ns3::flame::FlameProtocol": dict({
1220 "category": FC.CATEGORY_PROTOCOLS,
1221 "create_function": create_element,
1222 "configure_function": configure_element,
1224 "connector_types": [],
1225 "box_attributes": ["BroadcastInterval",
1228 "ns3::Cost231PropagationLossModel": dict({
1229 "category": FC.CATEGORY_LOSS_MODELS,
1230 "create_function": create_element,
1231 "configure_function": configure_element,
1233 "connector_types": [],
1234 "box_attributes": ["Lambda",
1240 "ns3::Ipv6ExtensionESP": dict({
1242 "create_function": create_element,
1243 "configure_function": configure_element,
1245 "connector_types": [],
1246 "box_attributes": ["ExtensionNumber"],
1248 "ns3::CaraWifiManager": dict({
1249 "category": FC.CATEGORY_MANAGERS,
1250 "create_function": create_element,
1251 "configure_function": configure_element,
1253 "connector_types": ["dev"],
1254 "box_attributes": ["ProbeThreshold",
1262 "FragmentationThreshold",
1266 "ns3::RttMeanDeviation": dict({
1268 "create_function": create_element,
1269 "configure_function": configure_element,
1271 "connector_types": [],
1272 "box_attributes": ["Gain",
1274 "InitialEstimation",
1277 "ns3::Icmpv4L4Protocol": dict({
1278 "category": FC.CATEGORY_PROTOCOLS,
1279 "create_function": create_element,
1280 "configure_function": configure_element,
1282 "connector_types": ["node"],
1283 "box_attributes": ["ProtocolNumber"],
1285 "ns3::WaveformGenerator": dict({
1287 "create_function": create_element,
1288 "configure_function": configure_element,
1290 "connector_types": [],
1291 "box_attributes": ["Period",
1294 "ns3::YansWifiChannel": dict({
1295 "category": FC.CATEGORY_CHANNELS,
1296 "create_function": create_element,
1297 "configure_function": configure_element,
1299 "connector_types": ["phys", "delay", "loss"],
1300 "box_attributes": [],
1302 "ns3::SimpleChannel": dict({
1303 "category": FC.CATEGORY_CHANNELS,
1304 "create_function": create_element,
1305 "configure_function": configure_element,
1307 "connector_types": ["devs"],
1308 "box_attributes": [],
1310 "ns3::Ipv6ExtensionFragment": dict({
1312 "create_function": create_element,
1313 "configure_function": configure_element,
1315 "connector_types": [],
1316 "box_attributes": ["ExtensionNumber"],
1318 "ns3::Dot11sStack": dict({
1320 "create_function": create_element,
1321 "configure_function": configure_element,
1323 "connector_types": [],
1324 "box_attributes": ["Root"],
1326 "ns3::FriisSpectrumPropagationLossModel": dict({
1327 "category": FC.CATEGORY_LOSS_MODELS,
1328 "create_function": create_element,
1329 "configure_function": configure_element,
1331 "connector_types": [],
1332 "box_attributes": [],
1334 "ns3::RandomRectanglePositionAllocator": dict({
1335 "category": FC.CATEGORY_MOBILITY_MODELS,
1336 "create_function": create_element,
1337 "configure_function": configure_element,
1339 "connector_types": [],
1340 "box_attributes": ["X",
1342 "tags": [tags.MOBILE],
1344 "ns3::NqapWifiMac": dict({
1345 "category": FC.CATEGORY_MAC_MODELS,
1346 "create_function": create_wifi_standard_model,
1347 "configure_function": configure_element,
1349 "connector_types": ["dev"],
1350 "box_attributes": ["BeaconInterval",
1354 "BasicBlockAckTimeout",
1355 "CompressedBlockAckTimeout",
1360 "MaxPropagationDelay",
1363 "ns3::HierarchicalMobilityModel": dict({
1364 "category": FC.CATEGORY_MOBILITY_MODELS,
1365 "create_function": create_element,
1366 "configure_function": configure_element,
1368 "connector_types": ["node"],
1369 "box_attributes": ["Position",
1371 "tags": [tags.MOBILE],
1373 "ns3::ThreeLogDistancePropagationLossModel": dict({
1374 "category": FC.CATEGORY_LOSS_MODELS,
1375 "create_function": create_element,
1376 "configure_function": configure_element,
1378 "connector_types": [],
1379 "box_attributes": ["Distance0",
1387 "ns3::UanNoiseModelDefault": dict({
1389 "create_function": create_element,
1390 "configure_function": configure_element,
1392 "connector_types": [],
1393 "box_attributes": ["Wind",
1396 "ns3::dot11s::HwmpRtable": dict({
1398 "create_function": create_element,
1399 "configure_function": configure_element,
1401 "connector_types": [],
1402 "box_attributes": [],
1404 "ns3::PacketBurst": dict({
1406 "create_function": create_element,
1407 "configure_function": configure_element,
1409 "connector_types": [],
1410 "box_attributes": [],
1412 "ns3::RandomPropagationDelayModel": dict({
1413 "category": FC.CATEGORY_DELAY_MODELS,
1414 "create_function": create_element,
1415 "configure_function": configure_element,
1417 "connector_types": [],
1418 "box_attributes": ["Variable"],
1420 "ns3::ArpL3Protocol": dict({
1421 "category": FC.CATEGORY_PROTOCOLS,
1422 "create_function": create_element,
1423 "configure_function": configure_element,
1425 "connector_types": ["node"],
1426 "box_attributes": [],
1428 "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1429 "category": FC.CATEGORY_MOBILITY_MODELS,
1430 "create_function": create_element,
1431 "configure_function": configure_element,
1433 "connector_types": [],
1434 "box_attributes": ["MinSpeed",
1444 "tags": [tags.MOBILE],
1446 "ns3::BaseStationNetDevice": dict({
1447 "category": FC.CATEGORY_DEVICES,
1448 "create_function": create_base_station,
1449 "configure_function": configure_station,
1450 "help": "Base station for wireless mobile network",
1451 "connector_types": ["node", "chan", "phy", "uplnk", "dwnlnk"],
1452 "box_attributes": ["InitialRangInterval",
1458 "MaxRangCorrectionRetries",
1462 "traces": ["wimaxpcap", "wimaxascii"],
1463 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1465 "ns3::UdpServer": dict({
1466 "category": FC.CATEGORY_APPLICATIONS,
1467 "create_function": create_element,
1468 "configure_function": configure_element,
1470 "connector_types": ["node"],
1471 "stop_function": stop_application,
1472 "start_function": start_application,
1473 "status_function": status_application,
1474 "box_attributes": ["Port",
1479 "ns3::AarfcdWifiManager": dict({
1480 "category": FC.CATEGORY_MANAGERS,
1481 "create_function": create_element,
1482 "configure_function": configure_element,
1484 "connector_types": ["dev"],
1485 "box_attributes": ["SuccessK",
1487 "MaxSuccessThreshold",
1488 "MinTimerThreshold",
1489 "MinSuccessThreshold",
1492 "TurnOffRtsAfterRateDecrease",
1493 "TurnOnRtsAfterRateIncrease",
1498 "FragmentationThreshold",
1501 "ns3::UanTransducerHd": dict({
1503 "create_function": create_element,
1504 "configure_function": configure_element,
1506 "connector_types": [],
1507 "box_attributes": [],
1509 "ns3::LogDistancePropagationLossModel": dict({
1510 "category": FC.CATEGORY_LOSS_MODELS,
1511 "create_function": create_element,
1512 "configure_function": configure_element,
1514 "connector_types": ["prev", "next"],
1515 "box_attributes": ["Exponent",
1516 "ReferenceDistance",
1519 "ns3::EmuNetDevice": dict({
1520 "category": FC.CATEGORY_DEVICES,
1521 "create_function": create_element,
1522 "configure_function": configure_element,
1524 "connector_types": ["node", "queue"],
1525 "box_attributes": ["Mtu",
1531 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1533 "ns3::Ipv6ExtensionLooseRouting": dict({
1534 "category": FC.CATEGORY_ROUTING,
1535 "create_function": create_element,
1536 "configure_function": configure_element,
1538 "connector_types": [],
1539 "box_attributes": ["ExtensionNumber"],
1541 "ns3::RandomWaypointMobilityModel": dict({
1542 "category": FC.CATEGORY_MOBILITY_MODELS,
1543 "create_function": create_element,
1544 "configure_function": configure_element,
1546 "connector_types": ["node"],
1547 "box_attributes": ["Speed",
1551 "tags": [tags.MOBILE],
1553 "ns3::RangePropagationLossModel": dict({
1554 "category": FC.CATEGORY_LOSS_MODELS,
1555 "create_function": create_element,
1556 "configure_function": configure_element,
1558 "connector_types": [],
1559 "box_attributes": ["MaxRange"],
1561 "ns3::AlohaNoackNetDevice": dict({
1562 "category": FC.CATEGORY_DEVICES,
1563 "create_function": create_element,
1564 "configure_function": configure_element,
1566 "connector_types": [],
1567 "box_attributes": ["Address",
1569 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1571 "ns3::MatrixPropagationLossModel": dict({
1572 "category": FC.CATEGORY_LOSS_MODELS,
1573 "create_function": create_element,
1574 "configure_function": configure_element,
1576 "connector_types": [],
1577 "box_attributes": ["DefaultLoss"],
1579 "ns3::WifiNetDevice": dict({
1580 "category": FC.CATEGORY_DEVICES,
1581 "create_function": create_element,
1582 "configure_function": configure_device,
1584 "connector_types": ["node", "mac", "phy", "manager"],
1585 "box_attributes": ["Mtu"],
1586 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1588 "ns3::CsmaChannel": dict({
1589 "category": FC.CATEGORY_CHANNELS,
1590 "create_function": create_element,
1591 "configure_function": configure_element,
1593 "connector_types": ["devs"],
1594 "box_attributes": ["DataRate",
1597 "ns3::BridgeNetDevice": dict({
1598 "category": FC.CATEGORY_DEVICES,
1599 "create_function": create_element,
1600 "configure_function": configure_element,
1602 "connector_types": ["node"],
1603 "box_attributes": ["Mtu",
1606 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1608 "ns3::Ipv6ExtensionRouting": dict({
1609 "category": FC.CATEGORY_ROUTING,
1610 "create_function": create_element,
1611 "configure_function": configure_element,
1613 "connector_types": [],
1614 "box_attributes": ["ExtensionNumber"],
1616 "ns3::QstaWifiMac": dict({
1617 "category": FC.CATEGORY_MAC_MODELS,
1618 "create_function": create_wifi_standard_model,
1619 "configure_function": configure_element,
1620 "help": "Station Wifi MAC Model",
1621 "connector_types": ["dev"],
1622 "box_attributes": ["ProbeRequestTimeout",
1623 "AssocRequestTimeout",
1627 "BasicBlockAckTimeout",
1628 "CompressedBlockAckTimeout",
1633 "MaxPropagationDelay",
1637 "ns3::UdpEchoClient": dict({
1638 "category": FC.CATEGORY_APPLICATIONS,
1639 "create_function": create_element,
1640 "configure_function": configure_element,
1642 "connector_types": ["node"],
1643 "stop_function": stop_application,
1644 "start_function": start_application,
1645 "status_function": status_application,
1646 "box_attributes": ["MaxPackets",
1653 "tags": [tags.APPLICATION],
1655 "ns3::UdpClient": dict({
1656 "category": FC.CATEGORY_APPLICATIONS,
1657 "create_function": create_element,
1658 "configure_function": configure_element,
1660 "connector_types": ["node"],
1661 "stop_function": stop_application,
1662 "start_function": start_application,
1663 "status_function": status_application,
1664 "box_attributes": ["MaxPackets",
1671 "tags": [tags.APPLICATION],
1673 "ns3::PointToPointChannel": dict({
1674 "category": FC.CATEGORY_CHANNELS,
1675 "create_function": create_element,
1676 "configure_function": configure_element,
1678 "connector_types": ["dev2"],
1679 "box_attributes": ["Delay"],
1681 "ns3::Ipv6StaticRouting": dict({
1682 "category": FC.CATEGORY_ROUTING,
1683 "create_function": create_element,
1684 "configure_function": configure_element,
1686 "connector_types": [],
1687 "box_attributes": [],
1689 "ns3::DropTailQueue": dict({
1690 "category": FC.CATEGORY_QUEUES,
1691 "create_function": create_element,
1692 "configure_function": configure_element,
1694 "connector_types": ["dev"],
1695 "box_attributes": ["MaxPackets",
1698 "ns3::ConstantPositionMobilityModel": dict({
1699 "category": FC.CATEGORY_MOBILITY_MODELS,
1700 "create_function": create_element,
1701 "configure_function": configure_element,
1703 "connector_types": ["node"],
1704 "box_attributes": ["Position",
1706 "tags": [tags.MOBILE],
1708 "ns3::FixedRssLossModel": dict({
1709 "category": FC.CATEGORY_LOSS_MODELS,
1710 "create_function": create_element,
1711 "configure_function": configure_element,
1713 "connector_types": [],
1714 "box_attributes": ["Rss"],
1716 "ns3::EnergySourceContainer": dict({
1717 "category": FC.CATEGORY_ENERGY_MODELS,
1718 "create_function": create_element,
1719 "configure_function": configure_element,
1721 "connector_types": [],
1722 "box_attributes": [],
1724 "ns3::RandomWalk2dMobilityModel": dict({
1725 "category": FC.CATEGORY_MOBILITY_MODELS,
1726 "create_function": create_element,
1727 "configure_function": configure_element,
1729 "connector_types": ["node"],
1730 "box_attributes": ["Bounds",
1738 "tags": [tags.MOBILE],
1740 "ns3::ListPositionAllocator": dict({
1742 "create_function": create_element,
1743 "configure_function": configure_element,
1745 "connector_types": [],
1746 "box_attributes": [],
1748 "ns3::dot11s::PeerManagementProtocol": dict({
1749 "category": FC.CATEGORY_PROTOCOLS,
1750 "create_function": create_element,
1751 "configure_function": configure_element,
1753 "connector_types": [],
1754 "box_attributes": ["MaxNumberOfPeerLinks",
1755 "MaxBeaconShiftValue",
1756 "EnableBeaconCollisionAvoidance"],
1758 "ns3::MeshPointDevice": dict({
1759 "category": FC.CATEGORY_DEVICES,
1760 "create_function": create_element,
1761 "configure_function": configure_element,
1763 "connector_types": [],
1764 "box_attributes": ["Mtu"],
1765 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1767 "ns3::BasicEnergySource": dict({
1768 "category": FC.CATEGORY_ENERGY_MODELS,
1769 "create_function": create_element,
1770 "configure_function": configure_element,
1772 "connector_types": [],
1773 "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1774 "BasicEnergySupplyVoltageV",
1775 "PeriodicEnergyUpdateInterval"],
1777 "ns3::Ipv6OptionPadn": dict({
1779 "create_function": create_element,
1780 "configure_function": configure_element,
1782 "connector_types": [],
1783 "box_attributes": ["OptionNumber"],
1785 "ns3::QapWifiMac": dict({
1786 "category": FC.CATEGORY_MAC_MODELS,
1787 "create_function": create_wifi_standard_model,
1788 "configure_function": configure_element,
1789 "help": "Access point Wifi MAC Model",
1790 "connector_types": ["dev"],
1791 "box_attributes": ["BeaconInterval",
1795 "BasicBlockAckTimeout",
1796 "CompressedBlockAckTimeout",
1801 "MaxPropagationDelay",
1805 "ns3::YansErrorRateModel": dict({
1806 "category": FC.CATEGORY_ERROR_MODELS,
1807 "create_function": create_element,
1808 "configure_function": configure_element,
1810 "connector_types": [],
1811 "box_attributes": [],
1813 "ns3::WifiMacQueue": dict({
1814 "category": FC.CATEGORY_QUEUES,
1815 "create_function": create_element,
1816 "configure_function": configure_element,
1818 "connector_types": [],
1819 "box_attributes": ["MaxPacketNumber",
1822 "ns3::NonCommunicatingNetDevice": dict({
1823 "category": FC.CATEGORY_DEVICES,
1824 "create_function": create_element,
1825 "configure_function": configure_element,
1827 "connector_types": [],
1828 "box_attributes": [],
1829 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1831 "ns3::RateErrorModel": dict({
1832 "category": FC.CATEGORY_ERROR_MODELS,
1833 "create_function": create_element,
1834 "configure_function": configure_element,
1836 "connector_types": [],
1837 "box_attributes": ["ErrorUnit",
1842 "ns3::MeshWifiInterfaceMac": dict({
1843 "category": FC.CATEGORY_MAC_MODELS,
1844 "create_function": create_element,
1845 "configure_function": configure_element,
1847 "connector_types": [],
1848 "box_attributes": ["BeaconInterval",
1853 "BasicBlockAckTimeout",
1854 "CompressedBlockAckTimeout",
1859 "MaxPropagationDelay",
1862 "ns3::UanPhyCalcSinrDual": dict({
1864 "create_function": create_element,
1865 "configure_function": configure_element,
1867 "connector_types": [],
1868 "box_attributes": [],
1870 "ns3::Ipv6ExtensionAH": dict({
1872 "create_function": create_element,
1873 "configure_function": configure_element,
1875 "connector_types": [],
1876 "box_attributes": ["ExtensionNumber"],
1878 "ns3::SingleModelSpectrumChannel": dict({
1879 "category": FC.CATEGORY_CHANNELS,
1880 "create_function": create_element,
1881 "configure_function": configure_element,
1883 "connector_types": [],
1884 "box_attributes": [],
1886 "ns3::YansWifiPhy": dict({
1887 "category": FC.CATEGORY_PHY_MODELS,
1888 "create_function": create_wifi_standard_model,
1889 "configure_function": configure_element,
1891 "connector_types": ["dev", "err", "chan"],
1892 "box_attributes": ["EnergyDetectionThreshold",
1893 "CcaMode1Threshold",
1900 "ChannelSwitchDelay",
1903 "traces": ["yanswifipcap"]
1905 "ns3::WifiRadioEnergyModel": dict({
1906 "category": FC.CATEGORY_ENERGY_MODELS,
1907 "create_function": create_element,
1908 "configure_function": configure_element,
1910 "connector_types": [],
1911 "box_attributes": ["TxCurrentA",
1916 "ns3::EdcaTxopN": dict({
1918 "create_function": create_element,
1919 "configure_function": configure_element,
1921 "connector_types": [],
1922 "box_attributes": ["BlockAckThreshold",
1927 "ns3::UanPhyPerGenDefault": dict({
1929 "create_function": create_element,
1930 "configure_function": configure_element,
1932 "connector_types": [],
1933 "box_attributes": ["Threshold"],
1935 "ns3::IdealWifiManager": dict({
1936 "category": FC.CATEGORY_MANAGERS,
1937 "create_function": create_element,
1938 "configure_function": configure_element,
1940 "connector_types": ["dev"],
1941 "box_attributes": ["BerThreshold",
1946 "FragmentationThreshold",
1949 "ns3::MultiModelSpectrumChannel": dict({
1950 "category": FC.CATEGORY_CHANNELS,
1951 "create_function": create_element,
1952 "configure_function": configure_element,
1954 "connector_types": [],
1955 "box_attributes": [],
1957 "ns3::HalfDuplexIdealPhy": dict({
1958 "category": FC.CATEGORY_PHY_MODELS,
1959 "create_function": create_element,
1960 "configure_function": configure_element,
1962 "connector_types": [],
1963 "box_attributes": ["Rate"],
1965 "ns3::UanPhyCalcSinrDefault": dict({
1966 "category": FC.CATEGORY_PHY_MODELS,
1967 "create_function": create_element,
1968 "configure_function": configure_element,
1970 "connector_types": [],
1971 "box_attributes": [],
1973 "ns3::ReceiveListErrorModel": dict({
1974 "category": FC.CATEGORY_ERROR_MODELS,
1975 "create_function": create_element,
1976 "configure_function": configure_element,
1978 "connector_types": [],
1979 "box_attributes": ["IsEnabled"],
1981 "ns3::SpectrumAnalyzer": dict({
1983 "create_function": create_element,
1984 "configure_function": configure_element,
1986 "connector_types": [],
1987 "box_attributes": ["Resolution",
1988 "NoisePowerSpectralDensity"],
1990 "ns3::ConstantRateWifiManager": dict({
1991 "category": FC.CATEGORY_MANAGERS,
1992 "create_function": create_element,
1993 "configure_function": configure_element,
1995 "connector_types": ["dev"],
1996 "box_attributes": ["DataMode",
2002 "FragmentationThreshold",
2005 "ns3::Ipv6OptionPad1": dict({
2007 "create_function": create_element,
2008 "configure_function": configure_element,
2010 "connector_types": [],
2011 "box_attributes": ["OptionNumber"],
2013 "ns3::UdpTraceClient": dict({
2015 "create_function": create_element,
2016 "configure_function": configure_element,
2018 "connector_types": [],
2019 "box_attributes": ["RemoteAddress",
2025 "ns3::RraaWifiManager": dict({
2026 "category": FC.CATEGORY_MANAGERS,
2027 "create_function": create_element,
2028 "configure_function": configure_element,
2030 "connector_types": ["dev"],
2031 "box_attributes": ["Basic",
2059 "FragmentationThreshold",
2062 "ns3::RandomPropagationLossModel": dict({
2063 "category": FC.CATEGORY_LOSS_MODELS,
2064 "create_function": create_element,
2065 "configure_function": configure_element,
2067 "connector_types": [],
2068 "box_attributes": ["Variable"],
2070 "ns3::UanChannel": dict({
2071 "category": FC.CATEGORY_CHANNELS,
2072 "create_function": create_element,
2073 "configure_function": configure_element,
2075 "connector_types": [],
2076 "box_attributes": [],
2078 "ns3::MinstrelWifiManager": dict({
2079 "category": FC.CATEGORY_MANAGERS,
2080 "create_function": create_element,
2081 "configure_function": configure_element,
2083 "connector_types": ["dev"],
2084 "box_attributes": ["UpdateStatistics",
2094 "FragmentationThreshold",
2097 "ns3::UanPhyDual": dict({
2098 "category": FC.CATEGORY_PHY_MODELS,
2099 "create_function": create_element,
2100 "configure_function": configure_element,
2102 "connector_types": [],
2103 "box_attributes": ["CcaThresholdPhy1",
2109 "SupportedModesPhy1",
2110 "SupportedModesPhy2"],
2112 "ns3::ListErrorModel": dict({
2113 "category": FC.CATEGORY_ERROR_MODELS,
2114 "create_function": create_element,
2115 "configure_function": configure_element,
2117 "connector_types": ["dev"],
2118 "box_attributes": ["IsEnabled"],
2120 "ns3::VirtualNetDevice": dict({
2121 "category": FC.CATEGORY_DEVICES,
2122 "create_function": create_element,
2123 "configure_function": configure_element,
2125 "connector_types": [],
2126 "box_attributes": ["Mtu"],
2127 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2129 "ns3::UanPhyGen": dict({
2130 "category": FC.CATEGORY_PHY_MODELS,
2131 "create_function": create_element,
2132 "configure_function": configure_element,
2134 "connector_types": [],
2135 "box_attributes": ["CcaThreshold",
2141 "ns3::Ipv6L3Protocol": dict({
2142 "category": FC.CATEGORY_PROTOCOLS,
2143 "create_function": create_element,
2144 "configure_function": configure_element,
2146 "connector_types": ["node"],
2147 "box_attributes": ["DefaultTtl",
2150 "ns3::PointToPointRemoteChannel": dict({
2151 "category": FC.CATEGORY_CHANNELS,
2152 "create_function": create_element,
2153 "configure_function": configure_element,
2155 "connector_types": [],
2156 "box_attributes": ["Delay"],
2158 "ns3::UanPhyPerUmodem": dict({
2159 "category": FC.CATEGORY_PHY_MODELS,
2160 "create_function": create_element,
2161 "configure_function": configure_element,
2163 "connector_types": [],
2164 "box_attributes": [],
2166 "ns3::OnoeWifiManager": dict({
2167 "category": FC.CATEGORY_MANAGERS,
2168 "create_function": create_element,
2169 "configure_function": configure_element,
2171 "connector_types": ["dev"],
2172 "box_attributes": ["UpdatePeriod",
2174 "AddCreditThreshold",
2179 "FragmentationThreshold",
2182 "ns3::QadhocWifiMac": dict({
2183 "category": FC.CATEGORY_MAC_MODELS,
2184 "create_function": create_element,
2185 "configure_function": configure_element,
2187 "connector_types": [],
2188 "box_attributes": ["CtsTimeout",
2190 "BasicBlockAckTimeout",
2191 "CompressedBlockAckTimeout",
2196 "MaxPropagationDelay",
2199 "ns3::JakesPropagationLossModel": dict({
2200 "category": FC.CATEGORY_LOSS_MODELS,
2201 "create_function": create_element,
2202 "configure_function": configure_element,
2204 "connector_types": [],
2205 "box_attributes": ["NumberOfRaysPerPath",
2206 "NumberOfOscillatorsPerRay",
2210 "ns3::PacketSink": dict({
2211 "category": FC.CATEGORY_APPLICATIONS,
2212 "create_function": create_element,
2213 "configure_function": configure_element,
2215 "connector_types": ["node"],
2216 "stop_function": stop_application,
2217 "start_function": start_application,
2218 "status_function": status_application,
2219 "box_attributes": ["Local",
2223 "tags": [tags.APPLICATION],
2225 "ns3::RandomDirection2dMobilityModel": dict({
2226 "category": FC.CATEGORY_MOBILITY_MODELS,
2227 "create_function": create_element,
2228 "configure_function": configure_element,
2230 "connector_types": ["node"],
2231 "box_attributes": ["Bounds",
2236 "tags": [tags.MOBILE],
2238 "ns3::UanMacAloha": dict({
2240 "create_function": create_element,
2241 "configure_function": configure_element,
2243 "connector_types": [],
2244 "box_attributes": [],
2246 "ns3::MsduStandardAggregator": dict({
2248 "create_function": create_element,
2249 "configure_function": configure_element,
2251 "connector_types": [],
2252 "box_attributes": ["MaxAmsduSize"],
2254 "ns3::DcaTxop": dict({
2256 "create_function": create_element,
2257 "configure_function": configure_element,
2259 "connector_types": [],
2260 "box_attributes": ["MinCw",
2264 "ns3::UanPhyCalcSinrFhFsk": dict({
2265 "category": FC.CATEGORY_PHY_MODELS,
2266 "create_function": create_element,
2267 "configure_function": configure_element,
2269 "connector_types": [],
2270 "box_attributes": ["NumberOfHops"],
2272 "ns3::UanPropModelIdeal": dict({
2274 "create_function": create_element,
2275 "configure_function": configure_element,
2277 "connector_types": [],
2278 "box_attributes": [],
2280 "ns3::UanMacRcGw": dict({
2282 "create_function": create_element,
2283 "configure_function": configure_element,
2285 "connector_types": [],
2286 "box_attributes": ["MaxReservations",
2294 "NumberOfRetryRates",
2299 "ns3::NistErrorRateModel": dict({
2300 "category": FC.CATEGORY_ERROR_MODELS,
2301 "create_function": create_element,
2302 "configure_function": configure_element,
2304 "connector_types": ["phy"],
2305 "box_attributes": [],
2307 "ns3::Ipv4L3Protocol": dict({
2308 "category": FC.CATEGORY_PROTOCOLS,
2309 "create_function": create_ipv4protocol,
2310 "configure_function": configure_element,
2312 "connector_types": ["node"],
2313 "box_attributes": ["DefaultTtl",
2317 "ns3::aodv::RoutingProtocol": dict({
2318 "category": FC.CATEGORY_PROTOCOLS,
2319 "create_function": create_element,
2320 "configure_function": configure_element,
2322 "connector_types": [],
2323 "box_attributes": ["HelloInterval",
2326 "NodeTraversalTime",
2328 "ActiveRouteTimeout",
2335 "PathDiscoveryTime",
2344 "ns3::TcpL4Protocol": dict({
2345 "category": FC.CATEGORY_PROTOCOLS,
2346 "create_function": create_element,
2347 "configure_function": configure_element,
2349 "connector_types": ["node"],
2350 "box_attributes": ["RttEstimatorFactory",
2353 "ns3::olsr::RoutingProtocol": dict({
2354 "category": FC.CATEGORY_PROTOCOLS,
2355 "create_function": create_element,
2356 "configure_function": configure_element,
2358 "connector_types": [],
2359 "box_attributes": ["HelloInterval",
2365 "ns3::UdpEchoServer": dict({
2366 "category": FC.CATEGORY_APPLICATIONS,
2367 "create_function": create_element,
2368 "configure_function": configure_element,
2370 "connector_types": ["node"],
2371 "stop_function": stop_application,
2372 "start_function": start_application,
2373 "status_function": status_application,
2374 "box_attributes": ["Port",
2377 "tags": [tags.APPLICATION],
2379 "ns3::AmrrWifiManager": dict({
2380 "category": FC.CATEGORY_MANAGERS,
2381 "create_function": create_element,
2382 "configure_function": configure_element,
2384 "connector_types": ["dev"],
2385 "box_attributes": ["UpdatePeriod",
2388 "MaxSuccessThreshold",
2389 "MinSuccessThreshold",
2394 "FragmentationThreshold",
2397 "ns3::ArfWifiManager": dict({
2398 "category": FC.CATEGORY_MANAGERS,
2399 "create_function": create_element,
2400 "configure_function": configure_element,
2402 "connector_types": ["dev"],
2403 "box_attributes": ["TimerThreshold",
2409 "FragmentationThreshold",
2412 "ns3::SubscriberStationNetDevice": dict({
2413 "category": FC.CATEGORY_DEVICES,
2414 "create_function": create_subscriber_station,
2415 "configure_function": configure_station,
2416 "help": "Subscriber station for mobile wireless network",
2417 "connector_types": ["node", "chan", "phy", "sflows"],
2418 "box_attributes": ["LostDlMapInterval",
2419 "LostUlMapInterval",
2429 "MaxContentionRangingRetries",
2433 "traces": ["wimaxpcap", "wimaxascii"],
2434 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2436 "ns3::flame::FlameRtable": dict({
2438 "create_function": create_element,
2439 "configure_function": configure_element,
2441 "connector_types": [],
2442 "box_attributes": ["Lifetime"],
2444 "ns3::BSSchedulerRtps": dict({
2445 "category": FC.CATEGORY_SERVICE_FLOWS,
2446 "create_function": create_element,
2447 "configure_function": configure_element,
2448 "help": "Simple downlink scheduler for rtPS flows",
2449 "connector_types": ["dev"],
2450 "box_attributes": [],
2452 "ns3::BSSchedulerSimple": dict({
2453 "category": FC.CATEGORY_SERVICE_FLOWS,
2454 "create_function": create_element,
2455 "configure_function": configure_element,
2456 "help": "simple downlink scheduler for service flows",
2457 "connector_types": ["dev"],
2458 "box_attributes": [],
2460 "ns3::SimpleOfdmWimaxChannel": dict({
2461 "category": FC.CATEGORY_CHANNELS,
2462 "create_function": create_wimax_channel,
2463 "configure_function": configure_element,
2464 "help": "Wimax channel",
2465 "connector_types": ["devs"],
2466 "box_attributes": [],
2468 "ns3::SimpleOfdmWimaxPhy": dict({
2469 "category": FC.CATEGORY_PHY_MODELS,
2470 "create_function": create_wimax_phy,
2471 "configure_function": configure_element,
2472 "help": "Wimax Phy",
2473 "connector_types": ["dev"],
2474 "box_attributes": [],
2476 "ns3::UplinkSchedulerSimple": dict({
2477 "category": FC.CATEGORY_SERVICE_FLOWS,
2478 "create_function": create_element_no_constructor,
2479 "configure_function": configure_element,
2480 "help": "Simple uplink scheduler for service flows",
2481 "connector_types": ["dev"],
2482 "box_attributes": [],
2484 "ns3::UplinkSchedulerRtps": dict({
2485 "category": FC.CATEGORY_SERVICE_FLOWS,
2486 "create_function": create_element_no_constructor,
2487 "configure_function": configure_element,
2488 "help": "Simple uplink scheduler for rtPS flows",
2489 "connector_types": ["dev"],
2490 "box_attributes": [],
2492 "ns3::IpcsClassifierRecord": dict({
2493 "category": FC.CATEGORY_SERVICE_FLOWS,
2494 "create_function": create_ipcs_classifier_record,
2495 "configure_function": configure_element,
2496 "help": "Classifier record for service flow",
2497 "connector_types": ["sflow"],
2498 "box_attributes": ["ClassifierSrcAddress",
2499 "ClassifierSrcMask",
2500 "ClassifierDstAddress",
2501 "ClassifierDstMask",
2502 "ClassifierSrcPortLow",
2503 "ClassifierSrcPortHigh",
2504 "ClassifierDstPortLow",
2505 "ClassifierDstPortHigh",
2506 "ClassifierProtocol",
2507 "ClassifierPriority"],
2509 "ns3::ServiceFlow": dict({
2510 "category": FC.CATEGORY_SERVICE_FLOWS,
2511 "create_function": create_service_flow,
2512 "configure_function": configure_element,
2513 "help": "Service flow for QoS",
2514 "connector_types": ["classif", "dev"],
2515 "box_attributes": ["ServiceFlowDirection",
2516 "ServiceFlowSchedulingType"],