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 prestart_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.FdNetDeviceHelper()
130 helper.EnablePcap(filepath, element, explicitFilename = True)
132 def fdascii_trace(testbed_instance, guid, trace_id):
133 node_guid = _get_node_guid(testbed_instance, guid)
134 interface_number = _get_dev_number(testbed_instance, guid)
135 element = testbed_instance._elements[guid]
136 filename = "trace-fd-node-%d-dev-%d.tr" % (node_guid, interface_number)
137 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
138 helper = testbed_instance.ns3.FdNetDeviceHelper()
139 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
140 stream = asciiHelper.CreateFileStream(filepath)
141 helper.EnableAscii(stream, element)
143 def yanswifipcap_trace(testbed_instance, guid, trace_id):
144 dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
145 node_guid = _get_node_guid(testbed_instance, dev_guid)
146 interface_number = _get_dev_number(testbed_instance, dev_guid)
147 element = testbed_instance._elements[dev_guid]
148 filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
149 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
150 helper = testbed_instance.ns3.YansWifiPhyHelper()
151 helper.EnablePcap(filepath, element, explicitFilename = True)
153 def wimaxascii_trace(testbed_instance, guid, trace_id):
154 node_guid = _get_node_guid(testbed_instance, guid)
155 interface_number = _get_dev_number(testbed_instance, guid)
156 element = testbed_instance._elements[guid]
157 filename = "trace-wimax-node-%d-dev-%d.tr" % (node_guid, interface_number)
158 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
159 helper = testbed_instance.ns3.WimaxHelper()
160 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
161 stream = asciiHelper.CreateFileStream (filepath)
162 helper.EnableAscii(stream, element)
163 #helper.EnableLogComponents()
165 def wimaxpcap_trace(testbed_instance, guid, trace_id):
166 node_guid = _get_node_guid(testbed_instance, guid)
167 interface_number = _get_dev_number(testbed_instance, guid)
168 element = testbed_instance._elements[guid]
169 filename = "trace-wimax-node-%d-dev-%d.pcap" % (node_guid, interface_number)
170 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
171 helper = testbed_instance.ns3.WimaxHelper()
172 helper.EnablePcap(filepath, element, explicitFilename = True)
174 def rtt_trace(testbed_instance, guid, trace_id):
175 element = testbed_instance._elements[guid]
176 helper = testbed_instance.ns3.ScalarTraceHelper()
177 prefix = "trace-app-%d" % (guid, )
178 filename = helper.GetFilenameFromSource(prefix, element, trace_id)
179 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
180 prefix = filepath[:filepath.find(prefix)+len(prefix)]
181 helper.EnableTrace(element, trace_id, prefix, "T")
183 trace_functions = dict({
184 "P2PPcapTrace": p2ppcap_trace,
185 "P2PAsciiTrace": p2pascii_trace,
186 "CsmaPcapTrace": csmapcap_trace,
187 "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
188 "FdPcapTrace": fdpcap_trace,
189 "FdAsciiTrace": fdascii_trace,
190 "YansWifiPhyPcapTrace": yanswifipcap_trace,
191 "WimaxPcapTrace": wimaxpcap_trace,
192 "WimaxAsciiTrace": wimaxascii_trace,
196 ### Creation functions ###
198 def create_element(testbed_instance, guid):
199 element_factory = testbed_instance.ns3.ObjectFactory()
200 factory_id = testbed_instance._create[guid]
201 element_factory.SetTypeId(factory_id)
202 construct_parameters = testbed_instance._get_construct_parameters(guid)
203 for name, value in construct_parameters.iteritems():
204 ns3_value = testbed_instance._to_ns3_value(guid, name, value)
205 element_factory.Set(name, ns3_value)
206 element = element_factory.Create()
207 testbed_instance._elements[guid] = element
209 def create_node(testbed_instance, guid):
210 create_element(testbed_instance, guid)
211 element = testbed_instance._elements[guid]
212 element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
214 def create_wifi_standard_model(testbed_instance, guid):
215 create_element(testbed_instance, guid)
216 element = testbed_instance._elements[guid]
217 parameters = testbed_instance._get_parameters(guid)
218 standard = parameters.get("Standard")
220 raise RuntimeError("No wifi standard set for %d" % guid)
221 element.ConfigureStandard(wifi_standards[standard])
223 def create_waypoint_mobility(testbed_instance, guid):
224 create_element(testbed_instance, guid)
225 element = testbed_instance._elements[guid]
226 parameters = testbed_instance._get_parameters(guid)
227 ns3 = testbed_instance.ns3
228 waypoints = parameters.get("WaypointList", "")
229 waypoints = re.sub(" |\(|\)", "", waypoints)
230 for swp in waypoints.split(","):
234 pos = ns3.Vector(float(dwp[1]), float(dwp[2]), float(dwp[3]))
235 waypoint = ns3.Waypoint(time, pos)
236 element.AddWaypoint(waypoint)
238 def create_ipv4protocol(testbed_instance, guid):
239 create_element(testbed_instance, guid)
240 element = testbed_instance._elements[guid]
241 list_routing = testbed_instance.ns3.Ipv4ListRouting()
242 element.SetRoutingProtocol(list_routing)
243 static_routing = testbed_instance.ns3.Ipv4StaticRouting()
244 list_routing.AddRoutingProtocol(static_routing, 1)
246 def create_element_no_constructor(testbed_instance, guid):
247 """ Create function for ns3 classes for which
248 TypeId.HasConstructor == False"""
249 factory_id = testbed_instance._create[guid]
250 factory_name = factory_id.replace("ns3::", "")
251 constructor = getattr(testbed_instance.ns3, factory_name)
252 element = constructor()
253 testbed_instance._elements[guid] = element
255 def create_base_station(testbed_instance, guid):
256 node_guid = _get_node_guid(testbed_instance, guid)
257 node = testbed_instance._elements[node_guid]
258 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
259 if len(phy_guids) == 0:
260 raise RuntimeError("No PHY was found for station %d" % guid)
261 phy = testbed_instance._elements[phy_guids[0]]
262 uplnk_guids = testbed_instance.get_connected(guid, "uplnk", "dev")
263 if len(uplnk_guids) == 0:
264 raise RuntimeError("No uplink scheduler was found for station %d" % guid)
265 uplnk = testbed_instance._elements[uplnk_guids[0]]
266 dwnlnk_guids = testbed_instance.get_connected(guid, "dwnlnk", "dev")
267 if len(dwnlnk_guids) == 0:
268 raise RuntimeError("No downlink scheduler was found for station %d" % guid)
269 dwnlnk = testbed_instance._elements[dwnlnk_guids[0]]
270 element = testbed_instance.ns3.BaseStationNetDevice(node, phy, uplnk, dwnlnk)
271 testbed_instance._elements[guid] = element
273 def create_subscriber_station(testbed_instance, guid):
274 node_guid = _get_node_guid(testbed_instance, guid)
275 node = testbed_instance._elements[node_guid]
276 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
277 if len(phy_guids) == 0:
278 raise RuntimeError("No PHY was found for station %d" % guid)
279 phy = testbed_instance._elements[phy_guids[0]]
280 element = testbed_instance.ns3.SubscriberStationNetDevice(node, phy)
281 element.SetModulationType(testbed_instance.ns3.WimaxPhy.MODULATION_TYPE_QAM16_12)
282 testbed_instance._elements[guid] = element
284 def create_wimax_channel(testbed_instance, guid):
285 element = testbed_instance.ns3.SimpleOfdmWimaxChannel(testbed_instance.ns3.SimpleOfdmWimaxChannel.COST231_PROPAGATION)
286 testbed_instance._elements[guid] = element
288 def create_wimax_phy(testbed_instance, guid):
289 element = testbed_instance.ns3.SimpleOfdmWimaxPhy()
290 testbed_instance._elements[guid] = element
292 def create_service_flow(testbed_instance, guid):
293 parameters = testbed_instance._get_parameters(guid)
294 direction = parameters.get("Direction")
295 if direction == None:
296 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
297 sched = parameters.get("SchedulingType")
299 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
300 ServiceFlow = testbed_instance.ns3.ServiceFlow
301 direction = service_flow_direction[direction]
302 sched = service_flow_scheduling_type[sched]
303 element = ServiceFlow(direction)
304 element.SetCsSpecification(ServiceFlow.IPV4)
305 element.SetServiceSchedulingType(sched)
306 element.SetMaxSustainedTrafficRate(100)
307 element.SetMinReservedTrafficRate(1000000)
308 element.SetMinTolerableTrafficRate(1000000)
309 element.SetMaximumLatency(100)
310 element.SetMaxTrafficBurst(2000)
311 element.SetTrafficPriority(1)
312 element.SetUnsolicitedGrantInterval(1)
313 element.SetMaxSustainedTrafficRate(70)
314 element.SetToleratedJitter(10)
315 element.SetSduSize(49)
316 element.SetRequestTransmissionPolicy(0)
317 testbed_instance._elements[guid] = element
319 def create_ipcs_classifier_record(testbed_instance, guid):
320 parameters = testbed_instance._get_parameters(guid)
321 src_address = parameters.get("SrcAddress")
322 if src_address == None:
323 raise RuntimeError("No SrcAddress was found for classifier %d" % guid)
324 src_address = testbed_instance.ns3.Ipv4Address(src_address)
325 src_mask = parameters.get("SrcMask")
327 raise RuntimeError("No SrcMask was found for classifier %d" % guid)
328 src_mask = testbed_instance.ns3.Ipv4Mask(src_mask)
329 dst_address = parameters.get("DstAddress")
330 if dst_address == None:
331 raise RuntimeError("No Dstddress was found for classifier %d" % guid)
332 dst_address = testbed_instance.ns3.Ipv4Address(dst_address)
333 dst_mask = parameters.get("DstMask")
335 raise RuntimeError("No DstMask was found for classifier %d" % guid)
336 dst_mask = testbed_instance.ns3.Ipv4Mask(dst_mask)
337 src_port_low = parameters.get("SrcPortLow")
338 if src_port_low == None:
339 raise RuntimeError("No SrcPortLow was found for classifier %d" % guid)
340 src_port_high = parameters.get("SrcPortHigh")
341 if src_port_high == None:
342 raise RuntimeError("No SrcPortHigh was found for classifier %d" % guid)
343 dst_port_low = parameters.get("DstPortLow")
344 if dst_port_low == None:
345 raise RuntimeError("No DstPortLow was found for classifier %d" % guid)
346 dst_port_high = parameters.get("DstPortHigh")
347 if dst_port_high == None:
348 raise RuntimeError("No DstPortHigh was found for classifier %d" % guid)
349 protocol = parameters.get("Protocol")
350 if protocol == None or protocol not in l4_protocols:
351 raise RuntimeError("No Protocol was found for classifier %d" % guid)
352 priority = parameters.get("Priority")
354 raise RuntimeError("No Priority was found for classifier %d" % guid)
355 element = testbed_instance.ns3.IpcsClassifierRecord(src_address, src_mask,
356 dst_address, dst_mask, src_port_low, src_port_high, dst_port_low,
357 dst_port_high, l4_protocols[protocol], priority)
358 testbed_instance._elements[guid] = element
360 ### Start/Stop functions ###
362 def start_application(testbed_instance, guid):
363 element = testbed_instance.elements[guid]
364 # BUG: without doing this explicit call it doesn't start!!!
365 # Shouldn't be enough to set the StartTime?
368 def stop_application(testbed_instance, guid):
369 element = testbed_instance.elements[guid]
370 now = testbed_instance.ns3.Simulator.Now()
371 element.SetStopTime(now)
373 ### Status functions ###
375 def status_application(testbed_instance, guid):
376 if guid not in testbed_instance.elements.keys():
377 raise RuntimeError("Can't get status on guid %d" % guid )
378 now = testbed_instance.ns3.Simulator.Now()
380 return AS.STATUS_NOT_STARTED
381 app = testbed_instance.elements[guid]
382 parameters = testbed_instance._get_parameters(guid)
383 start_value = parameters.get("StartTime")
384 if start_value != None:
385 start_time = testbed_instance.ns3.Time(start_value)
386 if now.Compare(start_time) < 0:
387 return AS.STATUS_NOT_STARTED
388 stop_value = parameters.get("StopTime")
389 if stop_value != None:
390 stop_time = testbed_instance.ns3.Time(stop_value)
391 if now.Compare(stop_time) < 0:
392 return AS.STATUS_RUNNING
394 return AS.STATUS_FINISHED
395 return AS.STATUS_UNDETERMINED
397 ### Configure functions ###
399 def configure_traces(testbed_instance, guid):
400 traces = testbed_instance._get_traces(guid)
401 for trace_id in traces:
402 trace_func = trace_functions[trace_id]
403 trace_func(testbed_instance, guid, trace_id)
405 def configure_element(testbed_instance, guid):
406 configure_traces(testbed_instance, guid)
408 def configure_device(testbed_instance, guid):
409 configure_traces(testbed_instance, guid)
410 element = testbed_instance._elements[guid]
412 parameters = testbed_instance._get_parameters(guid)
413 address = parameters.get("macAddress")
415 macaddr = testbed_instance.ns3.Mac48Address(address)
417 macaddr = testbed_instance.ns3.Mac48Address.Allocate()
418 element.SetAddress(macaddr)
420 if not guid in testbed_instance._add_address:
422 # search for the node asociated with the device
423 node_guid = _get_node_guid(testbed_instance, guid)
424 node = testbed_instance.elements[node_guid]
425 # search for the Ipv4L3Protocol asociated with the device
426 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
427 ipv4 = testbed_instance._elements[ipv4_guid]
428 ns3 = testbed_instance.ns3
430 addresses = testbed_instance._add_address[guid]
431 for address in addresses:
432 (address, netprefix, broadcast) = address
433 # TODO: missing IPV6 addresses!!
434 ifindex = ipv4.AddInterface(element)
435 inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
436 ns3.Ipv4Mask("/%d" % netprefix))
437 ipv4.AddAddress(ifindex, inaddr)
438 ipv4.SetMetric(ifindex, 1)
441 def _add_static_route(ns3, static_routing,
442 address, netprefix, nexthop_address, ifindex):
444 # Default route: 0.0.0.0/0
445 static_routing.SetDefaultRoute(nexthop_address, ifindex)
446 elif netprefix == 32:
447 # Host route: x.y.z.w/32
448 static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
450 # Network route: x.y.z.w/n
451 mask = ns3.Ipv4Mask("/%d" % netprefix)
452 static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
455 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
457 # Default route: 0.0.0.0/0
458 static_routing.SetDefaultRoute(ifindex)
459 elif netprefix == 32:
460 # Host route: x.y.z.w/32
461 static_routing.AddHostRouteTo(address, ifindex)
463 # Network route: x.y.z.w/n
464 mask = ns3.Ipv4Mask("/%d" % netprefix)
465 static_routing.AddNetworkRouteTo(address, mask, ifindex)
467 def configure_node(testbed_instance, guid):
468 configure_traces(testbed_instance, guid)
470 element = testbed_instance._elements[guid]
471 if not guid in testbed_instance._add_route:
473 # search for the Ipv4L3Protocol asociated with the device
474 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
475 ipv4 = testbed_instance._elements[ipv4_guid]
476 list_routing = ipv4.GetRoutingProtocol()
477 (static_routing, priority) = list_routing.GetRoutingProtocol(0)
478 ns3 = testbed_instance.ns3
479 routes = testbed_instance._add_route[guid]
481 (destination, netprefix, nexthop, metric) = route
482 address = ns3.Ipv4Address(destination)
484 nexthop_address = ns3.Ipv4Address(nexthop)
486 # TODO: HACKISH way of getting the ifindex... improve this
487 nifaces = ipv4.GetNInterfaces()
488 for ifidx in xrange(nifaces):
489 iface = ipv4.GetInterface(ifidx)
490 naddress = iface.GetNAddresses()
491 for addridx in xrange(naddress):
492 ifaddr = iface.GetAddress(addridx)
493 ifmask = ifaddr.GetMask()
494 ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
500 # Check previous ptp routes
501 for chaindest, chainprefix, chainhop, metric in routes:
502 if chaindest == nexthop and chainprefix == 32:
503 chainhop_address = ns3.Ipv4Address(chainhop)
504 for ifidx in xrange(nifaces):
505 iface = ipv4.GetInterface(ifidx)
506 naddress = iface.GetNAddresses()
507 for addridx in xrange(naddress):
508 ifaddr = iface.GetAddress(addridx)
509 ifmask = ifaddr.GetMask()
510 ifindex = ipv4.GetInterfaceForPrefix(chainhop_address, ifmask)
514 raise RuntimeError, "Cannot associate interface for routing entry:" \
515 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
516 _add_static_route(ns3, static_routing,
517 address, netprefix, nexthop_address, ifindex)
519 mask = ns3.Ipv4Mask("/%d" % netprefix)
520 ifindex = ipv4.GetInterfaceForPrefix(address, mask)
522 raise RuntimeError, "Cannot associate interface for routing entry:" \
523 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
524 _add_static_route_if(ns3, static_routing,
525 address, netprefix, nexthop_address, ifindex)
527 def configure_station(testbed_instance, guid):
528 configure_device(testbed_instance, guid)
529 element = testbed_instance._elements[guid]
534 factories_create_order = ["ns3::BasicEnergySource",
535 "ns3::WifiRadioEnergyModel",
536 "ns3::BSSchedulerRtps",
537 "ns3::BSSchedulerSimple",
538 "ns3::UdpTraceClient",
544 "ns3::flame::FlameProtocol",
545 "ns3::flame::FlameRtable",
546 "ns3::dot11s::AirtimeLinkMetricCalculator",
547 "ns3::dot11s::HwmpProtocol",
548 "ns3::dot11s::HwmpRtable",
549 "ns3::dot11s::PeerManagementProtocol",
550 "ns3::dot11s::PeerLink",
551 "ns3::MeshWifiInterfaceMac",
552 "ns3::MeshPointDevice",
555 "ns3::UanPhyCalcSinrDual",
556 "ns3::UanPhyPerGenDefault",
558 "ns3::UanPropModelThorp",
560 "ns3::UanNoiseModelDefault",
562 "ns3::UanPropModelIdeal",
563 "ns3::UanTransducerHd",
564 "ns3::UanPhyCalcSinrDefault",
566 "ns3::UanPhyCalcSinrFhFsk",
567 "ns3::UanPhyPerUmodem",
570 "ns3::AthstatsWifiTraceSink",
573 "ns3::NonCommunicatingNetDevice",
574 "ns3::HalfDuplexIdealPhy",
575 "ns3::AlohaNoackNetDevice",
576 "ns3::SpectrumAnalyzer",
577 "ns3::WaveformGenerator",
578 "ns3::MultiModelSpectrumChannel",
579 "ns3::SingleModelSpectrumChannel",
580 "ns3::MsduStandardAggregator",
584 "ns3::QadhocWifiMac",
585 "ns3::MinstrelWifiManager",
586 "ns3::CaraWifiManager",
587 "ns3::AarfcdWifiManager",
588 "ns3::OnoeWifiManager",
589 "ns3::AmrrWifiManager",
590 "ns3::ConstantRateWifiManager",
591 "ns3::IdealWifiManager",
592 "ns3::AarfWifiManager",
593 "ns3::ArfWifiManager",
594 "ns3::WifiNetDevice",
598 "ns3::YansWifiChannel",
600 "ns3::NistErrorRateModel",
601 "ns3::YansErrorRateModel",
602 "ns3::WaypointMobilityModel",
603 "ns3::ConstantAccelerationMobilityModel",
604 "ns3::RandomDirection2dMobilityModel",
605 "ns3::RandomWalk2dMobilityModel",
606 "ns3::SteadyStateRandomWaypointMobilityModel",
607 "ns3::RandomWaypointMobilityModel",
608 "ns3::GaussMarkovMobilityModel",
609 "ns3::ConstantVelocityMobilityModel",
610 "ns3::ConstantPositionMobilityModel",
611 "ns3::ListPositionAllocator",
612 "ns3::GridPositionAllocator",
613 "ns3::RandomRectanglePositionAllocator",
614 "ns3::RandomBoxPositionAllocator",
615 "ns3::RandomDiscPositionAllocator",
616 "ns3::UniformDiscPositionAllocator",
617 "ns3::HierarchicalMobilityModel",
618 "ns3::aodv::RoutingProtocol",
619 "ns3::UdpEchoServer",
620 "ns3::UdpEchoClient",
622 "ns3::OnOffApplication",
623 "ns3::VirtualNetDevice",
625 "ns3::Nepi::TunChannel",
627 "ns3::BridgeChannel",
628 "ns3::BridgeNetDevice",
631 "ns3::CsmaNetDevice",
632 "ns3::PointToPointRemoteChannel",
633 "ns3::PointToPointChannel",
634 "ns3::PointToPointNetDevice",
635 "ns3::NscTcpL4Protocol",
636 "ns3::Icmpv6L4Protocol",
637 "ns3::Ipv6OptionPad1",
638 "ns3::Ipv6OptionPadn",
639 "ns3::Ipv6OptionJumbogram",
640 "ns3::Ipv6OptionRouterAlert",
641 "ns3::Ipv6ExtensionHopByHop",
642 "ns3::Ipv6ExtensionDestination",
643 "ns3::Ipv6ExtensionFragment",
644 "ns3::Ipv6ExtensionRouting",
645 "ns3::Ipv6ExtensionLooseRouting",
646 "ns3::Ipv6ExtensionESP",
647 "ns3::Ipv6ExtensionAH",
648 "ns3::Ipv6L3Protocol",
649 "ns3::LoopbackNetDevice",
650 "ns3::Icmpv4L4Protocol",
651 "ns3::RttMeanDeviation",
652 "ns3::ArpL3Protocol",
653 "ns3::TcpL4Protocol",
654 "ns3::UdpL4Protocol",
655 "ns3::Ipv4L3Protocol",
656 "ns3::SimpleNetDevice",
657 "ns3::SimpleChannel",
659 "ns3::DropTailQueue",
661 "ns3::FriisSpectrumPropagationLossModel",
662 "ns3::Cost231PropagationLossModel",
663 "ns3::JakesPropagationLossModel",
664 "ns3::RandomPropagationLossModel",
665 "ns3::FriisPropagationLossModel",
666 "ns3::TwoRayGroundPropagationLossModel",
667 "ns3::LogDistancePropagationLossModel",
668 "ns3::ThreeLogDistancePropagationLossModel",
669 "ns3::NakagamiPropagationLossModel",
670 "ns3::FixedRssLossModel",
671 "ns3::MatrixPropagationLossModel",
672 "ns3::RangePropagationLossModel",
673 "ns3::RandomPropagationDelayModel",
674 "ns3::ConstantSpeedPropagationDelayModel",
675 "ns3::RateErrorModel",
676 "ns3::ListErrorModel",
677 "ns3::ReceiveListErrorModel",
679 "ns3::EnergySourceContainer",
680 "ns3::BSSchedulerRtps",
681 "ns3::BSSchedulerSimple",
682 "ns3::SimpleOfdmWimaxChannel",
683 "ns3::SimpleOfdmWimaxPhy",
684 "ns3::UplinkSchedulerMBQoS",
685 "ns3::UplinkSchedulerRtps",
686 "ns3::UplinkSchedulerSimple",
687 "ns3::IpcsClassifierRecord",
689 "ns3::BaseStationNetDevice",
690 "ns3::SubscriberStationNetDevice",
693 factories_configure_order = ["ns3::BasicEnergySource",
694 "ns3::WifiRadioEnergyModel",
695 "ns3::BSSchedulerRtps",
696 "ns3::BSSchedulerSimple",
697 "ns3::UdpTraceClient",
703 "ns3::flame::FlameProtocol",
704 "ns3::flame::FlameRtable",
705 "ns3::dot11s::AirtimeLinkMetricCalculator",
706 "ns3::dot11s::HwmpProtocol",
707 "ns3::dot11s::HwmpRtable",
708 "ns3::dot11s::PeerManagementProtocol",
709 "ns3::dot11s::PeerLink",
710 "ns3::MeshWifiInterfaceMac",
711 "ns3::MeshPointDevice",
714 "ns3::UanPhyCalcSinrDual",
715 "ns3::UanPhyPerGenDefault",
717 "ns3::UanPropModelThorp",
719 "ns3::UanNoiseModelDefault",
721 "ns3::UanPropModelIdeal",
722 "ns3::UanTransducerHd",
723 "ns3::UanPhyCalcSinrDefault",
725 "ns3::UanPhyCalcSinrFhFsk",
726 "ns3::UanPhyPerUmodem",
729 "ns3::AthstatsWifiTraceSink",
732 "ns3::NonCommunicatingNetDevice",
733 "ns3::HalfDuplexIdealPhy",
734 "ns3::AlohaNoackNetDevice",
735 "ns3::SpectrumAnalyzer",
736 "ns3::WaveformGenerator",
737 "ns3::MultiModelSpectrumChannel",
738 "ns3::SingleModelSpectrumChannel",
739 "ns3::MsduStandardAggregator",
743 "ns3::QadhocWifiMac",
744 "ns3::MinstrelWifiManager",
745 "ns3::CaraWifiManager",
746 "ns3::AarfcdWifiManager",
747 "ns3::OnoeWifiManager",
748 "ns3::AmrrWifiManager",
749 "ns3::ConstantRateWifiManager",
750 "ns3::IdealWifiManager",
751 "ns3::AarfWifiManager",
752 "ns3::ArfWifiManager",
753 "ns3::WifiNetDevice",
757 "ns3::YansWifiChannel",
759 "ns3::NistErrorRateModel",
760 "ns3::YansErrorRateModel",
761 "ns3::WaypointMobilityModel",
762 "ns3::ConstantAccelerationMobilityModel",
763 "ns3::RandomDirection2dMobilityModel",
764 "ns3::RandomWalk2dMobilityModel",
765 "ns3::SteadyStateRandomWaypointMobilityModel",
766 "ns3::RandomWaypointMobilityModel",
767 "ns3::GaussMarkovMobilityModel",
768 "ns3::ConstantVelocityMobilityModel",
769 "ns3::ConstantPositionMobilityModel",
770 "ns3::ListPositionAllocator",
771 "ns3::GridPositionAllocator",
772 "ns3::RandomRectanglePositionAllocator",
773 "ns3::RandomBoxPositionAllocator",
774 "ns3::RandomDiscPositionAllocator",
775 "ns3::UniformDiscPositionAllocator",
776 "ns3::HierarchicalMobilityModel",
777 "ns3::aodv::RoutingProtocol",
778 "ns3::UdpEchoServer",
779 "ns3::UdpEchoClient",
781 "ns3::OnOffApplication",
782 "ns3::VirtualNetDevice",
784 "ns3::Nepi::TunChannel",
786 "ns3::BridgeChannel",
787 "ns3::BridgeNetDevice",
790 "ns3::CsmaNetDevice",
791 "ns3::PointToPointRemoteChannel",
792 "ns3::PointToPointChannel",
793 "ns3::PointToPointNetDevice",
794 "ns3::BaseStationNetDevice",
795 "ns3::SubscriberStationNetDevice",
796 "ns3::NscTcpL4Protocol",
797 "ns3::Icmpv6L4Protocol",
798 "ns3::Ipv6OptionPad1",
799 "ns3::Ipv6OptionPadn",
800 "ns3::Ipv6OptionJumbogram",
801 "ns3::Ipv6OptionRouterAlert",
802 "ns3::Ipv6ExtensionHopByHop",
803 "ns3::Ipv6ExtensionDestination",
804 "ns3::Ipv6ExtensionFragment",
805 "ns3::Ipv6ExtensionRouting",
806 "ns3::Ipv6ExtensionLooseRouting",
807 "ns3::Ipv6ExtensionESP",
808 "ns3::Ipv6ExtensionAH",
809 "ns3::Ipv6L3Protocol",
810 "ns3::LoopbackNetDevice",
811 "ns3::Icmpv4L4Protocol",
812 "ns3::RttMeanDeviation",
813 "ns3::ArpL3Protocol",
814 "ns3::TcpL4Protocol",
815 "ns3::UdpL4Protocol",
816 "ns3::Ipv4L3Protocol",
817 "ns3::SimpleNetDevice",
818 "ns3::SimpleChannel",
820 "ns3::DropTailQueue",
822 "ns3::FriisSpectrumPropagationLossModel",
823 "ns3::Cost231PropagationLossModel",
824 "ns3::JakesPropagationLossModel",
825 "ns3::RandomPropagationLossModel",
826 "ns3::FriisPropagationLossModel",
827 "ns3::TwoRayGroundPropagationLossModel",
828 "ns3::LogDistancePropagationLossModel",
829 "ns3::ThreeLogDistancePropagationLossModel",
830 "ns3::NakagamiPropagationLossModel",
831 "ns3::FixedRssLossModel",
832 "ns3::MatrixPropagationLossModel",
833 "ns3::RangePropagationLossModel",
834 "ns3::RandomPropagationDelayModel",
835 "ns3::ConstantSpeedPropagationDelayModel",
836 "ns3::RateErrorModel",
837 "ns3::ListErrorModel",
838 "ns3::ReceiveListErrorModel",
840 "ns3::EnergySourceContainer",
841 "ns3::BSSchedulerRtps",
842 "ns3::BSSchedulerSimple",
843 "ns3::SimpleOfdmWimaxChannel",
844 "ns3::SimpleOfdmWimaxPhy",
845 "ns3::UplinkSchedulerMBQoS",
846 "ns3::UplinkSchedulerRtps",
847 "ns3::UplinkSchedulerSimple",
848 "ns3::IpcsClassifierRecord",
853 factories_info = dict({
855 "category": FC.CATEGORY_APPLICATIONS,
856 "create_function": create_element,
857 "configure_function": configure_element,
858 "stop_function": stop_application,
859 "start_function": start_application,
860 "status_function": status_application,
862 "connector_types": [],
863 "box_attributes": ["MaxPackets",
870 "tags": [tags.APPLICATION],
872 "ns3::UdpL4Protocol": dict({
873 "category": FC.CATEGORY_PROTOCOLS,
874 "create_function": create_element,
875 "configure_function": configure_element,
877 "connector_types": ["node"],
878 "box_attributes": ["ProtocolNumber"],
879 "tags": [tags.PROTOCOL],
881 "ns3::RandomDiscPositionAllocator": dict({
882 "category": FC.CATEGORY_MOBILITY_MODELS,
883 "create_function": create_element,
884 "configure_function": configure_element,
886 "connector_types": [],
887 "box_attributes": ["Theta",
891 "tags": [tags.MOBILE],
894 "category": FC.CATEGORY_NODES,
895 "create_function": create_node,
896 "configure_function": configure_node,
898 "connector_types": ["devs", "apps", "protos", "mobility"],
899 "tags": [tags.NODE, tags.ALLOW_ROUTES],
901 "ns3::GridPositionAllocator": dict({
902 "category": FC.CATEGORY_MOBILITY_MODELS,
903 "create_function": create_element,
904 "configure_function": configure_element,
906 "connector_types": [],
907 "box_attributes": ["GridWidth",
914 "ns3::TapBridge": dict({
915 "category": FC.CATEGORY_DEVICES,
916 "create_function": create_element,
917 "configure_function": configure_element,
919 "connector_types": [],
920 "box_attributes": ["Mtu",
928 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
930 "ns3::FlowMonitor": dict({
931 "category": FC.CATEGORY_SERVICE_FLOWS,
932 "create_function": create_element,
933 "configure_function": configure_element,
935 "connector_types": [],
936 "box_attributes": ["MaxPerHopDelay",
939 "PacketSizeBinWidth",
940 "FlowInterruptionsBinWidth",
941 "FlowInterruptionsMinTime"],
943 "ns3::ConstantVelocityMobilityModel": dict({
944 "category": FC.CATEGORY_MOBILITY_MODELS,
945 "create_function": create_element,
946 "configure_function": configure_element,
948 "connector_types": ["node"],
949 "box_attributes": ["Position",
951 "tags": [tags.MOBILE],
953 "ns3::V4Ping": dict({
954 "category": FC.CATEGORY_APPLICATIONS,
955 "create_function": create_element,
956 "configure_function": configure_element,
958 "connector_types": ["node"],
959 "stop_function": stop_application,
960 "start_function": start_application,
961 "status_function": status_application,
962 "box_attributes": ["Remote",
969 "tags": [tags.APPLICATION],
971 "ns3::dot11s::PeerLink": dict({
973 "create_function": create_element,
974 "configure_function": configure_element,
976 "connector_types": [],
977 "box_attributes": ["RetryTimeout",
984 "ns3::PointToPointNetDevice": dict({
985 "category": FC.CATEGORY_DEVICES,
986 "create_function": create_element,
987 "configure_function": configure_device,
989 "connector_types": ["node", "err", "queue", "chan"],
990 "box_attributes": ["Mtu",
994 "traces": ["p2ppcap", "p2pascii"],
995 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
997 "ns3::NakagamiPropagationLossModel": dict({
998 "category": FC.CATEGORY_LOSS_MODELS,
999 "create_function": create_element,
1000 "configure_function": configure_element,
1002 "connector_types": [],
1003 "box_attributes": ["Distance1",
1009 "ns3::AarfWifiManager": dict({
1010 "category": FC.CATEGORY_MANAGERS,
1011 "create_function": create_element,
1012 "configure_function": configure_element,
1014 "connector_types": ["dev"],
1015 "box_attributes": ["SuccessK",
1017 "MaxSuccessThreshold",
1018 "MinTimerThreshold",
1019 "MinSuccessThreshold",
1024 "FragmentationThreshold",
1027 "ns3::Ipv6OptionJumbogram": dict({
1029 "create_function": create_element,
1030 "configure_function": configure_element,
1032 "connector_types": [],
1033 "box_attributes": ["OptionNumber"],
1035 "ns3::TwoRayGroundPropagationLossModel": dict({
1036 "category": FC.CATEGORY_LOSS_MODELS,
1037 "create_function": create_element,
1038 "configure_function": configure_element,
1040 "connector_types": [],
1041 "box_attributes": ["Lambda",
1046 "ns3::OnOffApplication": dict({
1047 "category": FC.CATEGORY_APPLICATIONS,
1048 "create_function": create_element,
1049 "configure_function": configure_element,
1051 "connector_types": ["node"],
1052 "stop_function": stop_application,
1053 "start_function": start_application,
1054 "status_function": status_application,
1055 "box_attributes": ["DataRate",
1064 "tags": [tags.APPLICATION],
1066 "ns3::AdhocWifiMac": dict({
1067 "category": FC.CATEGORY_MAC_MODELS,
1068 "create_function": create_element,
1069 "configure_function": configure_element,
1071 "connector_types": [],
1072 "box_attributes": ["CtsTimeout",
1074 "BasicBlockAckTimeout",
1075 "CompressedBlockAckTimeout",
1080 "MaxPropagationDelay",
1083 "ns3::ConstantAccelerationMobilityModel": dict({
1084 "category": FC.CATEGORY_MOBILITY_MODELS,
1085 "create_function": create_element,
1086 "configure_function": configure_element,
1088 "connector_types": ["node"],
1089 "box_attributes": ["Position",
1091 "tags": [tags.MOBILE],
1093 "ns3::GaussMarkovMobilityModel": dict({
1094 "category": FC.CATEGORY_MOBILITY_MODELS,
1095 "create_function": create_element,
1096 "configure_function": configure_element,
1098 "connector_types": [],
1099 "box_attributes": ["Bounds",
1110 "tags": [tags.MOBILE],
1112 "ns3::dot11s::HwmpProtocol": dict({
1113 "category": FC.CATEGORY_PROTOCOLS,
1114 "create_function": create_element,
1115 "configure_function": configure_element,
1117 "connector_types": [],
1118 "box_attributes": ["RandomStart",
1120 "Dot11MeshHWMPmaxPREQretries",
1121 "Dot11MeshHWMPnetDiameterTraversalTime",
1122 "Dot11MeshHWMPpreqMinInterval",
1123 "Dot11MeshHWMPperrMinInterval",
1124 "Dot11MeshHWMPactiveRootTimeout",
1125 "Dot11MeshHWMPactivePathTimeout",
1126 "Dot11MeshHWMPpathToRootInterval",
1127 "Dot11MeshHWMPrannInterval",
1129 "UnicastPerrThreshold",
1130 "UnicastPreqThreshold",
1131 "UnicastDataThreshold",
1135 "ns3::NscTcpL4Protocol": dict({
1136 "category": FC.CATEGORY_PROTOCOLS,
1137 "create_function": create_element,
1138 "configure_function": configure_element,
1140 "connector_types": [],
1141 "box_attributes": ["Library",
1144 "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
1146 "create_function": create_element,
1147 "configure_function": configure_element,
1149 "connector_types": [],
1150 "box_attributes": ["Dot11sMeshHeaderLength"],
1152 "ns3::UanMacCw": dict({
1154 "create_function": create_element,
1155 "configure_function": configure_element,
1157 "connector_types": [],
1158 "box_attributes": ["CW",
1161 "ns3::AthstatsWifiTraceSink": dict({
1163 "create_function": create_element,
1164 "configure_function": configure_element,
1166 "connector_types": [],
1167 "box_attributes": ["Interval"],
1169 "ns3::FlameStack": dict({
1171 "create_function": create_element,
1172 "configure_function": configure_element,
1174 "connector_types": [],
1175 "box_attributes": [],
1177 "ns3::UanMacRc": dict({
1179 "create_function": create_element,
1180 "configure_function": configure_element,
1182 "connector_types": [],
1183 "box_attributes": ["RetryRate",
1190 "NumberOfRetryRates",
1193 "ns3::WaypointMobilityModel": dict({
1194 "category": FC.CATEGORY_MOBILITY_MODELS,
1195 "create_function": create_waypoint_mobility,
1196 "configure_function": configure_element,
1197 "help": "Waypoint-based mobility model.",
1198 "connector_types": ["node"],
1199 "box_attributes": ["WaypointsLeft",
1203 "tags": [tags.MOBILE],
1205 "ns3::FdNetDevice": dict({
1206 "category": FC.CATEGORY_DEVICES,
1207 "create_function": create_element,
1208 "configure_function": configure_device,
1209 "help": "Network interface associated to a file descriptor",
1210 "connector_types": ["node", "->fd"],
1211 "box_attributes": ["Address",
1212 "tun_proto", "tun_addr", "tun_port", "tun_key", "tun_cipher_fdnd"],
1213 "traces": ["fdpcap", "fdascii"],
1214 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1216 "ns3::Nepi::TunChannel": dict({
1217 "category": FC.CATEGORY_TUNNELS,
1218 "create_function": create_tunchannel,
1219 "preconfigure_function": preconfigure_tunchannel,
1220 "configure_function": postconfigure_tunchannel,
1221 "prestart_function": prestart_tunchannel,
1222 "help": "Channel to forward FdNetDevice data to "
1223 "other TAP interfaces supporting the NEPI tunneling protocol.",
1224 "connector_types": ["fd->", "udp", "tcp"],
1225 "allow_addresses": False,
1226 "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key","tun_cipher"],
1227 "tags": [tags.TUNNEL],
1230 "ns3::CsmaNetDevice": dict({
1231 "category": FC.CATEGORY_DEVICES,
1232 "create_function": create_element,
1233 "configure_function": configure_device,
1234 "help": "CSMA (carrier sense, multiple access) interface",
1235 "connector_types": ["node", "chan", "err", "queue"],
1236 "box_attributes": ["Address",
1240 "traces": ["csmapcap", "csmapcap_promisc"],
1241 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1243 "ns3::UanPropModelThorp": dict({
1245 "create_function": create_element,
1246 "configure_function": configure_element,
1248 "connector_types": [],
1249 "box_attributes": ["SpreadCoef"],
1251 "ns3::Icmpv6L4Protocol": dict({
1252 "category": FC.CATEGORY_PROTOCOLS,
1253 "create_function": create_element,
1254 "configure_function": configure_element,
1256 "connector_types": ["node"],
1257 "box_attributes": ["DAD",
1260 "ns3::SimpleNetDevice": dict({
1261 "category": FC.CATEGORY_DEVICES,
1262 "create_function": create_element,
1263 "configure_function": configure_element,
1265 "connector_types": ["node", "chan"],
1266 "box_attributes": [],
1267 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1269 "ns3::FriisPropagationLossModel": dict({
1270 "category": FC.CATEGORY_LOSS_MODELS,
1271 "create_function": create_element,
1272 "configure_function": configure_element,
1274 "connector_types": [],
1275 "box_attributes": ["Lambda",
1279 "ns3::Ipv6OptionRouterAlert": dict({
1281 "create_function": create_element,
1282 "configure_function": configure_element,
1284 "connector_types": [],
1285 "box_attributes": ["OptionNumber"],
1287 "ns3::UniformDiscPositionAllocator": dict({
1288 "category": FC.CATEGORY_MOBILITY_MODELS,
1289 "create_function": create_element,
1290 "configure_function": configure_element,
1292 "connector_types": [],
1293 "box_attributes": ["rho",
1296 "tags": [tags.MOBILE],
1298 "ns3::RandomBoxPositionAllocator": dict({
1299 "category": FC.CATEGORY_MOBILITY_MODELS,
1300 "create_function": create_element,
1301 "configure_function": configure_element,
1303 "connector_types": [],
1304 "box_attributes": ["X",
1307 "tags": [tags.MOBILE],
1309 "ns3::Ipv6ExtensionDestination": dict({
1311 "create_function": create_element,
1312 "configure_function": configure_element,
1314 "connector_types": [],
1315 "box_attributes": ["ExtensionNumber"],
1317 "ns3::LoopbackNetDevice": dict({
1318 "category": FC.CATEGORY_DEVICES,
1319 "create_function": create_element,
1320 "configure_function": configure_element,
1322 "connector_types": [],
1323 "box_attributes": [],
1324 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1326 "ns3::ConstantSpeedPropagationDelayModel": dict({
1327 "category": FC.CATEGORY_DELAY_MODELS,
1328 "create_function": create_element,
1329 "configure_function": configure_element,
1331 "connector_types": ["chan"],
1332 "box_attributes": ["Speed"],
1334 "ns3::Ipv6ExtensionHopByHop": dict({
1336 "create_function": create_element,
1337 "configure_function": configure_element,
1339 "connector_types": [],
1340 "box_attributes": ["ExtensionNumber"],
1342 "ns3::BridgeChannel": dict({
1343 "category": FC.CATEGORY_CHANNELS,
1344 "create_function": create_element,
1345 "configure_function": configure_element,
1347 "connector_types": [],
1348 "box_attributes": [],
1350 "ns3::Radvd": dict({
1352 "create_function": create_element,
1353 "configure_function": configure_element,
1355 "connector_types": [],
1356 "box_attributes": ["StartTime",
1359 "ns3::PacketSocket": dict({
1361 "create_function": create_element,
1362 "configure_function": configure_element,
1364 "connector_types": [],
1365 "box_attributes": ["RcvBufSize"],
1367 "ns3::flame::FlameProtocol": dict({
1368 "category": FC.CATEGORY_PROTOCOLS,
1369 "create_function": create_element,
1370 "configure_function": configure_element,
1372 "connector_types": [],
1373 "box_attributes": ["BroadcastInterval",
1376 "ns3::Cost231PropagationLossModel": dict({
1377 "category": FC.CATEGORY_LOSS_MODELS,
1378 "create_function": create_element,
1379 "configure_function": configure_element,
1381 "connector_types": [],
1382 "box_attributes": ["Lambda",
1388 "ns3::Ipv6ExtensionESP": dict({
1390 "create_function": create_element,
1391 "configure_function": configure_element,
1393 "connector_types": [],
1394 "box_attributes": ["ExtensionNumber"],
1396 "ns3::CaraWifiManager": dict({
1397 "category": FC.CATEGORY_MANAGERS,
1398 "create_function": create_element,
1399 "configure_function": configure_element,
1401 "connector_types": ["dev"],
1402 "box_attributes": ["ProbeThreshold",
1410 "FragmentationThreshold",
1414 "ns3::RttMeanDeviation": dict({
1416 "create_function": create_element,
1417 "configure_function": configure_element,
1419 "connector_types": [],
1420 "box_attributes": ["Gain",
1422 "InitialEstimation",
1425 "ns3::Icmpv4L4Protocol": dict({
1426 "category": FC.CATEGORY_PROTOCOLS,
1427 "create_function": create_element,
1428 "configure_function": configure_element,
1430 "connector_types": ["node"],
1431 "box_attributes": ["ProtocolNumber"],
1433 "ns3::WaveformGenerator": dict({
1435 "create_function": create_element,
1436 "configure_function": configure_element,
1438 "connector_types": [],
1439 "box_attributes": ["Period",
1442 "ns3::YansWifiChannel": dict({
1443 "category": FC.CATEGORY_CHANNELS,
1444 "create_function": create_element,
1445 "configure_function": configure_element,
1447 "connector_types": ["phys", "delay", "loss"],
1448 "box_attributes": [],
1450 "ns3::SimpleChannel": dict({
1451 "category": FC.CATEGORY_CHANNELS,
1452 "create_function": create_element,
1453 "configure_function": configure_element,
1455 "connector_types": ["devs"],
1456 "box_attributes": [],
1458 "ns3::Ipv6ExtensionFragment": dict({
1460 "create_function": create_element,
1461 "configure_function": configure_element,
1463 "connector_types": [],
1464 "box_attributes": ["ExtensionNumber"],
1466 "ns3::Dot11sStack": dict({
1468 "create_function": create_element,
1469 "configure_function": configure_element,
1471 "connector_types": [],
1472 "box_attributes": ["Root"],
1474 "ns3::FriisSpectrumPropagationLossModel": dict({
1475 "category": FC.CATEGORY_LOSS_MODELS,
1476 "create_function": create_element,
1477 "configure_function": configure_element,
1479 "connector_types": [],
1480 "box_attributes": [],
1482 "ns3::RandomRectanglePositionAllocator": dict({
1483 "category": FC.CATEGORY_MOBILITY_MODELS,
1484 "create_function": create_element,
1485 "configure_function": configure_element,
1487 "connector_types": [],
1488 "box_attributes": ["X",
1490 "tags": [tags.MOBILE],
1492 "ns3::HierarchicalMobilityModel": dict({
1493 "category": FC.CATEGORY_MOBILITY_MODELS,
1494 "create_function": create_element,
1495 "configure_function": configure_element,
1497 "connector_types": ["node"],
1498 "box_attributes": ["Position",
1500 "tags": [tags.MOBILE],
1502 "ns3::ThreeLogDistancePropagationLossModel": dict({
1503 "category": FC.CATEGORY_LOSS_MODELS,
1504 "create_function": create_element,
1505 "configure_function": configure_element,
1507 "connector_types": [],
1508 "box_attributes": ["Distance0",
1516 "ns3::UanNoiseModelDefault": dict({
1518 "create_function": create_element,
1519 "configure_function": configure_element,
1521 "connector_types": [],
1522 "box_attributes": ["Wind",
1525 "ns3::dot11s::HwmpRtable": dict({
1527 "create_function": create_element,
1528 "configure_function": configure_element,
1530 "connector_types": [],
1531 "box_attributes": [],
1533 "ns3::PacketBurst": dict({
1535 "create_function": create_element,
1536 "configure_function": configure_element,
1538 "connector_types": [],
1539 "box_attributes": [],
1541 "ns3::RandomPropagationDelayModel": dict({
1542 "category": FC.CATEGORY_DELAY_MODELS,
1543 "create_function": create_element,
1544 "configure_function": configure_element,
1546 "connector_types": [],
1547 "box_attributes": ["Variable"],
1549 "ns3::ArpL3Protocol": dict({
1550 "category": FC.CATEGORY_PROTOCOLS,
1551 "create_function": create_element,
1552 "configure_function": configure_element,
1554 "connector_types": ["node"],
1555 "box_attributes": [],
1557 "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1558 "category": FC.CATEGORY_MOBILITY_MODELS,
1559 "create_function": create_element,
1560 "configure_function": configure_element,
1562 "connector_types": [],
1563 "box_attributes": ["MinSpeed",
1573 "tags": [tags.MOBILE],
1575 "ns3::BaseStationNetDevice": dict({
1576 "category": FC.CATEGORY_DEVICES,
1577 "create_function": create_base_station,
1578 "configure_function": configure_station,
1579 "help": "Base station for wireless mobile network",
1580 "connector_types": ["node", "chan", "phy", "uplnk", "dwnlnk"],
1581 "box_attributes": ["InitialRangInterval",
1587 "MaxRangCorrectionRetries",
1591 "traces": ["wimaxpcap", "wimaxascii"],
1592 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1594 "ns3::UdpServer": dict({
1595 "category": FC.CATEGORY_APPLICATIONS,
1596 "create_function": create_element,
1597 "configure_function": configure_element,
1599 "connector_types": ["node"],
1600 "stop_function": stop_application,
1601 "start_function": start_application,
1602 "status_function": status_application,
1603 "box_attributes": ["Port",
1608 "ns3::AarfcdWifiManager": dict({
1609 "category": FC.CATEGORY_MANAGERS,
1610 "create_function": create_element,
1611 "configure_function": configure_element,
1613 "connector_types": ["dev"],
1614 "box_attributes": ["SuccessK",
1616 "MaxSuccessThreshold",
1617 "MinTimerThreshold",
1618 "MinSuccessThreshold",
1621 "TurnOffRtsAfterRateDecrease",
1622 "TurnOnRtsAfterRateIncrease",
1627 "FragmentationThreshold",
1630 "ns3::UanTransducerHd": dict({
1632 "create_function": create_element,
1633 "configure_function": configure_element,
1635 "connector_types": [],
1636 "box_attributes": [],
1638 "ns3::LogDistancePropagationLossModel": dict({
1639 "category": FC.CATEGORY_LOSS_MODELS,
1640 "create_function": create_element,
1641 "configure_function": configure_element,
1643 "connector_types": ["prev", "next"],
1644 "box_attributes": ["Exponent",
1645 "ReferenceDistance",
1648 "ns3::EmuNetDevice": dict({
1649 "category": FC.CATEGORY_DEVICES,
1650 "create_function": create_element,
1651 "configure_function": configure_element,
1653 "connector_types": ["node", "queue"],
1654 "box_attributes": ["Mtu",
1660 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1662 "ns3::Ipv6ExtensionLooseRouting": dict({
1663 "category": FC.CATEGORY_ROUTING,
1664 "create_function": create_element,
1665 "configure_function": configure_element,
1667 "connector_types": [],
1668 "box_attributes": ["ExtensionNumber"],
1670 "ns3::RandomWaypointMobilityModel": dict({
1671 "category": FC.CATEGORY_MOBILITY_MODELS,
1672 "create_function": create_element,
1673 "configure_function": configure_element,
1675 "connector_types": ["node"],
1676 "box_attributes": ["Speed",
1680 "tags": [tags.MOBILE],
1682 "ns3::RangePropagationLossModel": dict({
1683 "category": FC.CATEGORY_LOSS_MODELS,
1684 "create_function": create_element,
1685 "configure_function": configure_element,
1687 "connector_types": [],
1688 "box_attributes": ["MaxRange"],
1690 "ns3::AlohaNoackNetDevice": dict({
1691 "category": FC.CATEGORY_DEVICES,
1692 "create_function": create_element,
1693 "configure_function": configure_element,
1695 "connector_types": [],
1696 "box_attributes": ["Address",
1698 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1700 "ns3::MatrixPropagationLossModel": dict({
1701 "category": FC.CATEGORY_LOSS_MODELS,
1702 "create_function": create_element,
1703 "configure_function": configure_element,
1705 "connector_types": [],
1706 "box_attributes": ["DefaultLoss"],
1708 "ns3::WifiNetDevice": dict({
1709 "category": FC.CATEGORY_DEVICES,
1710 "create_function": create_element,
1711 "configure_function": configure_device,
1713 "connector_types": ["node", "mac", "phy", "manager"],
1714 "box_attributes": ["Mtu"],
1715 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1717 "ns3::CsmaChannel": dict({
1718 "category": FC.CATEGORY_CHANNELS,
1719 "create_function": create_element,
1720 "configure_function": configure_element,
1722 "connector_types": ["devs"],
1723 "box_attributes": ["DataRate",
1726 "ns3::BridgeNetDevice": dict({
1727 "category": FC.CATEGORY_DEVICES,
1728 "create_function": create_element,
1729 "configure_function": configure_element,
1731 "connector_types": ["node"],
1732 "box_attributes": ["Mtu",
1735 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1737 "ns3::Ipv6ExtensionRouting": dict({
1738 "category": FC.CATEGORY_ROUTING,
1739 "create_function": create_element,
1740 "configure_function": configure_element,
1742 "connector_types": [],
1743 "box_attributes": ["ExtensionNumber"],
1745 "ns3::StaWifiMac": dict({
1746 "category": FC.CATEGORY_MAC_MODELS,
1747 "create_function": create_wifi_standard_model,
1748 "configure_function": configure_element,
1749 "help": "Station Wifi MAC Model",
1750 "connector_types": ["dev"],
1751 "box_attributes": ["ProbeRequestTimeout",
1752 "AssocRequestTimeout",
1756 "BasicBlockAckTimeout",
1757 "CompressedBlockAckTimeout",
1762 "MaxPropagationDelay",
1766 "ns3::UdpEchoClient": dict({
1767 "category": FC.CATEGORY_APPLICATIONS,
1768 "create_function": create_element,
1769 "configure_function": configure_element,
1771 "connector_types": ["node"],
1772 "stop_function": stop_application,
1773 "start_function": start_application,
1774 "status_function": status_application,
1775 "box_attributes": ["MaxPackets",
1782 "tags": [tags.APPLICATION],
1784 "ns3::UdpClient": dict({
1785 "category": FC.CATEGORY_APPLICATIONS,
1786 "create_function": create_element,
1787 "configure_function": configure_element,
1789 "connector_types": ["node"],
1790 "stop_function": stop_application,
1791 "start_function": start_application,
1792 "status_function": status_application,
1793 "box_attributes": ["MaxPackets",
1800 "tags": [tags.APPLICATION],
1802 "ns3::PointToPointChannel": dict({
1803 "category": FC.CATEGORY_CHANNELS,
1804 "create_function": create_element,
1805 "configure_function": configure_element,
1807 "connector_types": ["dev2"],
1808 "box_attributes": ["Delay"],
1810 "ns3::Ipv6StaticRouting": dict({
1811 "category": FC.CATEGORY_ROUTING,
1812 "create_function": create_element,
1813 "configure_function": configure_element,
1815 "connector_types": [],
1816 "box_attributes": [],
1818 "ns3::DropTailQueue": dict({
1819 "category": FC.CATEGORY_QUEUES,
1820 "create_function": create_element,
1821 "configure_function": configure_element,
1823 "connector_types": ["dev"],
1824 "box_attributes": ["MaxPackets",
1827 "ns3::ConstantPositionMobilityModel": dict({
1828 "category": FC.CATEGORY_MOBILITY_MODELS,
1829 "create_function": create_element,
1830 "configure_function": configure_element,
1832 "connector_types": ["node"],
1833 "box_attributes": ["Position",
1835 "tags": [tags.MOBILE],
1837 "ns3::FixedRssLossModel": dict({
1838 "category": FC.CATEGORY_LOSS_MODELS,
1839 "create_function": create_element,
1840 "configure_function": configure_element,
1842 "connector_types": [],
1843 "box_attributes": ["Rss"],
1845 "ns3::EnergySourceContainer": dict({
1846 "category": FC.CATEGORY_ENERGY_MODELS,
1847 "create_function": create_element,
1848 "configure_function": configure_element,
1850 "connector_types": [],
1851 "box_attributes": [],
1853 "ns3::RandomWalk2dMobilityModel": dict({
1854 "category": FC.CATEGORY_MOBILITY_MODELS,
1855 "create_function": create_element,
1856 "configure_function": configure_element,
1858 "connector_types": ["node"],
1859 "box_attributes": ["Bounds",
1867 "tags": [tags.MOBILE],
1869 "ns3::ListPositionAllocator": dict({
1871 "create_function": create_element,
1872 "configure_function": configure_element,
1874 "connector_types": [],
1875 "box_attributes": [],
1877 "ns3::dot11s::PeerManagementProtocol": dict({
1878 "category": FC.CATEGORY_PROTOCOLS,
1879 "create_function": create_element,
1880 "configure_function": configure_element,
1882 "connector_types": [],
1883 "box_attributes": ["MaxNumberOfPeerLinks",
1884 "MaxBeaconShiftValue",
1885 "EnableBeaconCollisionAvoidance"],
1887 "ns3::MeshPointDevice": dict({
1888 "category": FC.CATEGORY_DEVICES,
1889 "create_function": create_element,
1890 "configure_function": configure_element,
1892 "connector_types": [],
1893 "box_attributes": ["Mtu"],
1894 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1896 "ns3::BasicEnergySource": dict({
1897 "category": FC.CATEGORY_ENERGY_MODELS,
1898 "create_function": create_element,
1899 "configure_function": configure_element,
1901 "connector_types": [],
1902 "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1903 "BasicEnergySupplyVoltageV",
1904 "PeriodicEnergyUpdateInterval"],
1906 "ns3::Ipv6OptionPadn": dict({
1908 "create_function": create_element,
1909 "configure_function": configure_element,
1911 "connector_types": [],
1912 "box_attributes": ["OptionNumber"],
1914 "ns3::ApWifiMac": dict({
1915 "category": FC.CATEGORY_MAC_MODELS,
1916 "create_function": create_wifi_standard_model,
1917 "configure_function": configure_element,
1918 "help": "Access point Wifi MAC Model",
1919 "connector_types": ["dev"],
1920 "box_attributes": ["BeaconInterval",
1924 "BasicBlockAckTimeout",
1925 "CompressedBlockAckTimeout",
1930 "MaxPropagationDelay",
1934 "ns3::YansErrorRateModel": dict({
1935 "category": FC.CATEGORY_ERROR_MODELS,
1936 "create_function": create_element,
1937 "configure_function": configure_element,
1939 "connector_types": [],
1940 "box_attributes": [],
1942 "ns3::WifiMacQueue": dict({
1943 "category": FC.CATEGORY_QUEUES,
1944 "create_function": create_element,
1945 "configure_function": configure_element,
1947 "connector_types": [],
1948 "box_attributes": ["MaxPacketNumber",
1951 "ns3::NonCommunicatingNetDevice": dict({
1952 "category": FC.CATEGORY_DEVICES,
1953 "create_function": create_element,
1954 "configure_function": configure_element,
1956 "connector_types": [],
1957 "box_attributes": [],
1958 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1960 "ns3::RateErrorModel": dict({
1961 "category": FC.CATEGORY_ERROR_MODELS,
1962 "create_function": create_element,
1963 "configure_function": configure_element,
1965 "connector_types": [],
1966 "box_attributes": ["ErrorUnit",
1971 "ns3::MeshWifiInterfaceMac": dict({
1972 "category": FC.CATEGORY_MAC_MODELS,
1973 "create_function": create_element,
1974 "configure_function": configure_element,
1976 "connector_types": [],
1977 "box_attributes": ["BeaconInterval",
1982 "BasicBlockAckTimeout",
1983 "CompressedBlockAckTimeout",
1988 "MaxPropagationDelay",
1991 "ns3::UanPhyCalcSinrDual": dict({
1993 "create_function": create_element,
1994 "configure_function": configure_element,
1996 "connector_types": [],
1997 "box_attributes": [],
1999 "ns3::Ipv6ExtensionAH": dict({
2001 "create_function": create_element,
2002 "configure_function": configure_element,
2004 "connector_types": [],
2005 "box_attributes": ["ExtensionNumber"],
2007 "ns3::SingleModelSpectrumChannel": dict({
2008 "category": FC.CATEGORY_CHANNELS,
2009 "create_function": create_element,
2010 "configure_function": configure_element,
2012 "connector_types": [],
2013 "box_attributes": [],
2015 "ns3::YansWifiPhy": dict({
2016 "category": FC.CATEGORY_PHY_MODELS,
2017 "create_function": create_wifi_standard_model,
2018 "configure_function": configure_element,
2020 "connector_types": ["dev", "err", "chan"],
2021 "box_attributes": ["EnergyDetectionThreshold",
2022 "CcaMode1Threshold",
2029 "ChannelSwitchDelay",
2032 "traces": ["yanswifipcap"]
2034 "ns3::WifiRadioEnergyModel": dict({
2035 "category": FC.CATEGORY_ENERGY_MODELS,
2036 "create_function": create_element,
2037 "configure_function": configure_element,
2039 "connector_types": [],
2040 "box_attributes": ["TxCurrentA",
2045 "ns3::EdcaTxopN": dict({
2047 "create_function": create_element,
2048 "configure_function": configure_element,
2050 "connector_types": [],
2051 "box_attributes": ["BlockAckThreshold",
2056 "ns3::UanPhyPerGenDefault": dict({
2058 "create_function": create_element,
2059 "configure_function": configure_element,
2061 "connector_types": [],
2062 "box_attributes": ["Threshold"],
2064 "ns3::IdealWifiManager": dict({
2065 "category": FC.CATEGORY_MANAGERS,
2066 "create_function": create_element,
2067 "configure_function": configure_element,
2069 "connector_types": ["dev"],
2070 "box_attributes": ["BerThreshold",
2075 "FragmentationThreshold",
2078 "ns3::MultiModelSpectrumChannel": dict({
2079 "category": FC.CATEGORY_CHANNELS,
2080 "create_function": create_element,
2081 "configure_function": configure_element,
2083 "connector_types": [],
2084 "box_attributes": [],
2086 "ns3::HalfDuplexIdealPhy": dict({
2087 "category": FC.CATEGORY_PHY_MODELS,
2088 "create_function": create_element,
2089 "configure_function": configure_element,
2091 "connector_types": [],
2092 "box_attributes": ["Rate"],
2094 "ns3::UanPhyCalcSinrDefault": dict({
2095 "category": FC.CATEGORY_PHY_MODELS,
2096 "create_function": create_element,
2097 "configure_function": configure_element,
2099 "connector_types": [],
2100 "box_attributes": [],
2102 "ns3::ReceiveListErrorModel": dict({
2103 "category": FC.CATEGORY_ERROR_MODELS,
2104 "create_function": create_element,
2105 "configure_function": configure_element,
2107 "connector_types": [],
2108 "box_attributes": ["IsEnabled"],
2110 "ns3::SpectrumAnalyzer": dict({
2112 "create_function": create_element,
2113 "configure_function": configure_element,
2115 "connector_types": [],
2116 "box_attributes": ["Resolution",
2117 "NoisePowerSpectralDensity"],
2119 "ns3::ConstantRateWifiManager": dict({
2120 "category": FC.CATEGORY_MANAGERS,
2121 "create_function": create_element,
2122 "configure_function": configure_element,
2124 "connector_types": ["dev"],
2125 "box_attributes": ["DataMode",
2131 "FragmentationThreshold",
2134 "ns3::Ipv6OptionPad1": dict({
2136 "create_function": create_element,
2137 "configure_function": configure_element,
2139 "connector_types": [],
2140 "box_attributes": ["OptionNumber"],
2142 "ns3::UdpTraceClient": dict({
2144 "create_function": create_element,
2145 "configure_function": configure_element,
2147 "connector_types": [],
2148 "box_attributes": ["RemoteAddress",
2154 "ns3::RraaWifiManager": dict({
2155 "category": FC.CATEGORY_MANAGERS,
2156 "create_function": create_element,
2157 "configure_function": configure_element,
2159 "connector_types": ["dev"],
2160 "box_attributes": ["Basic",
2188 "FragmentationThreshold",
2191 "ns3::RandomPropagationLossModel": dict({
2192 "category": FC.CATEGORY_LOSS_MODELS,
2193 "create_function": create_element,
2194 "configure_function": configure_element,
2196 "connector_types": [],
2197 "box_attributes": ["Variable"],
2199 "ns3::UanChannel": dict({
2200 "category": FC.CATEGORY_CHANNELS,
2201 "create_function": create_element,
2202 "configure_function": configure_element,
2204 "connector_types": [],
2205 "box_attributes": [],
2207 "ns3::MinstrelWifiManager": dict({
2208 "category": FC.CATEGORY_MANAGERS,
2209 "create_function": create_element,
2210 "configure_function": configure_element,
2212 "connector_types": ["dev"],
2213 "box_attributes": ["UpdateStatistics",
2223 "FragmentationThreshold",
2226 "ns3::UanPhyDual": dict({
2227 "category": FC.CATEGORY_PHY_MODELS,
2228 "create_function": create_element,
2229 "configure_function": configure_element,
2231 "connector_types": [],
2232 "box_attributes": ["CcaThresholdPhy1",
2238 "SupportedModesPhy1",
2239 "SupportedModesPhy2"],
2241 "ns3::ListErrorModel": dict({
2242 "category": FC.CATEGORY_ERROR_MODELS,
2243 "create_function": create_element,
2244 "configure_function": configure_element,
2246 "connector_types": ["dev"],
2247 "box_attributes": ["IsEnabled"],
2249 "ns3::VirtualNetDevice": dict({
2250 "category": FC.CATEGORY_DEVICES,
2251 "create_function": create_element,
2252 "configure_function": configure_element,
2254 "connector_types": [],
2255 "box_attributes": ["Mtu"],
2256 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2258 "ns3::UanPhyGen": dict({
2259 "category": FC.CATEGORY_PHY_MODELS,
2260 "create_function": create_element,
2261 "configure_function": configure_element,
2263 "connector_types": [],
2264 "box_attributes": ["CcaThreshold",
2270 "ns3::Ipv6L3Protocol": dict({
2271 "category": FC.CATEGORY_PROTOCOLS,
2272 "create_function": create_element,
2273 "configure_function": configure_element,
2275 "connector_types": ["node"],
2276 "box_attributes": ["DefaultTtl",
2279 "ns3::PointToPointRemoteChannel": dict({
2280 "category": FC.CATEGORY_CHANNELS,
2281 "create_function": create_element,
2282 "configure_function": configure_element,
2284 "connector_types": [],
2285 "box_attributes": ["Delay"],
2287 "ns3::UanPhyPerUmodem": dict({
2288 "category": FC.CATEGORY_PHY_MODELS,
2289 "create_function": create_element,
2290 "configure_function": configure_element,
2292 "connector_types": [],
2293 "box_attributes": [],
2295 "ns3::OnoeWifiManager": dict({
2296 "category": FC.CATEGORY_MANAGERS,
2297 "create_function": create_element,
2298 "configure_function": configure_element,
2300 "connector_types": ["dev"],
2301 "box_attributes": ["UpdatePeriod",
2303 "AddCreditThreshold",
2308 "FragmentationThreshold",
2311 "ns3::QadhocWifiMac": dict({
2312 "category": FC.CATEGORY_MAC_MODELS,
2313 "create_function": create_element,
2314 "configure_function": configure_element,
2316 "connector_types": [],
2317 "box_attributes": ["CtsTimeout",
2319 "BasicBlockAckTimeout",
2320 "CompressedBlockAckTimeout",
2325 "MaxPropagationDelay",
2328 "ns3::JakesPropagationLossModel": dict({
2329 "category": FC.CATEGORY_LOSS_MODELS,
2330 "create_function": create_element,
2331 "configure_function": configure_element,
2333 "connector_types": [],
2334 "box_attributes": ["NumberOfRaysPerPath",
2335 "NumberOfOscillatorsPerRay",
2339 "ns3::PacketSink": dict({
2340 "category": FC.CATEGORY_APPLICATIONS,
2341 "create_function": create_element,
2342 "configure_function": configure_element,
2344 "connector_types": ["node"],
2345 "stop_function": stop_application,
2346 "start_function": start_application,
2347 "status_function": status_application,
2348 "box_attributes": ["Local",
2352 "tags": [tags.APPLICATION],
2354 "ns3::RandomDirection2dMobilityModel": dict({
2355 "category": FC.CATEGORY_MOBILITY_MODELS,
2356 "create_function": create_element,
2357 "configure_function": configure_element,
2359 "connector_types": ["node"],
2360 "box_attributes": ["Bounds",
2365 "tags": [tags.MOBILE],
2367 "ns3::UanMacAloha": dict({
2369 "create_function": create_element,
2370 "configure_function": configure_element,
2372 "connector_types": [],
2373 "box_attributes": [],
2375 "ns3::MsduStandardAggregator": dict({
2377 "create_function": create_element,
2378 "configure_function": configure_element,
2380 "connector_types": [],
2381 "box_attributes": ["MaxAmsduSize"],
2383 "ns3::DcaTxop": dict({
2385 "create_function": create_element,
2386 "configure_function": configure_element,
2388 "connector_types": [],
2389 "box_attributes": ["MinCw",
2393 "ns3::UanPhyCalcSinrFhFsk": dict({
2394 "category": FC.CATEGORY_PHY_MODELS,
2395 "create_function": create_element,
2396 "configure_function": configure_element,
2398 "connector_types": [],
2399 "box_attributes": ["NumberOfHops"],
2401 "ns3::UanPropModelIdeal": dict({
2403 "create_function": create_element,
2404 "configure_function": configure_element,
2406 "connector_types": [],
2407 "box_attributes": [],
2409 "ns3::UanMacRcGw": dict({
2411 "create_function": create_element,
2412 "configure_function": configure_element,
2414 "connector_types": [],
2415 "box_attributes": ["MaxReservations",
2423 "NumberOfRetryRates",
2428 "ns3::NistErrorRateModel": dict({
2429 "category": FC.CATEGORY_ERROR_MODELS,
2430 "create_function": create_element,
2431 "configure_function": configure_element,
2433 "connector_types": ["phy"],
2434 "box_attributes": [],
2436 "ns3::Ipv4L3Protocol": dict({
2437 "category": FC.CATEGORY_PROTOCOLS,
2438 "create_function": create_ipv4protocol,
2439 "configure_function": configure_element,
2441 "connector_types": ["node"],
2442 "box_attributes": ["DefaultTtl",
2446 "ns3::aodv::RoutingProtocol": dict({
2447 "category": FC.CATEGORY_PROTOCOLS,
2448 "create_function": create_element,
2449 "configure_function": configure_element,
2451 "connector_types": [],
2452 "box_attributes": ["HelloInterval",
2455 "NodeTraversalTime",
2457 "ActiveRouteTimeout",
2464 "PathDiscoveryTime",
2473 "ns3::TcpL4Protocol": dict({
2474 "category": FC.CATEGORY_PROTOCOLS,
2475 "create_function": create_element,
2476 "configure_function": configure_element,
2478 "connector_types": ["node"],
2479 "box_attributes": ["RttEstimatorFactory",
2482 "ns3::olsr::RoutingProtocol": dict({
2483 "category": FC.CATEGORY_PROTOCOLS,
2484 "create_function": create_element,
2485 "configure_function": configure_element,
2487 "connector_types": [],
2488 "box_attributes": ["HelloInterval",
2494 "ns3::UdpEchoServer": dict({
2495 "category": FC.CATEGORY_APPLICATIONS,
2496 "create_function": create_element,
2497 "configure_function": configure_element,
2499 "connector_types": ["node"],
2500 "stop_function": stop_application,
2501 "start_function": start_application,
2502 "status_function": status_application,
2503 "box_attributes": ["Port",
2506 "tags": [tags.APPLICATION],
2508 "ns3::AmrrWifiManager": dict({
2509 "category": FC.CATEGORY_MANAGERS,
2510 "create_function": create_element,
2511 "configure_function": configure_element,
2513 "connector_types": ["dev"],
2514 "box_attributes": ["UpdatePeriod",
2517 "MaxSuccessThreshold",
2518 "MinSuccessThreshold",
2523 "FragmentationThreshold",
2526 "ns3::ArfWifiManager": dict({
2527 "category": FC.CATEGORY_MANAGERS,
2528 "create_function": create_element,
2529 "configure_function": configure_element,
2531 "connector_types": ["dev"],
2532 "box_attributes": ["TimerThreshold",
2538 "FragmentationThreshold",
2541 "ns3::SubscriberStationNetDevice": dict({
2542 "category": FC.CATEGORY_DEVICES,
2543 "create_function": create_subscriber_station,
2544 "configure_function": configure_station,
2545 "help": "Subscriber station for mobile wireless network",
2546 "connector_types": ["node", "chan", "phy", "sflows"],
2547 "box_attributes": ["LostDlMapInterval",
2548 "LostUlMapInterval",
2558 "MaxContentionRangingRetries",
2562 "traces": ["wimaxpcap", "wimaxascii"],
2563 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2565 "ns3::flame::FlameRtable": dict({
2567 "create_function": create_element,
2568 "configure_function": configure_element,
2570 "connector_types": [],
2571 "box_attributes": ["Lifetime"],
2573 "ns3::BSSchedulerRtps": dict({
2574 "category": FC.CATEGORY_SERVICE_FLOWS,
2575 "create_function": create_element,
2576 "configure_function": configure_element,
2577 "help": "Simple downlink scheduler for rtPS flows",
2578 "connector_types": ["dev"],
2579 "box_attributes": [],
2581 "ns3::BSSchedulerSimple": dict({
2582 "category": FC.CATEGORY_SERVICE_FLOWS,
2583 "create_function": create_element,
2584 "configure_function": configure_element,
2585 "help": "simple downlink scheduler for service flows",
2586 "connector_types": ["dev"],
2587 "box_attributes": [],
2589 "ns3::SimpleOfdmWimaxChannel": dict({
2590 "category": FC.CATEGORY_CHANNELS,
2591 "create_function": create_wimax_channel,
2592 "configure_function": configure_element,
2593 "help": "Wimax channel",
2594 "connector_types": ["devs"],
2595 "box_attributes": [],
2597 "ns3::SimpleOfdmWimaxPhy": dict({
2598 "category": FC.CATEGORY_PHY_MODELS,
2599 "create_function": create_wimax_phy,
2600 "configure_function": configure_element,
2601 "help": "Wimax Phy",
2602 "connector_types": ["dev"],
2603 "box_attributes": [],
2605 "ns3::UplinkSchedulerSimple": dict({
2606 "category": FC.CATEGORY_SERVICE_FLOWS,
2607 "create_function": create_element_no_constructor,
2608 "configure_function": configure_element,
2609 "help": "Simple uplink scheduler for service flows",
2610 "connector_types": ["dev"],
2611 "box_attributes": [],
2613 "ns3::UplinkSchedulerRtps": dict({
2614 "category": FC.CATEGORY_SERVICE_FLOWS,
2615 "create_function": create_element_no_constructor,
2616 "configure_function": configure_element,
2617 "help": "Simple uplink scheduler for rtPS flows",
2618 "connector_types": ["dev"],
2619 "box_attributes": [],
2621 "ns3::IpcsClassifierRecord": dict({
2622 "category": FC.CATEGORY_SERVICE_FLOWS,
2623 "create_function": create_ipcs_classifier_record,
2624 "configure_function": configure_element,
2625 "help": "Classifier record for service flow",
2626 "connector_types": ["sflow"],
2627 "box_attributes": ["ClassifierSrcAddress",
2628 "ClassifierSrcMask",
2629 "ClassifierDstAddress",
2630 "ClassifierDstMask",
2631 "ClassifierSrcPortLow",
2632 "ClassifierSrcPortHigh",
2633 "ClassifierDstPortLow",
2634 "ClassifierDstPortHigh",
2635 "ClassifierProtocol",
2636 "ClassifierPriority"],
2638 "ns3::ServiceFlow": dict({
2639 "category": FC.CATEGORY_SERVICE_FLOWS,
2640 "create_function": create_service_flow,
2641 "configure_function": configure_element,
2642 "help": "Service flow for QoS",
2643 "connector_types": ["classif", "dev"],
2644 "box_attributes": ["ServiceFlowDirection",
2645 "ServiceFlowSchedulingType"],