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. Can't add Ipv4 addresses" % node_guid)
60 def _get_node_guid(testbed_instance, guid):
61 # search for the node asociated with the device
62 node_guids = testbed_instance.get_connected(guid, "node", "devs")
63 if len(node_guids) == 0:
64 raise RuntimeError("Can't instantiate interface %d outside node" % guid)
65 node_guid = node_guids[0]
68 def _get_dev_number(testbed_instance, guid):
69 node_guid = _get_node_guid(testbed_instance, guid)
70 dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
72 for guid_ in dev_guids:
76 return interface_number
78 def _follow_trace(testbed_instance, guid, trace_id, filename):
79 testbed_instance.follow_trace(guid, trace_id, filename)
80 filepath = testbed_instance.trace_filepath(guid, trace_id)
83 ### create traces functions ###
85 def p2pascii_trace(testbed_instance, guid, trace_id):
86 node_guid = _get_node_guid(testbed_instance, guid)
87 interface_number = _get_dev_number(testbed_instance, guid)
88 element = testbed_instance._elements[guid]
89 filename = "trace-p2p-node-%d-dev-%d.tr" % (node_guid, interface_number)
90 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
91 helper = testbed_instance.ns3.PointToPointHelper()
92 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
93 stream = asciiHelper.CreateFileStream(filepath)
94 helper.EnableAscii(stream, element)
96 def p2ppcap_trace(testbed_instance, guid, trace_id):
97 node_guid = _get_node_guid(testbed_instance, guid)
98 interface_number = _get_dev_number(testbed_instance, guid)
99 element = testbed_instance._elements[guid]
100 filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_guid, interface_number)
101 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
102 helper = testbed_instance.ns3.PointToPointHelper()
103 helper.EnablePcap(filepath, element, explicitFilename = True)
105 def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
106 node_guid = _get_node_guid(testbed_instance, guid)
107 interface_number = _get_dev_number(testbed_instance, guid)
108 element = testbed_instance._elements[guid]
109 filename = "trace-csma-node-%d-dev-%d.pcap" % (node_guid, interface_number)
110 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
111 helper = testbed_instance.ns3.CsmaHelper()
112 helper.EnablePcap(filepath, element, promiscuous = promisc,
113 explicitFilename = True)
115 def csmapcap_trace(testbed_instance, guid, trace_id):
117 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
119 def csmapcap_promisc_trace(testbed_instance, guid, trace_id):
121 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
123 def fdpcap_trace(testbed_instance, guid, trace_id):
124 node_guid = _get_node_guid(testbed_instance, guid)
125 interface_number = _get_dev_number(testbed_instance, guid)
126 element = testbed_instance._elements[guid]
127 filename = "trace-fd-node-%d-dev-%d.pcap" % (node_guid, interface_number)
128 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
129 helper = testbed_instance.ns3.FileDescriptorHelper()
130 helper.EnablePcap(filepath, element, explicitFilename = True)
132 def yanswifipcap_trace(testbed_instance, guid, trace_id):
133 dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
134 node_guid = _get_node_guid(testbed_instance, dev_guid)
135 interface_number = _get_dev_number(testbed_instance, dev_guid)
136 element = testbed_instance._elements[dev_guid]
137 filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
138 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
139 helper = testbed_instance.ns3.YansWifiPhyHelper()
140 helper.EnablePcap(filepath, element, explicitFilename = True)
142 def wimaxascii_trace(testbed_instance, guid, trace_id):
143 node_guid = _get_node_guid(testbed_instance, guid)
144 interface_number = _get_dev_number(testbed_instance, guid)
145 element = testbed_instance._elements[guid]
146 filename = "trace-wimax-node-%d-dev-%d.tr" % (node_guid, interface_number)
147 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
148 helper = testbed_instance.ns3.WimaxHelper()
149 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
150 stream = asciiHelper.CreateFileStream (filepath)
151 helper.EnableAscii(stream, element)
152 #helper.EnableLogComponents()
154 def wimaxpcap_trace(testbed_instance, guid, trace_id):
155 node_guid = _get_node_guid(testbed_instance, guid)
156 interface_number = _get_dev_number(testbed_instance, guid)
157 element = testbed_instance._elements[guid]
158 filename = "trace-wimax-node-%d-dev-%d.pcap" % (node_guid, interface_number)
159 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
160 helper = testbed_instance.ns3.WimaxHelper()
161 helper.EnablePcap(filepath, element, explicitFilename = True)
163 def rtt_trace(testbed_instance, guid, trace_id):
164 element = testbed_instance._elements[guid]
165 helper = testbed_instance.ns3.ScalarTraceHelper()
166 prefix = "trace-app-%d" % (guid, )
167 filename = helper.GetFilenameFromSource(prefix, element, trace_id)
168 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
169 prefix = filepath[:filepath.find(prefix)+len(prefix)]
170 helper.EnableTrace(element, trace_id, prefix, "T")
172 trace_functions = dict({
173 "P2PPcapTrace": p2ppcap_trace,
174 "P2PAsciiTrace": p2pascii_trace,
175 "CsmaPcapTrace": csmapcap_trace,
176 "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
177 "FileDescriptorPcapTrace": fdpcap_trace,
178 "YansWifiPhyPcapTrace": yanswifipcap_trace,
179 "WimaxPcapTrace": wimaxpcap_trace,
180 "WimaxAsciiTrace": wimaxascii_trace,
184 ### Creation functions ###
186 def create_element(testbed_instance, guid):
187 element_factory = testbed_instance.ns3.ObjectFactory()
188 factory_id = testbed_instance._create[guid]
189 element_factory.SetTypeId(factory_id)
190 construct_parameters = testbed_instance._get_construct_parameters(guid)
191 for name, value in construct_parameters.iteritems():
192 ns3_value = testbed_instance._to_ns3_value(guid, name, value)
193 element_factory.Set(name, ns3_value)
194 element = element_factory.Create()
195 testbed_instance._elements[guid] = element
197 def create_node(testbed_instance, guid):
198 create_element(testbed_instance, guid)
199 element = testbed_instance._elements[guid]
200 element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
202 def create_wifi_standard_model(testbed_instance, guid):
203 create_element(testbed_instance, guid)
204 element = testbed_instance._elements[guid]
205 parameters = testbed_instance._get_parameters(guid)
206 standard = parameters.get("Standard")
208 raise RuntimeError("No wifi standard set for %d" % guid)
209 element.ConfigureStandard(wifi_standards[standard])
211 def create_waypoint_mobility(testbed_instance, guid):
212 create_element(testbed_instance, guid)
213 element = testbed_instance._elements[guid]
214 parameters = testbed_instance._get_parameters(guid)
215 ns3 = testbed_instance.ns3
216 waypoints = parameters.get("WaypointList", "")
217 waypoints = re.sub(" |\(|\)", "", waypoints)
218 for swp in waypoints.split(","):
222 pos = ns3.Vector(float(dwp[1]), float(dwp[2]), float(dwp[3]))
223 waypoint = ns3.Waypoint(time, pos)
224 element.AddWaypoint(waypoint)
226 def create_ipv4protocol(testbed_instance, guid):
227 create_element(testbed_instance, guid)
228 element = testbed_instance._elements[guid]
229 list_routing = testbed_instance.ns3.Ipv4ListRouting()
230 element.SetRoutingProtocol(list_routing)
231 static_routing = testbed_instance.ns3.Ipv4StaticRouting()
232 list_routing.AddRoutingProtocol(static_routing, 1)
234 def create_element_no_constructor(testbed_instance, guid):
235 """ Create function for ns3 classes for which
236 TypeId.HasConstructor == False"""
237 factory_id = testbed_instance._create[guid]
238 factory_name = factory_id.replace("ns3::", "")
239 constructor = getattr(testbed_instance.ns3, factory_name)
240 element = constructor()
241 testbed_instance._elements[guid] = element
243 def create_base_station(testbed_instance, guid):
244 node_guid = _get_node_guid(testbed_instance, guid)
245 node = testbed_instance._elements[node_guid]
246 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
247 if len(phy_guids) == 0:
248 raise RuntimeError("No PHY was found for station %d" % guid)
249 phy = testbed_instance._elements[phy_guids[0]]
250 uplnk_guids = testbed_instance.get_connected(guid, "uplnk", "dev")
251 if len(uplnk_guids) == 0:
252 raise RuntimeError("No uplink scheduler was found for station %d" % guid)
253 uplnk = testbed_instance._elements[uplnk_guids[0]]
254 dwnlnk_guids = testbed_instance.get_connected(guid, "dwnlnk", "dev")
255 if len(dwnlnk_guids) == 0:
256 raise RuntimeError("No downlink scheduler was found for station %d" % guid)
257 dwnlnk = testbed_instance._elements[dwnlnk_guids[0]]
258 element = testbed_instance.ns3.BaseStationNetDevice(node, phy, uplnk, dwnlnk)
259 testbed_instance._elements[guid] = element
261 def create_subscriber_station(testbed_instance, guid):
262 node_guid = _get_node_guid(testbed_instance, guid)
263 node = testbed_instance._elements[node_guid]
264 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
265 if len(phy_guids) == 0:
266 raise RuntimeError("No PHY was found for station %d" % guid)
267 phy = testbed_instance._elements[phy_guids[0]]
268 element = testbed_instance.ns3.SubscriberStationNetDevice(node, phy)
269 element.SetModulationType(testbed_instance.ns3.WimaxPhy.MODULATION_TYPE_QAM16_12)
270 testbed_instance._elements[guid] = element
272 def create_wimax_channel(testbed_instance, guid):
273 element = testbed_instance.ns3.SimpleOfdmWimaxChannel(testbed_instance.ns3.SimpleOfdmWimaxChannel.COST231_PROPAGATION)
274 testbed_instance._elements[guid] = element
276 def create_wimax_phy(testbed_instance, guid):
277 element = testbed_instance.ns3.SimpleOfdmWimaxPhy()
278 testbed_instance._elements[guid] = element
280 def create_service_flow(testbed_instance, guid):
281 parameters = testbed_instance._get_parameters(guid)
282 direction = parameters.get("Direction")
283 if direction == None:
284 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
285 sched = parameters.get("SchedulingType")
287 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
288 ServiceFlow = testbed_instance.ns3.ServiceFlow
289 direction = service_flow_direction[direction]
290 sched = service_flow_scheduling_type[sched]
291 element = ServiceFlow(direction)
292 element.SetCsSpecification(ServiceFlow.IPV4)
293 element.SetServiceSchedulingType(sched)
294 element.SetMaxSustainedTrafficRate(100)
295 element.SetMinReservedTrafficRate(1000000)
296 element.SetMinTolerableTrafficRate(1000000)
297 element.SetMaximumLatency(100)
298 element.SetMaxTrafficBurst(2000)
299 element.SetTrafficPriority(1)
300 element.SetUnsolicitedGrantInterval(1)
301 element.SetMaxSustainedTrafficRate(70)
302 element.SetToleratedJitter(10)
303 element.SetSduSize(49)
304 element.SetRequestTransmissionPolicy(0)
305 testbed_instance._elements[guid] = element
307 def create_ipcs_classifier_record(testbed_instance, guid):
308 parameters = testbed_instance._get_parameters(guid)
309 src_address = parameters.get("SrcAddress")
310 if src_address == None:
311 raise RuntimeError("No SrcAddress was found for classifier %d" % guid)
312 src_address = testbed_instance.ns3.Ipv4Address(src_address)
313 src_mask = parameters.get("SrcMask")
315 raise RuntimeError("No SrcMask was found for classifier %d" % guid)
316 src_mask = testbed_instance.ns3.Ipv4Mask(src_mask)
317 dst_address = parameters.get("DstAddress")
318 if dst_address == None:
319 raise RuntimeError("No Dstddress was found for classifier %d" % guid)
320 dst_address = testbed_instance.ns3.Ipv4Address(dst_address)
321 dst_mask = parameters.get("DstMask")
323 raise RuntimeError("No DstMask was found for classifier %d" % guid)
324 dst_mask = testbed_instance.ns3.Ipv4Mask(dst_mask)
325 src_port_low = parameters.get("SrcPortLow")
326 if src_port_low == None:
327 raise RuntimeError("No SrcPortLow was found for classifier %d" % guid)
328 src_port_high = parameters.get("SrcPortHigh")
329 if src_port_high == None:
330 raise RuntimeError("No SrcPortHigh was found for classifier %d" % guid)
331 dst_port_low = parameters.get("DstPortLow")
332 if dst_port_low == None:
333 raise RuntimeError("No DstPortLow was found for classifier %d" % guid)
334 dst_port_high = parameters.get("DstPortHigh")
335 if dst_port_high == None:
336 raise RuntimeError("No DstPortHigh was found for classifier %d" % guid)
337 protocol = parameters.get("Protocol")
338 if protocol == None or protocol not in l4_protocols:
339 raise RuntimeError("No Protocol was found for classifier %d" % guid)
340 priority = parameters.get("Priority")
342 raise RuntimeError("No Priority was found for classifier %d" % guid)
343 element = testbed_instance.ns3.IpcsClassifierRecord(src_address, src_mask,
344 dst_address, dst_mask, src_port_low, src_port_high, dst_port_low,
345 dst_port_high, l4_protocols[protocol], priority)
346 testbed_instance._elements[guid] = element
348 ### Start/Stop functions ###
350 def start_application(testbed_instance, guid):
351 element = testbed_instance.elements[guid]
352 # BUG: without doing this explicit call it doesn't start!!!
353 # Shouldn't be enough to set the StartTime?
356 def stop_application(testbed_instance, guid):
357 element = testbed_instance.elements[guid]
358 now = testbed_instance.ns3.Simulator.Now()
359 element.SetStopTime(now)
361 ### Status functions ###
363 def status_application(testbed_instance, guid):
364 if guid not in testbed_instance.elements.keys():
365 raise RuntimeError("Can't get status on guid %d" % guid )
366 now = testbed_instance.ns3.Simulator.Now()
368 return AS.STATUS_NOT_STARTED
369 app = testbed_instance.elements[guid]
370 parameters = testbed_instance._get_parameters(guid)
371 start_value = parameters.get("StartTime")
372 if start_value != None:
373 start_time = testbed_instance.ns3.Time(start_value)
374 if now.Compare(start_time) < 0:
375 return AS.STATUS_NOT_STARTED
376 stop_value = parameters.get("StopTime")
377 if stop_value != None:
378 stop_time = testbed_instance.ns3.Time(stop_value)
379 if now.Compare(stop_time) < 0:
380 return AS.STATUS_RUNNING
382 return AS.STATUS_FINISHED
383 return AS.STATUS_UNDETERMINED
385 ### Configure functions ###
387 def configure_traces(testbed_instance, guid):
388 traces = testbed_instance._get_traces(guid)
389 for trace_id in traces:
390 trace_func = trace_functions[trace_id]
391 trace_func(testbed_instance, guid, trace_id)
393 def configure_element(testbed_instance, guid):
394 configure_traces(testbed_instance, guid)
396 def configure_device(testbed_instance, guid):
397 configure_traces(testbed_instance, guid)
399 element = testbed_instance._elements[guid]
401 parameters = testbed_instance._get_parameters(guid)
402 address = parameters.get("macAddress")
404 macaddr = testbed_instance.ns3.Mac48Address(address)
406 macaddr = testbed_instance.ns3.Mac48Address.Allocate()
407 element.SetAddress(macaddr)
409 if not guid in testbed_instance._add_address:
411 # search for the node asociated with the device
412 node_guid = _get_node_guid(testbed_instance, guid)
413 node = testbed_instance.elements[node_guid]
414 # search for the Ipv4L3Protocol asociated with the device
415 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
416 ipv4 = testbed_instance._elements[ipv4_guid]
417 ns3 = testbed_instance.ns3
419 addresses = testbed_instance._add_address[guid]
420 for address in addresses:
421 (address, netprefix, broadcast) = address
422 # TODO: missing IPV6 addresses!!
423 ifindex = ipv4.AddInterface(element)
424 inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
425 ns3.Ipv4Mask("/%d" % netprefix))
426 ipv4.AddAddress(ifindex, inaddr)
427 ipv4.SetMetric(ifindex, 1)
430 def _add_static_route(ns3, static_routing,
431 address, netprefix, nexthop_address, ifindex):
433 # Default route: 0.0.0.0/0
434 static_routing.SetDefaultRoute(nexthop_address, ifindex)
435 elif netprefix == 32:
436 # Host route: x.y.z.w/32
437 static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
439 # Network route: x.y.z.w/n
440 mask = ns3.Ipv4Mask("/%d" % netprefix)
441 static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
444 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
446 # Default route: 0.0.0.0/0
447 static_routing.SetDefaultRoute(ifindex)
448 elif netprefix == 32:
449 # Host route: x.y.z.w/32
450 static_routing.AddHostRouteTo(address, ifindex)
452 # Network route: x.y.z.w/n
453 mask = ns3.Ipv4Mask("/%d" % netprefix)
454 static_routing.AddNetworkRouteTo(address, mask, ifindex)
456 def configure_node(testbed_instance, guid):
457 configure_traces(testbed_instance, guid)
459 element = testbed_instance._elements[guid]
460 if not guid in testbed_instance._add_route:
462 # search for the Ipv4L3Protocol asociated with the device
463 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
464 ipv4 = testbed_instance._elements[ipv4_guid]
465 list_routing = ipv4.GetRoutingProtocol()
466 (static_routing, priority) = list_routing.GetRoutingProtocol(0)
467 ns3 = testbed_instance.ns3
468 routes = testbed_instance._add_route[guid]
470 (destination, netprefix, nexthop, metric) = route
471 address = ns3.Ipv4Address(destination)
473 nexthop_address = ns3.Ipv4Address(nexthop)
475 # TODO: HACKISH way of getting the ifindex... improve this
476 nifaces = ipv4.GetNInterfaces()
477 for ifidx in xrange(nifaces):
478 iface = ipv4.GetInterface(ifidx)
479 naddress = iface.GetNAddresses()
480 for addridx in xrange(naddress):
481 ifaddr = iface.GetAddress(addridx)
482 ifmask = ifaddr.GetMask()
483 ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
487 # Check previous ptp routes
488 for chaindest, chainprefix, chainhop in routes:
489 if chaindest == nexthop and chainprefix == 32:
490 chainhop_address = ns3.Ipv4Address(chainhop)
491 for ifidx in xrange(nifaces):
492 iface = ipv4.GetInterface(ifidx)
493 naddress = iface.GetNAddresses()
494 for addridx in xrange(naddress):
495 ifaddr = iface.GetAddress(addridx)
496 ifmask = ifaddr.GetMask()
497 ifindex = ipv4.GetInterfaceForPrefix(chainhop_address, ifmask)
501 raise RuntimeError, "Cannot associate interface for routing entry:" \
502 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
503 _add_static_route(ns3, static_routing,
504 address, netprefix, nexthop_address, ifindex)
506 mask = ns3.Ipv4Mask("/%d" % netprefix)
507 ifindex = ipv4.GetInterfaceForPrefix(address, mask)
509 raise RuntimeError, "Cannot associate interface for routing entry:" \
510 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
511 _add_static_route_if(ns3, static_routing,
512 address, netprefix, nexthop_address, ifindex)
514 def configure_station(testbed_instance, guid):
515 configure_device(testbed_instance, guid)
516 element = testbed_instance._elements[guid]
521 factories_order = ["ns3::BasicEnergySource",
522 "ns3::WifiRadioEnergyModel",
523 "ns3::BSSchedulerRtps",
524 "ns3::BSSchedulerSimple",
525 "ns3::UdpTraceClient",
531 "ns3::flame::FlameProtocol",
532 "ns3::flame::FlameRtable",
533 "ns3::dot11s::AirtimeLinkMetricCalculator",
534 "ns3::dot11s::HwmpProtocol",
535 "ns3::dot11s::HwmpRtable",
536 "ns3::dot11s::PeerManagementProtocol",
537 "ns3::dot11s::PeerLink",
538 "ns3::MeshWifiInterfaceMac",
539 "ns3::MeshPointDevice",
542 "ns3::UanPhyCalcSinrDual",
543 "ns3::UanPhyPerGenDefault",
545 "ns3::UanPropModelThorp",
547 "ns3::UanNoiseModelDefault",
549 "ns3::UanPropModelIdeal",
550 "ns3::UanTransducerHd",
551 "ns3::UanPhyCalcSinrDefault",
553 "ns3::UanPhyCalcSinrFhFsk",
554 "ns3::UanPhyPerUmodem",
557 "ns3::AthstatsWifiTraceSink",
560 "ns3::NonCommunicatingNetDevice",
561 "ns3::HalfDuplexIdealPhy",
562 "ns3::AlohaNoackNetDevice",
563 "ns3::SpectrumAnalyzer",
564 "ns3::WaveformGenerator",
565 "ns3::MultiModelSpectrumChannel",
566 "ns3::SingleModelSpectrumChannel",
567 "ns3::MsduStandardAggregator",
571 "ns3::QadhocWifiMac",
572 "ns3::MinstrelWifiManager",
573 "ns3::CaraWifiManager",
574 "ns3::AarfcdWifiManager",
575 "ns3::OnoeWifiManager",
576 "ns3::AmrrWifiManager",
577 "ns3::ConstantRateWifiManager",
578 "ns3::IdealWifiManager",
579 "ns3::AarfWifiManager",
580 "ns3::ArfWifiManager",
581 "ns3::WifiNetDevice",
587 "ns3::YansWifiChannel",
589 "ns3::NistErrorRateModel",
590 "ns3::YansErrorRateModel",
591 "ns3::WaypointMobilityModel",
592 "ns3::ConstantAccelerationMobilityModel",
593 "ns3::RandomDirection2dMobilityModel",
594 "ns3::RandomWalk2dMobilityModel",
595 "ns3::SteadyStateRandomWaypointMobilityModel",
596 "ns3::RandomWaypointMobilityModel",
597 "ns3::GaussMarkovMobilityModel",
598 "ns3::ConstantVelocityMobilityModel",
599 "ns3::ConstantPositionMobilityModel",
600 "ns3::ListPositionAllocator",
601 "ns3::GridPositionAllocator",
602 "ns3::RandomRectanglePositionAllocator",
603 "ns3::RandomBoxPositionAllocator",
604 "ns3::RandomDiscPositionAllocator",
605 "ns3::UniformDiscPositionAllocator",
606 "ns3::HierarchicalMobilityModel",
607 "ns3::aodv::RoutingProtocol",
608 "ns3::UdpEchoServer",
609 "ns3::UdpEchoClient",
611 "ns3::OnOffApplication",
612 "ns3::VirtualNetDevice",
613 "ns3::FileDescriptorNetDevice",
614 "ns3::Nepi::TunChannel",
616 "ns3::BridgeChannel",
617 "ns3::BridgeNetDevice",
620 "ns3::CsmaNetDevice",
621 "ns3::PointToPointRemoteChannel",
622 "ns3::PointToPointChannel",
623 "ns3::PointToPointNetDevice",
624 "ns3::NscTcpL4Protocol",
625 "ns3::Icmpv6L4Protocol",
626 "ns3::Ipv6OptionPad1",
627 "ns3::Ipv6OptionPadn",
628 "ns3::Ipv6OptionJumbogram",
629 "ns3::Ipv6OptionRouterAlert",
630 "ns3::Ipv6ExtensionHopByHop",
631 "ns3::Ipv6ExtensionDestination",
632 "ns3::Ipv6ExtensionFragment",
633 "ns3::Ipv6ExtensionRouting",
634 "ns3::Ipv6ExtensionLooseRouting",
635 "ns3::Ipv6ExtensionESP",
636 "ns3::Ipv6ExtensionAH",
637 "ns3::Ipv6L3Protocol",
638 "ns3::LoopbackNetDevice",
639 "ns3::Icmpv4L4Protocol",
640 "ns3::RttMeanDeviation",
641 "ns3::ArpL3Protocol",
642 "ns3::TcpL4Protocol",
643 "ns3::UdpL4Protocol",
644 "ns3::Ipv4L3Protocol",
645 "ns3::SimpleNetDevice",
646 "ns3::SimpleChannel",
648 "ns3::DropTailQueue",
650 "ns3::FriisSpectrumPropagationLossModel",
651 "ns3::Cost231PropagationLossModel",
652 "ns3::JakesPropagationLossModel",
653 "ns3::RandomPropagationLossModel",
654 "ns3::FriisPropagationLossModel",
655 "ns3::TwoRayGroundPropagationLossModel",
656 "ns3::LogDistancePropagationLossModel",
657 "ns3::ThreeLogDistancePropagationLossModel",
658 "ns3::NakagamiPropagationLossModel",
659 "ns3::FixedRssLossModel",
660 "ns3::MatrixPropagationLossModel",
661 "ns3::RangePropagationLossModel",
662 "ns3::RandomPropagationDelayModel",
663 "ns3::ConstantSpeedPropagationDelayModel",
664 "ns3::RateErrorModel",
665 "ns3::ListErrorModel",
666 "ns3::ReceiveListErrorModel",
668 "ns3::EnergySourceContainer",
669 "ns3::BSSchedulerRtps",
670 "ns3::BSSchedulerSimple",
671 "ns3::SimpleOfdmWimaxChannel",
672 "ns3::SimpleOfdmWimaxPhy",
673 "ns3::UplinkSchedulerMBQoS",
674 "ns3::UplinkSchedulerRtps",
675 "ns3::UplinkSchedulerSimple",
676 "ns3::IpcsClassifierRecord",
678 "ns3::BaseStationNetDevice",
679 "ns3::SubscriberStationNetDevice",
682 factories_info = dict({
684 "category": FC.CATEGORY_APPLICATIONS,
685 "create_function": create_element,
686 "configure_function": configure_element,
687 "stop_function": stop_application,
688 "start_function": start_application,
689 "status_function": status_application,
691 "connector_types": [],
692 "box_attributes": ["MaxPackets",
699 "tags": [tags.APPLICATION],
701 "ns3::UdpL4Protocol": dict({
702 "category": FC.CATEGORY_PROTOCOLS,
703 "create_function": create_element,
704 "configure_function": configure_element,
706 "connector_types": ["node"],
707 "box_attributes": ["ProtocolNumber"],
708 "tags": [tags.PROTOCOL],
710 "ns3::RandomDiscPositionAllocator": dict({
711 "category": FC.CATEGORY_MOBILITY_MODELS,
712 "create_function": create_element,
713 "configure_function": configure_element,
715 "connector_types": [],
716 "box_attributes": ["Theta",
720 "tags": [tags.MOBILE],
723 "category": FC.CATEGORY_NODES,
724 "create_function": create_node,
725 "configure_function": configure_node,
727 "connector_types": ["devs", "apps", "protos", "mobility"],
728 "tags": [tags.NODE, tags.ALLOW_ROUTES],
730 "ns3::GridPositionAllocator": dict({
731 "category": FC.CATEGORY_MOBILITY_MODELS,
732 "create_function": create_element,
733 "configure_function": configure_element,
735 "connector_types": [],
736 "box_attributes": ["GridWidth",
743 "ns3::TapBridge": dict({
744 "category": FC.CATEGORY_DEVICES,
745 "create_function": create_element,
746 "configure_function": configure_element,
748 "connector_types": [],
749 "box_attributes": ["Mtu",
757 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
759 "ns3::FlowMonitor": dict({
760 "category": FC.CATEGORY_SERVICE_FLOWS,
761 "create_function": create_element,
762 "configure_function": configure_element,
764 "connector_types": [],
765 "box_attributes": ["MaxPerHopDelay",
768 "PacketSizeBinWidth",
769 "FlowInterruptionsBinWidth",
770 "FlowInterruptionsMinTime"],
772 "ns3::ConstantVelocityMobilityModel": dict({
773 "category": FC.CATEGORY_MOBILITY_MODELS,
774 "create_function": create_element,
775 "configure_function": configure_element,
777 "connector_types": ["node"],
778 "box_attributes": ["Position",
780 "tags": [tags.MOBILE],
782 "ns3::V4Ping": dict({
783 "category": FC.CATEGORY_APPLICATIONS,
784 "create_function": create_element,
785 "configure_function": configure_element,
787 "connector_types": ["node"],
788 "stop_function": stop_application,
789 "start_function": start_application,
790 "status_function": status_application,
791 "box_attributes": ["Remote",
798 "tags": [tags.APPLICATION],
800 "ns3::dot11s::PeerLink": dict({
802 "create_function": create_element,
803 "configure_function": configure_element,
805 "connector_types": [],
806 "box_attributes": ["RetryTimeout",
813 "ns3::PointToPointNetDevice": dict({
814 "category": FC.CATEGORY_DEVICES,
815 "create_function": create_element,
816 "configure_function": configure_device,
818 "connector_types": ["node", "err", "queue", "chan"],
819 "box_attributes": ["Mtu",
823 "traces": ["p2ppcap", "p2pascii"],
824 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
826 "ns3::NakagamiPropagationLossModel": dict({
827 "category": FC.CATEGORY_LOSS_MODELS,
828 "create_function": create_element,
829 "configure_function": configure_element,
831 "connector_types": [],
832 "box_attributes": ["Distance1",
838 "ns3::AarfWifiManager": dict({
839 "category": FC.CATEGORY_MANAGERS,
840 "create_function": create_element,
841 "configure_function": configure_element,
843 "connector_types": ["dev"],
844 "box_attributes": ["SuccessK",
846 "MaxSuccessThreshold",
848 "MinSuccessThreshold",
853 "FragmentationThreshold",
856 "ns3::Ipv6OptionJumbogram": dict({
858 "create_function": create_element,
859 "configure_function": configure_element,
861 "connector_types": [],
862 "box_attributes": ["OptionNumber"],
864 "ns3::TwoRayGroundPropagationLossModel": dict({
865 "category": FC.CATEGORY_LOSS_MODELS,
866 "create_function": create_element,
867 "configure_function": configure_element,
869 "connector_types": [],
870 "box_attributes": ["Lambda",
875 "ns3::OnOffApplication": dict({
876 "category": FC.CATEGORY_APPLICATIONS,
877 "create_function": create_element,
878 "configure_function": configure_element,
880 "connector_types": ["node"],
881 "stop_function": stop_application,
882 "start_function": start_application,
883 "status_function": status_application,
884 "box_attributes": ["DataRate",
893 "tags": [tags.APPLICATION],
895 "ns3::AdhocWifiMac": dict({
896 "category": FC.CATEGORY_MAC_MODELS,
897 "create_function": create_element,
898 "configure_function": configure_element,
900 "connector_types": [],
901 "box_attributes": ["CtsTimeout",
903 "BasicBlockAckTimeout",
904 "CompressedBlockAckTimeout",
909 "MaxPropagationDelay",
912 "ns3::ConstantAccelerationMobilityModel": dict({
913 "category": FC.CATEGORY_MOBILITY_MODELS,
914 "create_function": create_element,
915 "configure_function": configure_element,
917 "connector_types": ["node"],
918 "box_attributes": ["Position",
920 "tags": [tags.MOBILE],
922 "ns3::GaussMarkovMobilityModel": dict({
923 "category": FC.CATEGORY_MOBILITY_MODELS,
924 "create_function": create_element,
925 "configure_function": configure_element,
927 "connector_types": [],
928 "box_attributes": ["Bounds",
939 "tags": [tags.MOBILE],
941 "ns3::dot11s::HwmpProtocol": dict({
942 "category": FC.CATEGORY_PROTOCOLS,
943 "create_function": create_element,
944 "configure_function": configure_element,
946 "connector_types": [],
947 "box_attributes": ["RandomStart",
949 "Dot11MeshHWMPmaxPREQretries",
950 "Dot11MeshHWMPnetDiameterTraversalTime",
951 "Dot11MeshHWMPpreqMinInterval",
952 "Dot11MeshHWMPperrMinInterval",
953 "Dot11MeshHWMPactiveRootTimeout",
954 "Dot11MeshHWMPactivePathTimeout",
955 "Dot11MeshHWMPpathToRootInterval",
956 "Dot11MeshHWMPrannInterval",
958 "UnicastPerrThreshold",
959 "UnicastPreqThreshold",
960 "UnicastDataThreshold",
964 "ns3::NscTcpL4Protocol": dict({
965 "category": FC.CATEGORY_PROTOCOLS,
966 "create_function": create_element,
967 "configure_function": configure_element,
969 "connector_types": [],
970 "box_attributes": ["Library",
973 "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
975 "create_function": create_element,
976 "configure_function": configure_element,
978 "connector_types": [],
979 "box_attributes": ["Dot11sMeshHeaderLength"],
981 "ns3::UanMacCw": dict({
983 "create_function": create_element,
984 "configure_function": configure_element,
986 "connector_types": [],
987 "box_attributes": ["CW",
990 "ns3::AthstatsWifiTraceSink": dict({
992 "create_function": create_element,
993 "configure_function": configure_element,
995 "connector_types": [],
996 "box_attributes": ["Interval"],
998 "ns3::FlameStack": dict({
1000 "create_function": create_element,
1001 "configure_function": configure_element,
1003 "connector_types": [],
1004 "box_attributes": [],
1006 "ns3::UanMacRc": dict({
1008 "create_function": create_element,
1009 "configure_function": configure_element,
1011 "connector_types": [],
1012 "box_attributes": ["RetryRate",
1019 "NumberOfRetryRates",
1022 "ns3::WaypointMobilityModel": dict({
1023 "category": FC.CATEGORY_MOBILITY_MODELS,
1024 "create_function": create_waypoint_mobility,
1025 "configure_function": configure_element,
1026 "help": "Waypoint-based mobility model.",
1027 "connector_types": ["node"],
1028 "box_attributes": ["WaypointsLeft",
1032 "tags": [tags.MOBILE],
1034 "ns3::FileDescriptorNetDevice": dict({
1035 "category": FC.CATEGORY_DEVICES,
1036 "create_function": create_element,
1037 "configure_function": configure_device,
1038 "help": "Network interface associated to a file descriptor",
1039 "connector_types": ["node", "->fd"],
1040 "box_attributes": ["Address",
1041 "LinuxSocketAddress",
1042 "tun_proto", "tun_addr", "tun_port", "tun_key"],
1043 "traces": ["fdpcap"],
1044 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1046 "ns3::Nepi::TunChannel": dict({
1047 "category": FC.CATEGORY_TUNNELS,
1048 "create_function": create_tunchannel,
1049 "preconfigure_function": preconfigure_tunchannel,
1050 "configure_function": postconfigure_tunchannel,
1051 "prestart_function": wait_tunchannel,
1052 "help": "Channel to forward FileDescriptorNetDevice data to "
1053 "other TAP interfaces supporting the NEPI tunneling protocol.",
1054 "connector_types": ["fd->", "udp", "tcp"],
1055 "allow_addresses": False,
1056 "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key"],
1057 "tags": [tags.TUNNEL],
1060 "ns3::CsmaNetDevice": dict({
1061 "category": FC.CATEGORY_DEVICES,
1062 "create_function": create_element,
1063 "configure_function": configure_device,
1064 "help": "CSMA (carrier sense, multiple access) interface",
1065 "connector_types": ["node", "chan", "err", "queue"],
1066 "box_attributes": ["Address",
1070 "traces": ["csmapcap", "csmapcap_promisc"],
1071 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1073 "ns3::UanPropModelThorp": dict({
1075 "create_function": create_element,
1076 "configure_function": configure_element,
1078 "connector_types": [],
1079 "box_attributes": ["SpreadCoef"],
1081 "ns3::NqstaWifiMac": dict({
1082 "category": FC.CATEGORY_MAC_MODELS,
1083 "create_function": create_wifi_standard_model,
1084 "configure_function": configure_element,
1086 "connector_types": ["dev"],
1087 "box_attributes": ["ProbeRequestTimeout",
1088 "AssocRequestTimeout",
1092 "BasicBlockAckTimeout",
1093 "CompressedBlockAckTimeout",
1098 "MaxPropagationDelay",
1101 "ns3::Icmpv6L4Protocol": dict({
1102 "category": FC.CATEGORY_PROTOCOLS,
1103 "create_function": create_element,
1104 "configure_function": configure_element,
1106 "connector_types": ["node"],
1107 "box_attributes": ["DAD",
1110 "ns3::SimpleNetDevice": dict({
1111 "category": FC.CATEGORY_DEVICES,
1112 "create_function": create_element,
1113 "configure_function": configure_element,
1115 "connector_types": ["node", "chan"],
1116 "box_attributes": [],
1117 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1119 "ns3::FriisPropagationLossModel": dict({
1120 "category": FC.CATEGORY_LOSS_MODELS,
1121 "create_function": create_element,
1122 "configure_function": configure_element,
1124 "connector_types": [],
1125 "box_attributes": ["Lambda",
1129 "ns3::Ipv6OptionRouterAlert": dict({
1131 "create_function": create_element,
1132 "configure_function": configure_element,
1134 "connector_types": [],
1135 "box_attributes": ["OptionNumber"],
1137 "ns3::UniformDiscPositionAllocator": dict({
1138 "category": FC.CATEGORY_MOBILITY_MODELS,
1139 "create_function": create_element,
1140 "configure_function": configure_element,
1142 "connector_types": [],
1143 "box_attributes": ["rho",
1146 "tags": [tags.MOBILE],
1148 "ns3::RandomBoxPositionAllocator": dict({
1149 "category": FC.CATEGORY_MOBILITY_MODELS,
1150 "create_function": create_element,
1151 "configure_function": configure_element,
1153 "connector_types": [],
1154 "box_attributes": ["X",
1157 "tags": [tags.MOBILE],
1159 "ns3::Ipv6ExtensionDestination": dict({
1161 "create_function": create_element,
1162 "configure_function": configure_element,
1164 "connector_types": [],
1165 "box_attributes": ["ExtensionNumber"],
1167 "ns3::LoopbackNetDevice": dict({
1168 "category": FC.CATEGORY_DEVICES,
1169 "create_function": create_element,
1170 "configure_function": configure_element,
1172 "connector_types": [],
1173 "box_attributes": [],
1174 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1176 "ns3::ConstantSpeedPropagationDelayModel": dict({
1177 "category": FC.CATEGORY_DELAY_MODELS,
1178 "create_function": create_element,
1179 "configure_function": configure_element,
1181 "connector_types": ["chan"],
1182 "box_attributes": ["Speed"],
1184 "ns3::Ipv6ExtensionHopByHop": dict({
1186 "create_function": create_element,
1187 "configure_function": configure_element,
1189 "connector_types": [],
1190 "box_attributes": ["ExtensionNumber"],
1192 "ns3::BridgeChannel": dict({
1193 "category": FC.CATEGORY_CHANNELS,
1194 "create_function": create_element,
1195 "configure_function": configure_element,
1197 "connector_types": [],
1198 "box_attributes": [],
1200 "ns3::Radvd": dict({
1202 "create_function": create_element,
1203 "configure_function": configure_element,
1205 "connector_types": [],
1206 "box_attributes": ["StartTime",
1209 "ns3::PacketSocket": dict({
1211 "create_function": create_element,
1212 "configure_function": configure_element,
1214 "connector_types": [],
1215 "box_attributes": ["RcvBufSize"],
1217 "ns3::flame::FlameProtocol": dict({
1218 "category": FC.CATEGORY_PROTOCOLS,
1219 "create_function": create_element,
1220 "configure_function": configure_element,
1222 "connector_types": [],
1223 "box_attributes": ["BroadcastInterval",
1226 "ns3::Cost231PropagationLossModel": dict({
1227 "category": FC.CATEGORY_LOSS_MODELS,
1228 "create_function": create_element,
1229 "configure_function": configure_element,
1231 "connector_types": [],
1232 "box_attributes": ["Lambda",
1238 "ns3::Ipv6ExtensionESP": dict({
1240 "create_function": create_element,
1241 "configure_function": configure_element,
1243 "connector_types": [],
1244 "box_attributes": ["ExtensionNumber"],
1246 "ns3::CaraWifiManager": dict({
1247 "category": FC.CATEGORY_MANAGERS,
1248 "create_function": create_element,
1249 "configure_function": configure_element,
1251 "connector_types": ["dev"],
1252 "box_attributes": ["ProbeThreshold",
1260 "FragmentationThreshold",
1264 "ns3::RttMeanDeviation": dict({
1266 "create_function": create_element,
1267 "configure_function": configure_element,
1269 "connector_types": [],
1270 "box_attributes": ["Gain",
1272 "InitialEstimation",
1275 "ns3::Icmpv4L4Protocol": dict({
1276 "category": FC.CATEGORY_PROTOCOLS,
1277 "create_function": create_element,
1278 "configure_function": configure_element,
1280 "connector_types": ["node"],
1281 "box_attributes": ["ProtocolNumber"],
1283 "ns3::WaveformGenerator": dict({
1285 "create_function": create_element,
1286 "configure_function": configure_element,
1288 "connector_types": [],
1289 "box_attributes": ["Period",
1292 "ns3::YansWifiChannel": dict({
1293 "category": FC.CATEGORY_CHANNELS,
1294 "create_function": create_element,
1295 "configure_function": configure_element,
1297 "connector_types": ["phys", "delay", "loss"],
1298 "box_attributes": [],
1300 "ns3::SimpleChannel": dict({
1301 "category": FC.CATEGORY_CHANNELS,
1302 "create_function": create_element,
1303 "configure_function": configure_element,
1305 "connector_types": ["devs"],
1306 "box_attributes": [],
1308 "ns3::Ipv6ExtensionFragment": dict({
1310 "create_function": create_element,
1311 "configure_function": configure_element,
1313 "connector_types": [],
1314 "box_attributes": ["ExtensionNumber"],
1316 "ns3::Dot11sStack": dict({
1318 "create_function": create_element,
1319 "configure_function": configure_element,
1321 "connector_types": [],
1322 "box_attributes": ["Root"],
1324 "ns3::FriisSpectrumPropagationLossModel": dict({
1325 "category": FC.CATEGORY_LOSS_MODELS,
1326 "create_function": create_element,
1327 "configure_function": configure_element,
1329 "connector_types": [],
1330 "box_attributes": [],
1332 "ns3::RandomRectanglePositionAllocator": dict({
1333 "category": FC.CATEGORY_MOBILITY_MODELS,
1334 "create_function": create_element,
1335 "configure_function": configure_element,
1337 "connector_types": [],
1338 "box_attributes": ["X",
1340 "tags": [tags.MOBILE],
1342 "ns3::NqapWifiMac": dict({
1343 "category": FC.CATEGORY_MAC_MODELS,
1344 "create_function": create_wifi_standard_model,
1345 "configure_function": configure_element,
1347 "connector_types": ["dev"],
1348 "box_attributes": ["BeaconInterval",
1352 "BasicBlockAckTimeout",
1353 "CompressedBlockAckTimeout",
1358 "MaxPropagationDelay",
1361 "ns3::HierarchicalMobilityModel": dict({
1362 "category": FC.CATEGORY_MOBILITY_MODELS,
1363 "create_function": create_element,
1364 "configure_function": configure_element,
1366 "connector_types": ["node"],
1367 "box_attributes": ["Position",
1369 "tags": [tags.MOBILE],
1371 "ns3::ThreeLogDistancePropagationLossModel": dict({
1372 "category": FC.CATEGORY_LOSS_MODELS,
1373 "create_function": create_element,
1374 "configure_function": configure_element,
1376 "connector_types": [],
1377 "box_attributes": ["Distance0",
1385 "ns3::UanNoiseModelDefault": dict({
1387 "create_function": create_element,
1388 "configure_function": configure_element,
1390 "connector_types": [],
1391 "box_attributes": ["Wind",
1394 "ns3::dot11s::HwmpRtable": dict({
1396 "create_function": create_element,
1397 "configure_function": configure_element,
1399 "connector_types": [],
1400 "box_attributes": [],
1402 "ns3::PacketBurst": dict({
1404 "create_function": create_element,
1405 "configure_function": configure_element,
1407 "connector_types": [],
1408 "box_attributes": [],
1410 "ns3::RandomPropagationDelayModel": dict({
1411 "category": FC.CATEGORY_DELAY_MODELS,
1412 "create_function": create_element,
1413 "configure_function": configure_element,
1415 "connector_types": [],
1416 "box_attributes": ["Variable"],
1418 "ns3::ArpL3Protocol": dict({
1419 "category": FC.CATEGORY_PROTOCOLS,
1420 "create_function": create_element,
1421 "configure_function": configure_element,
1423 "connector_types": ["node"],
1424 "box_attributes": [],
1426 "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1427 "category": FC.CATEGORY_MOBILITY_MODELS,
1428 "create_function": create_element,
1429 "configure_function": configure_element,
1431 "connector_types": [],
1432 "box_attributes": ["MinSpeed",
1442 "tags": [tags.MOBILE],
1444 "ns3::BaseStationNetDevice": dict({
1445 "category": FC.CATEGORY_DEVICES,
1446 "create_function": create_base_station,
1447 "configure_function": configure_station,
1448 "help": "Base station for wireless mobile network",
1449 "connector_types": ["node", "chan", "phy", "uplnk", "dwnlnk"],
1450 "box_attributes": ["InitialRangInterval",
1456 "MaxRangCorrectionRetries",
1460 "traces": ["wimaxpcap", "wimaxascii"],
1461 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1463 "ns3::UdpServer": dict({
1464 "category": FC.CATEGORY_APPLICATIONS,
1465 "create_function": create_element,
1466 "configure_function": configure_element,
1468 "connector_types": ["node"],
1469 "stop_function": stop_application,
1470 "start_function": start_application,
1471 "status_function": status_application,
1472 "box_attributes": ["Port",
1477 "ns3::AarfcdWifiManager": dict({
1478 "category": FC.CATEGORY_MANAGERS,
1479 "create_function": create_element,
1480 "configure_function": configure_element,
1482 "connector_types": ["dev"],
1483 "box_attributes": ["SuccessK",
1485 "MaxSuccessThreshold",
1486 "MinTimerThreshold",
1487 "MinSuccessThreshold",
1490 "TurnOffRtsAfterRateDecrease",
1491 "TurnOnRtsAfterRateIncrease",
1496 "FragmentationThreshold",
1499 "ns3::UanTransducerHd": dict({
1501 "create_function": create_element,
1502 "configure_function": configure_element,
1504 "connector_types": [],
1505 "box_attributes": [],
1507 "ns3::LogDistancePropagationLossModel": dict({
1508 "category": FC.CATEGORY_LOSS_MODELS,
1509 "create_function": create_element,
1510 "configure_function": configure_element,
1512 "connector_types": ["prev", "next"],
1513 "box_attributes": ["Exponent",
1514 "ReferenceDistance",
1517 "ns3::EmuNetDevice": dict({
1518 "category": FC.CATEGORY_DEVICES,
1519 "create_function": create_element,
1520 "configure_function": configure_element,
1522 "connector_types": ["node", "queue"],
1523 "box_attributes": ["Mtu",
1529 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1531 "ns3::Ipv6ExtensionLooseRouting": dict({
1532 "category": FC.CATEGORY_ROUTING,
1533 "create_function": create_element,
1534 "configure_function": configure_element,
1536 "connector_types": [],
1537 "box_attributes": ["ExtensionNumber"],
1539 "ns3::RandomWaypointMobilityModel": dict({
1540 "category": FC.CATEGORY_MOBILITY_MODELS,
1541 "create_function": create_element,
1542 "configure_function": configure_element,
1544 "connector_types": ["node"],
1545 "box_attributes": ["Speed",
1549 "tags": [tags.MOBILE],
1551 "ns3::RangePropagationLossModel": dict({
1552 "category": FC.CATEGORY_LOSS_MODELS,
1553 "create_function": create_element,
1554 "configure_function": configure_element,
1556 "connector_types": [],
1557 "box_attributes": ["MaxRange"],
1559 "ns3::AlohaNoackNetDevice": dict({
1560 "category": FC.CATEGORY_DEVICES,
1561 "create_function": create_element,
1562 "configure_function": configure_element,
1564 "connector_types": [],
1565 "box_attributes": ["Address",
1567 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1569 "ns3::MatrixPropagationLossModel": dict({
1570 "category": FC.CATEGORY_LOSS_MODELS,
1571 "create_function": create_element,
1572 "configure_function": configure_element,
1574 "connector_types": [],
1575 "box_attributes": ["DefaultLoss"],
1577 "ns3::WifiNetDevice": dict({
1578 "category": FC.CATEGORY_DEVICES,
1579 "create_function": create_element,
1580 "configure_function": configure_device,
1582 "connector_types": ["node", "mac", "phy", "manager"],
1583 "box_attributes": ["Mtu"],
1584 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1586 "ns3::CsmaChannel": dict({
1587 "category": FC.CATEGORY_CHANNELS,
1588 "create_function": create_element,
1589 "configure_function": configure_element,
1591 "connector_types": ["devs"],
1592 "box_attributes": ["DataRate",
1595 "ns3::BridgeNetDevice": dict({
1596 "category": FC.CATEGORY_DEVICES,
1597 "create_function": create_element,
1598 "configure_function": configure_element,
1600 "connector_types": ["node"],
1601 "box_attributes": ["Mtu",
1604 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1606 "ns3::Ipv6ExtensionRouting": dict({
1607 "category": FC.CATEGORY_ROUTING,
1608 "create_function": create_element,
1609 "configure_function": configure_element,
1611 "connector_types": [],
1612 "box_attributes": ["ExtensionNumber"],
1614 "ns3::QstaWifiMac": dict({
1615 "category": FC.CATEGORY_MAC_MODELS,
1616 "create_function": create_wifi_standard_model,
1617 "configure_function": configure_element,
1618 "help": "Station Wifi MAC Model",
1619 "connector_types": ["dev"],
1620 "box_attributes": ["ProbeRequestTimeout",
1621 "AssocRequestTimeout",
1625 "BasicBlockAckTimeout",
1626 "CompressedBlockAckTimeout",
1631 "MaxPropagationDelay",
1635 "ns3::UdpEchoClient": dict({
1636 "category": FC.CATEGORY_APPLICATIONS,
1637 "create_function": create_element,
1638 "configure_function": configure_element,
1640 "connector_types": ["node"],
1641 "stop_function": stop_application,
1642 "start_function": start_application,
1643 "status_function": status_application,
1644 "box_attributes": ["MaxPackets",
1651 "tags": [tags.APPLICATION],
1653 "ns3::UdpClient": dict({
1654 "category": FC.CATEGORY_APPLICATIONS,
1655 "create_function": create_element,
1656 "configure_function": configure_element,
1658 "connector_types": ["node"],
1659 "stop_function": stop_application,
1660 "start_function": start_application,
1661 "status_function": status_application,
1662 "box_attributes": ["MaxPackets",
1669 "tags": [tags.APPLICATION],
1671 "ns3::PointToPointChannel": dict({
1672 "category": FC.CATEGORY_CHANNELS,
1673 "create_function": create_element,
1674 "configure_function": configure_element,
1676 "connector_types": ["dev2"],
1677 "box_attributes": ["Delay"],
1679 "ns3::Ipv6StaticRouting": dict({
1680 "category": FC.CATEGORY_ROUTING,
1681 "create_function": create_element,
1682 "configure_function": configure_element,
1684 "connector_types": [],
1685 "box_attributes": [],
1687 "ns3::DropTailQueue": dict({
1688 "category": FC.CATEGORY_QUEUES,
1689 "create_function": create_element,
1690 "configure_function": configure_element,
1692 "connector_types": ["dev"],
1693 "box_attributes": ["MaxPackets",
1696 "ns3::ConstantPositionMobilityModel": dict({
1697 "category": FC.CATEGORY_MOBILITY_MODELS,
1698 "create_function": create_element,
1699 "configure_function": configure_element,
1701 "connector_types": ["node"],
1702 "box_attributes": ["Position",
1704 "tags": [tags.MOBILE],
1706 "ns3::FixedRssLossModel": dict({
1707 "category": FC.CATEGORY_LOSS_MODELS,
1708 "create_function": create_element,
1709 "configure_function": configure_element,
1711 "connector_types": [],
1712 "box_attributes": ["Rss"],
1714 "ns3::EnergySourceContainer": dict({
1715 "category": FC.CATEGORY_ENERGY_MODELS,
1716 "create_function": create_element,
1717 "configure_function": configure_element,
1719 "connector_types": [],
1720 "box_attributes": [],
1722 "ns3::RandomWalk2dMobilityModel": dict({
1723 "category": FC.CATEGORY_MOBILITY_MODELS,
1724 "create_function": create_element,
1725 "configure_function": configure_element,
1727 "connector_types": ["node"],
1728 "box_attributes": ["Bounds",
1736 "tags": [tags.MOBILE],
1738 "ns3::ListPositionAllocator": dict({
1740 "create_function": create_element,
1741 "configure_function": configure_element,
1743 "connector_types": [],
1744 "box_attributes": [],
1746 "ns3::dot11s::PeerManagementProtocol": dict({
1747 "category": FC.CATEGORY_PROTOCOLS,
1748 "create_function": create_element,
1749 "configure_function": configure_element,
1751 "connector_types": [],
1752 "box_attributes": ["MaxNumberOfPeerLinks",
1753 "MaxBeaconShiftValue",
1754 "EnableBeaconCollisionAvoidance"],
1756 "ns3::MeshPointDevice": dict({
1757 "category": FC.CATEGORY_DEVICES,
1758 "create_function": create_element,
1759 "configure_function": configure_element,
1761 "connector_types": [],
1762 "box_attributes": ["Mtu"],
1763 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1765 "ns3::BasicEnergySource": dict({
1766 "category": FC.CATEGORY_ENERGY_MODELS,
1767 "create_function": create_element,
1768 "configure_function": configure_element,
1770 "connector_types": [],
1771 "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1772 "BasicEnergySupplyVoltageV",
1773 "PeriodicEnergyUpdateInterval"],
1775 "ns3::Ipv6OptionPadn": dict({
1777 "create_function": create_element,
1778 "configure_function": configure_element,
1780 "connector_types": [],
1781 "box_attributes": ["OptionNumber"],
1783 "ns3::QapWifiMac": dict({
1784 "category": FC.CATEGORY_MAC_MODELS,
1785 "create_function": create_wifi_standard_model,
1786 "configure_function": configure_element,
1787 "help": "Access point Wifi MAC Model",
1788 "connector_types": ["dev"],
1789 "box_attributes": ["BeaconInterval",
1793 "BasicBlockAckTimeout",
1794 "CompressedBlockAckTimeout",
1799 "MaxPropagationDelay",
1803 "ns3::YansErrorRateModel": dict({
1804 "category": FC.CATEGORY_ERROR_MODELS,
1805 "create_function": create_element,
1806 "configure_function": configure_element,
1808 "connector_types": [],
1809 "box_attributes": [],
1811 "ns3::WifiMacQueue": dict({
1812 "category": FC.CATEGORY_QUEUES,
1813 "create_function": create_element,
1814 "configure_function": configure_element,
1816 "connector_types": [],
1817 "box_attributes": ["MaxPacketNumber",
1820 "ns3::NonCommunicatingNetDevice": dict({
1821 "category": FC.CATEGORY_DEVICES,
1822 "create_function": create_element,
1823 "configure_function": configure_element,
1825 "connector_types": [],
1826 "box_attributes": [],
1827 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1829 "ns3::RateErrorModel": dict({
1830 "category": FC.CATEGORY_ERROR_MODELS,
1831 "create_function": create_element,
1832 "configure_function": configure_element,
1834 "connector_types": [],
1835 "box_attributes": ["ErrorUnit",
1840 "ns3::MeshWifiInterfaceMac": dict({
1841 "category": FC.CATEGORY_MAC_MODELS,
1842 "create_function": create_element,
1843 "configure_function": configure_element,
1845 "connector_types": [],
1846 "box_attributes": ["BeaconInterval",
1851 "BasicBlockAckTimeout",
1852 "CompressedBlockAckTimeout",
1857 "MaxPropagationDelay",
1860 "ns3::UanPhyCalcSinrDual": dict({
1862 "create_function": create_element,
1863 "configure_function": configure_element,
1865 "connector_types": [],
1866 "box_attributes": [],
1868 "ns3::Ipv6ExtensionAH": dict({
1870 "create_function": create_element,
1871 "configure_function": configure_element,
1873 "connector_types": [],
1874 "box_attributes": ["ExtensionNumber"],
1876 "ns3::SingleModelSpectrumChannel": dict({
1877 "category": FC.CATEGORY_CHANNELS,
1878 "create_function": create_element,
1879 "configure_function": configure_element,
1881 "connector_types": [],
1882 "box_attributes": [],
1884 "ns3::YansWifiPhy": dict({
1885 "category": FC.CATEGORY_PHY_MODELS,
1886 "create_function": create_wifi_standard_model,
1887 "configure_function": configure_element,
1889 "connector_types": ["dev", "err", "chan"],
1890 "box_attributes": ["EnergyDetectionThreshold",
1891 "CcaMode1Threshold",
1898 "ChannelSwitchDelay",
1901 "traces": ["yanswifipcap"]
1903 "ns3::WifiRadioEnergyModel": dict({
1904 "category": FC.CATEGORY_ENERGY_MODELS,
1905 "create_function": create_element,
1906 "configure_function": configure_element,
1908 "connector_types": [],
1909 "box_attributes": ["TxCurrentA",
1914 "ns3::EdcaTxopN": dict({
1916 "create_function": create_element,
1917 "configure_function": configure_element,
1919 "connector_types": [],
1920 "box_attributes": ["BlockAckThreshold",
1925 "ns3::UanPhyPerGenDefault": dict({
1927 "create_function": create_element,
1928 "configure_function": configure_element,
1930 "connector_types": [],
1931 "box_attributes": ["Threshold"],
1933 "ns3::IdealWifiManager": dict({
1934 "category": FC.CATEGORY_MANAGERS,
1935 "create_function": create_element,
1936 "configure_function": configure_element,
1938 "connector_types": ["dev"],
1939 "box_attributes": ["BerThreshold",
1944 "FragmentationThreshold",
1947 "ns3::MultiModelSpectrumChannel": dict({
1948 "category": FC.CATEGORY_CHANNELS,
1949 "create_function": create_element,
1950 "configure_function": configure_element,
1952 "connector_types": [],
1953 "box_attributes": [],
1955 "ns3::HalfDuplexIdealPhy": dict({
1956 "category": FC.CATEGORY_PHY_MODELS,
1957 "create_function": create_element,
1958 "configure_function": configure_element,
1960 "connector_types": [],
1961 "box_attributes": ["Rate"],
1963 "ns3::UanPhyCalcSinrDefault": dict({
1964 "category": FC.CATEGORY_PHY_MODELS,
1965 "create_function": create_element,
1966 "configure_function": configure_element,
1968 "connector_types": [],
1969 "box_attributes": [],
1971 "ns3::ReceiveListErrorModel": dict({
1972 "category": FC.CATEGORY_ERROR_MODELS,
1973 "create_function": create_element,
1974 "configure_function": configure_element,
1976 "connector_types": [],
1977 "box_attributes": ["IsEnabled"],
1979 "ns3::SpectrumAnalyzer": dict({
1981 "create_function": create_element,
1982 "configure_function": configure_element,
1984 "connector_types": [],
1985 "box_attributes": ["Resolution",
1986 "NoisePowerSpectralDensity"],
1988 "ns3::ConstantRateWifiManager": dict({
1989 "category": FC.CATEGORY_MANAGERS,
1990 "create_function": create_element,
1991 "configure_function": configure_element,
1993 "connector_types": ["dev"],
1994 "box_attributes": ["DataMode",
2000 "FragmentationThreshold",
2003 "ns3::Ipv6OptionPad1": dict({
2005 "create_function": create_element,
2006 "configure_function": configure_element,
2008 "connector_types": [],
2009 "box_attributes": ["OptionNumber"],
2011 "ns3::UdpTraceClient": dict({
2013 "create_function": create_element,
2014 "configure_function": configure_element,
2016 "connector_types": [],
2017 "box_attributes": ["RemoteAddress",
2023 "ns3::RraaWifiManager": dict({
2024 "category": FC.CATEGORY_MANAGERS,
2025 "create_function": create_element,
2026 "configure_function": configure_element,
2028 "connector_types": ["dev"],
2029 "box_attributes": ["Basic",
2057 "FragmentationThreshold",
2060 "ns3::RandomPropagationLossModel": dict({
2061 "category": FC.CATEGORY_LOSS_MODELS,
2062 "create_function": create_element,
2063 "configure_function": configure_element,
2065 "connector_types": [],
2066 "box_attributes": ["Variable"],
2068 "ns3::UanChannel": dict({
2069 "category": FC.CATEGORY_CHANNELS,
2070 "create_function": create_element,
2071 "configure_function": configure_element,
2073 "connector_types": [],
2074 "box_attributes": [],
2076 "ns3::MinstrelWifiManager": dict({
2077 "category": FC.CATEGORY_MANAGERS,
2078 "create_function": create_element,
2079 "configure_function": configure_element,
2081 "connector_types": ["dev"],
2082 "box_attributes": ["UpdateStatistics",
2092 "FragmentationThreshold",
2095 "ns3::UanPhyDual": dict({
2096 "category": FC.CATEGORY_PHY_MODELS,
2097 "create_function": create_element,
2098 "configure_function": configure_element,
2100 "connector_types": [],
2101 "box_attributes": ["CcaThresholdPhy1",
2107 "SupportedModesPhy1",
2108 "SupportedModesPhy2"],
2110 "ns3::ListErrorModel": dict({
2111 "category": FC.CATEGORY_ERROR_MODELS,
2112 "create_function": create_element,
2113 "configure_function": configure_element,
2115 "connector_types": ["dev"],
2116 "box_attributes": ["IsEnabled"],
2118 "ns3::VirtualNetDevice": dict({
2119 "category": FC.CATEGORY_DEVICES,
2120 "create_function": create_element,
2121 "configure_function": configure_element,
2123 "connector_types": [],
2124 "box_attributes": ["Mtu"],
2125 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2127 "ns3::UanPhyGen": dict({
2128 "category": FC.CATEGORY_PHY_MODELS,
2129 "create_function": create_element,
2130 "configure_function": configure_element,
2132 "connector_types": [],
2133 "box_attributes": ["CcaThreshold",
2139 "ns3::Ipv6L3Protocol": dict({
2140 "category": FC.CATEGORY_PROTOCOLS,
2141 "create_function": create_element,
2142 "configure_function": configure_element,
2144 "connector_types": ["node"],
2145 "box_attributes": ["DefaultTtl",
2148 "ns3::PointToPointRemoteChannel": dict({
2149 "category": FC.CATEGORY_CHANNELS,
2150 "create_function": create_element,
2151 "configure_function": configure_element,
2153 "connector_types": [],
2154 "box_attributes": ["Delay"],
2156 "ns3::UanPhyPerUmodem": dict({
2157 "category": FC.CATEGORY_PHY_MODELS,
2158 "create_function": create_element,
2159 "configure_function": configure_element,
2161 "connector_types": [],
2162 "box_attributes": [],
2164 "ns3::OnoeWifiManager": dict({
2165 "category": FC.CATEGORY_MANAGERS,
2166 "create_function": create_element,
2167 "configure_function": configure_element,
2169 "connector_types": ["dev"],
2170 "box_attributes": ["UpdatePeriod",
2172 "AddCreditThreshold",
2177 "FragmentationThreshold",
2180 "ns3::QadhocWifiMac": dict({
2181 "category": FC.CATEGORY_MAC_MODELS,
2182 "create_function": create_element,
2183 "configure_function": configure_element,
2185 "connector_types": [],
2186 "box_attributes": ["CtsTimeout",
2188 "BasicBlockAckTimeout",
2189 "CompressedBlockAckTimeout",
2194 "MaxPropagationDelay",
2197 "ns3::JakesPropagationLossModel": dict({
2198 "category": FC.CATEGORY_LOSS_MODELS,
2199 "create_function": create_element,
2200 "configure_function": configure_element,
2202 "connector_types": [],
2203 "box_attributes": ["NumberOfRaysPerPath",
2204 "NumberOfOscillatorsPerRay",
2208 "ns3::PacketSink": dict({
2209 "category": FC.CATEGORY_APPLICATIONS,
2210 "create_function": create_element,
2211 "configure_function": configure_element,
2213 "connector_types": ["node"],
2214 "stop_function": stop_application,
2215 "start_function": start_application,
2216 "status_function": status_application,
2217 "box_attributes": ["Local",
2221 "tags": [tags.APPLICATION],
2223 "ns3::RandomDirection2dMobilityModel": dict({
2224 "category": FC.CATEGORY_MOBILITY_MODELS,
2225 "create_function": create_element,
2226 "configure_function": configure_element,
2228 "connector_types": ["node"],
2229 "box_attributes": ["Bounds",
2234 "tags": [tags.MOBILE],
2236 "ns3::UanMacAloha": dict({
2238 "create_function": create_element,
2239 "configure_function": configure_element,
2241 "connector_types": [],
2242 "box_attributes": [],
2244 "ns3::MsduStandardAggregator": dict({
2246 "create_function": create_element,
2247 "configure_function": configure_element,
2249 "connector_types": [],
2250 "box_attributes": ["MaxAmsduSize"],
2252 "ns3::DcaTxop": dict({
2254 "create_function": create_element,
2255 "configure_function": configure_element,
2257 "connector_types": [],
2258 "box_attributes": ["MinCw",
2262 "ns3::UanPhyCalcSinrFhFsk": dict({
2263 "category": FC.CATEGORY_PHY_MODELS,
2264 "create_function": create_element,
2265 "configure_function": configure_element,
2267 "connector_types": [],
2268 "box_attributes": ["NumberOfHops"],
2270 "ns3::UanPropModelIdeal": dict({
2272 "create_function": create_element,
2273 "configure_function": configure_element,
2275 "connector_types": [],
2276 "box_attributes": [],
2278 "ns3::UanMacRcGw": dict({
2280 "create_function": create_element,
2281 "configure_function": configure_element,
2283 "connector_types": [],
2284 "box_attributes": ["MaxReservations",
2292 "NumberOfRetryRates",
2297 "ns3::NistErrorRateModel": dict({
2298 "category": FC.CATEGORY_ERROR_MODELS,
2299 "create_function": create_element,
2300 "configure_function": configure_element,
2302 "connector_types": ["phy"],
2303 "box_attributes": [],
2305 "ns3::Ipv4L3Protocol": dict({
2306 "category": FC.CATEGORY_PROTOCOLS,
2307 "create_function": create_ipv4protocol,
2308 "configure_function": configure_element,
2310 "connector_types": ["node"],
2311 "box_attributes": ["DefaultTtl",
2315 "ns3::aodv::RoutingProtocol": dict({
2316 "category": FC.CATEGORY_PROTOCOLS,
2317 "create_function": create_element,
2318 "configure_function": configure_element,
2320 "connector_types": [],
2321 "box_attributes": ["HelloInterval",
2324 "NodeTraversalTime",
2326 "ActiveRouteTimeout",
2333 "PathDiscoveryTime",
2342 "ns3::TcpL4Protocol": dict({
2343 "category": FC.CATEGORY_PROTOCOLS,
2344 "create_function": create_element,
2345 "configure_function": configure_element,
2347 "connector_types": ["node"],
2348 "box_attributes": ["RttEstimatorFactory",
2351 "ns3::olsr::RoutingProtocol": dict({
2352 "category": FC.CATEGORY_PROTOCOLS,
2353 "create_function": create_element,
2354 "configure_function": configure_element,
2356 "connector_types": [],
2357 "box_attributes": ["HelloInterval",
2363 "ns3::UdpEchoServer": dict({
2364 "category": FC.CATEGORY_APPLICATIONS,
2365 "create_function": create_element,
2366 "configure_function": configure_element,
2368 "connector_types": ["node"],
2369 "stop_function": stop_application,
2370 "start_function": start_application,
2371 "status_function": status_application,
2372 "box_attributes": ["Port",
2375 "tags": [tags.APPLICATION],
2377 "ns3::AmrrWifiManager": dict({
2378 "category": FC.CATEGORY_MANAGERS,
2379 "create_function": create_element,
2380 "configure_function": configure_element,
2382 "connector_types": ["dev"],
2383 "box_attributes": ["UpdatePeriod",
2386 "MaxSuccessThreshold",
2387 "MinSuccessThreshold",
2392 "FragmentationThreshold",
2395 "ns3::ArfWifiManager": dict({
2396 "category": FC.CATEGORY_MANAGERS,
2397 "create_function": create_element,
2398 "configure_function": configure_element,
2400 "connector_types": ["dev"],
2401 "box_attributes": ["TimerThreshold",
2407 "FragmentationThreshold",
2410 "ns3::SubscriberStationNetDevice": dict({
2411 "category": FC.CATEGORY_DEVICES,
2412 "create_function": create_subscriber_station,
2413 "configure_function": configure_station,
2414 "help": "Subscriber station for mobile wireless network",
2415 "connector_types": ["node", "chan", "phy", "sflows"],
2416 "box_attributes": ["LostDlMapInterval",
2417 "LostUlMapInterval",
2427 "MaxContentionRangingRetries",
2431 "traces": ["wimaxpcap", "wimaxascii"],
2432 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2434 "ns3::flame::FlameRtable": dict({
2436 "create_function": create_element,
2437 "configure_function": configure_element,
2439 "connector_types": [],
2440 "box_attributes": ["Lifetime"],
2442 "ns3::BSSchedulerRtps": dict({
2443 "category": FC.CATEGORY_SERVICE_FLOWS,
2444 "create_function": create_element,
2445 "configure_function": configure_element,
2446 "help": "Simple downlink scheduler for rtPS flows",
2447 "connector_types": ["dev"],
2448 "box_attributes": [],
2450 "ns3::BSSchedulerSimple": dict({
2451 "category": FC.CATEGORY_SERVICE_FLOWS,
2452 "create_function": create_element,
2453 "configure_function": configure_element,
2454 "help": "simple downlink scheduler for service flows",
2455 "connector_types": ["dev"],
2456 "box_attributes": [],
2458 "ns3::SimpleOfdmWimaxChannel": dict({
2459 "category": FC.CATEGORY_CHANNELS,
2460 "create_function": create_wimax_channel,
2461 "configure_function": configure_element,
2462 "help": "Wimax channel",
2463 "connector_types": ["devs"],
2464 "box_attributes": [],
2466 "ns3::SimpleOfdmWimaxPhy": dict({
2467 "category": FC.CATEGORY_PHY_MODELS,
2468 "create_function": create_wimax_phy,
2469 "configure_function": configure_element,
2470 "help": "Wimax Phy",
2471 "connector_types": ["dev"],
2472 "box_attributes": [],
2474 "ns3::UplinkSchedulerSimple": dict({
2475 "category": FC.CATEGORY_SERVICE_FLOWS,
2476 "create_function": create_element_no_constructor,
2477 "configure_function": configure_element,
2478 "help": "Simple uplink scheduler for service flows",
2479 "connector_types": ["dev"],
2480 "box_attributes": [],
2482 "ns3::UplinkSchedulerRtps": dict({
2483 "category": FC.CATEGORY_SERVICE_FLOWS,
2484 "create_function": create_element_no_constructor,
2485 "configure_function": configure_element,
2486 "help": "Simple uplink scheduler for rtPS flows",
2487 "connector_types": ["dev"],
2488 "box_attributes": [],
2490 "ns3::IpcsClassifierRecord": dict({
2491 "category": FC.CATEGORY_SERVICE_FLOWS,
2492 "create_function": create_ipcs_classifier_record,
2493 "configure_function": configure_element,
2494 "help": "Classifier record for service flow",
2495 "connector_types": ["sflow"],
2496 "box_attributes": ["ClassifierSrcAddress",
2497 "ClassifierSrcMask",
2498 "ClassifierDstAddress",
2499 "ClassifierDstMask",
2500 "ClassifierSrcPortLow",
2501 "ClassifierSrcPortHigh",
2502 "ClassifierDstPortLow",
2503 "ClassifierDstPortHigh",
2504 "ClassifierProtocol",
2505 "ClassifierPriority"],
2507 "ns3::ServiceFlow": dict({
2508 "category": FC.CATEGORY_SERVICE_FLOWS,
2509 "create_function": create_service_flow,
2510 "configure_function": configure_element,
2511 "help": "Service flow for QoS",
2512 "connector_types": ["classif", "dev"],
2513 "box_attributes": ["ServiceFlowDirection",
2514 "ServiceFlowSchedulingType"],