1 # -*- coding: utf-8 -*-
3 from util import _get_ipv4_protocol_guid, _get_node_guid, _get_dev_number
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 _follow_trace(testbed_instance, guid, trace_id, filename):
46 testbed_instance.follow_trace(guid, trace_id, filename)
47 filepath = testbed_instance.trace_filepath(guid, trace_id)
50 ### create traces functions ###
52 def p2pascii_trace(testbed_instance, guid, trace_id):
53 node_guid = _get_node_guid(testbed_instance, guid)
54 interface_number = _get_dev_number(testbed_instance, guid)
55 element = testbed_instance._elements[guid]
56 filename = "trace-p2p-node-%d-dev-%d.tr" % (node_guid, interface_number)
57 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
58 helper = testbed_instance.ns3.PointToPointHelper()
59 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
60 stream = asciiHelper.CreateFileStream(filepath)
61 helper.EnableAscii(stream, element)
63 def p2ppcap_trace(testbed_instance, guid, trace_id):
64 node_guid = _get_node_guid(testbed_instance, guid)
65 interface_number = _get_dev_number(testbed_instance, guid)
66 element = testbed_instance._elements[guid]
67 filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_guid, interface_number)
68 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
69 helper = testbed_instance.ns3.PointToPointHelper()
70 helper.EnablePcap(filepath, element, explicitFilename = True)
72 def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
73 node_guid = _get_node_guid(testbed_instance, guid)
74 interface_number = _get_dev_number(testbed_instance, guid)
75 element = testbed_instance._elements[guid]
76 filename = "trace-csma-node-%d-dev-%d.pcap" % (node_guid, interface_number)
77 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
78 helper = testbed_instance.ns3.CsmaHelper()
79 helper.EnablePcap(filepath, element, promiscuous = promisc,
80 explicitFilename = True)
82 def csmapcap_trace(testbed_instance, guid, trace_id):
84 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
86 def csmapcap_promisc_trace(testbed_instance, guid, trace_id):
88 _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
90 def fdpcap_trace(testbed_instance, guid, trace_id):
91 node_guid = _get_node_guid(testbed_instance, guid)
92 interface_number = _get_dev_number(testbed_instance, guid)
93 element = testbed_instance._elements[guid]
94 filename = "trace-fd-node-%d-dev-%d.pcap" % (node_guid, interface_number)
95 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
96 helper = testbed_instance.ns3.FdNetDeviceHelper()
97 helper.EnablePcap(filepath, element, explicitFilename = True)
99 def fdascii_trace(testbed_instance, guid, trace_id):
100 node_guid = _get_node_guid(testbed_instance, guid)
101 interface_number = _get_dev_number(testbed_instance, guid)
102 element = testbed_instance._elements[guid]
103 filename = "trace-fd-node-%d-dev-%d.tr" % (node_guid, interface_number)
104 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
105 helper = testbed_instance.ns3.FdNetDeviceHelper()
106 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
107 stream = asciiHelper.CreateFileStream(filepath)
108 helper.EnableAscii(stream, element)
110 def yanswifipcap_trace(testbed_instance, guid, trace_id):
111 dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
112 node_guid = _get_node_guid(testbed_instance, dev_guid)
113 interface_number = _get_dev_number(testbed_instance, dev_guid)
114 element = testbed_instance._elements[dev_guid]
115 filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
116 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
117 helper = testbed_instance.ns3.YansWifiPhyHelper()
118 helper.EnablePcap(filepath, element, explicitFilename = True)
120 def wimaxascii_trace(testbed_instance, guid, trace_id):
121 node_guid = _get_node_guid(testbed_instance, guid)
122 interface_number = _get_dev_number(testbed_instance, guid)
123 element = testbed_instance._elements[guid]
124 filename = "trace-wimax-node-%d-dev-%d.tr" % (node_guid, interface_number)
125 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
126 helper = testbed_instance.ns3.WimaxHelper()
127 asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
128 stream = asciiHelper.CreateFileStream (filepath)
129 helper.EnableAscii(stream, element)
130 #helper.EnableLogComponents()
132 def wimaxpcap_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-wimax-node-%d-dev-%d.pcap" % (node_guid, interface_number)
137 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
138 helper = testbed_instance.ns3.WimaxHelper()
139 helper.EnablePcap(filepath, element, explicitFilename = True)
141 def rtt_trace(testbed_instance, guid, trace_id):
142 element = testbed_instance._elements[guid]
143 helper = testbed_instance.ns3.ScalarTraceHelper()
144 prefix = "trace-app-%d" % (guid, )
145 filename = helper.GetFilenameFromSource(prefix, element, trace_id)
146 filepath = _follow_trace(testbed_instance, guid, trace_id, filename)
147 prefix = filepath[:filepath.find(prefix)+len(prefix)]
148 helper.EnableTrace(element, trace_id, prefix, "T")
150 trace_functions = dict({
151 "P2PPcapTrace": p2ppcap_trace,
152 "P2PAsciiTrace": p2pascii_trace,
153 "CsmaPcapTrace": csmapcap_trace,
154 "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
155 "FdPcapTrace": fdpcap_trace,
156 "FdAsciiTrace": fdascii_trace,
157 "YansWifiPhyPcapTrace": yanswifipcap_trace,
158 "WimaxPcapTrace": wimaxpcap_trace,
159 "WimaxAsciiTrace": wimaxascii_trace,
163 ### Creation functions ###
165 def create_element(testbed_instance, guid):
166 element_factory = testbed_instance.ns3.ObjectFactory()
167 factory_id = testbed_instance._create[guid]
168 element_factory.SetTypeId(factory_id)
169 construct_parameters = testbed_instance._get_construct_parameters(guid)
170 for name, value in construct_parameters.iteritems():
171 ns3_value = testbed_instance._to_ns3_value(guid, name, value)
172 element_factory.Set(name, ns3_value)
173 element = element_factory.Create()
174 testbed_instance._elements[guid] = element
176 def create_node(testbed_instance, guid):
177 create_element(testbed_instance, guid)
178 element = testbed_instance._elements[guid]
179 element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
181 def create_wifi_phy(testbed_instance, guid):
182 create_element(testbed_instance, guid)
183 element = testbed_instance._elements[guid]
184 parameters = testbed_instance._get_parameters(guid)
185 standard = parameters.get("Standard")
187 raise RuntimeError("No wifi standard set for %d" % guid)
188 element.ConfigureStandard(wifi_standards[standard])
190 def create_wifi_mac(testbed_instance, guid):
191 create_element(testbed_instance, guid)
192 element = testbed_instance._elements[guid]
193 parameters = testbed_instance._get_parameters(guid)
194 standard = parameters.get("Standard")
196 raise RuntimeError("No wifi standard set for %d" % guid)
197 element.ConfigureStandard(wifi_standards[standard])
198 qos = parameters.get("QosSupported")
199 # BUG: There seems to be an inheritance problem with the Python Bindings and SetQosSupported.
200 # It seems to be onbly defined for regular-wifi-mac.h and not for its children...
202 # element.SetQosSupported(qos)
204 def create_waypoint_mobility(testbed_instance, guid):
205 create_element(testbed_instance, guid)
206 element = testbed_instance._elements[guid]
207 parameters = testbed_instance._get_parameters(guid)
208 ns3 = testbed_instance.ns3
209 waypoints = parameters.get("WaypointList", "")
210 waypoints = re.sub(" |\(|\)", "", waypoints)
211 for swp in waypoints.split(","):
215 pos = ns3.Vector(float(dwp[1]), float(dwp[2]), float(dwp[3]))
216 waypoint = ns3.Waypoint(time, pos)
217 element.AddWaypoint(waypoint)
219 def create_ipv4protocol(testbed_instance, guid):
220 create_element(testbed_instance, guid)
221 element = testbed_instance._elements[guid]
222 list_routing = testbed_instance.ns3.Ipv4ListRouting()
223 element.SetRoutingProtocol(list_routing)
224 static_routing = testbed_instance.ns3.Ipv4StaticRouting()
225 list_routing.AddRoutingProtocol(static_routing, 1)
227 def create_element_no_constructor(testbed_instance, guid):
228 """ Create function for ns3 classes for which
229 TypeId.HasConstructor == False"""
230 factory_id = testbed_instance._create[guid]
231 factory_name = factory_id.replace("ns3::", "")
232 constructor = getattr(testbed_instance.ns3, factory_name)
233 element = constructor()
234 testbed_instance._elements[guid] = element
236 def create_base_station(testbed_instance, guid):
237 node_guid = _get_node_guid(testbed_instance, guid)
238 node = testbed_instance._elements[node_guid]
239 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
240 if len(phy_guids) == 0:
241 raise RuntimeError("No PHY was found for station %d" % guid)
242 phy = testbed_instance._elements[phy_guids[0]]
243 uplnk_guids = testbed_instance.get_connected(guid, "uplnk", "dev")
244 if len(uplnk_guids) == 0:
245 raise RuntimeError("No uplink scheduler was found for station %d" % guid)
246 uplnk = testbed_instance._elements[uplnk_guids[0]]
247 dwnlnk_guids = testbed_instance.get_connected(guid, "dwnlnk", "dev")
248 if len(dwnlnk_guids) == 0:
249 raise RuntimeError("No downlink scheduler was found for station %d" % guid)
250 dwnlnk = testbed_instance._elements[dwnlnk_guids[0]]
251 element = testbed_instance.ns3.BaseStationNetDevice(node, phy, uplnk, dwnlnk)
252 testbed_instance._elements[guid] = element
254 def create_subscriber_station(testbed_instance, guid):
255 node_guid = _get_node_guid(testbed_instance, guid)
256 node = testbed_instance._elements[node_guid]
257 phy_guids = testbed_instance.get_connected(guid, "phy", "dev")
258 if len(phy_guids) == 0:
259 raise RuntimeError("No PHY was found for station %d" % guid)
260 phy = testbed_instance._elements[phy_guids[0]]
261 element = testbed_instance.ns3.SubscriberStationNetDevice(node, phy)
262 element.SetModulationType(testbed_instance.ns3.WimaxPhy.MODULATION_TYPE_QAM16_12)
263 testbed_instance._elements[guid] = element
265 def create_wimax_channel(testbed_instance, guid):
266 element = testbed_instance.ns3.SimpleOfdmWimaxChannel(testbed_instance.ns3.SimpleOfdmWimaxChannel.COST231_PROPAGATION)
267 testbed_instance._elements[guid] = element
269 def create_wimax_phy(testbed_instance, guid):
270 element = testbed_instance.ns3.SimpleOfdmWimaxPhy()
271 testbed_instance._elements[guid] = element
273 def create_service_flow(testbed_instance, guid):
274 parameters = testbed_instance._get_parameters(guid)
275 direction = parameters.get("Direction")
276 if direction == None:
277 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
278 sched = parameters.get("SchedulingType")
280 raise RuntimeError("No SchedulingType was found for service flow %d" % guid)
281 ServiceFlow = testbed_instance.ns3.ServiceFlow
282 direction = service_flow_direction[direction]
283 sched = service_flow_scheduling_type[sched]
284 element = ServiceFlow(direction)
285 element.SetCsSpecification(ServiceFlow.IPV4)
286 element.SetServiceSchedulingType(sched)
287 element.SetMaxSustainedTrafficRate(100)
288 element.SetMinReservedTrafficRate(1000000)
289 element.SetMinTolerableTrafficRate(1000000)
290 element.SetMaximumLatency(100)
291 element.SetMaxTrafficBurst(2000)
292 element.SetTrafficPriority(1)
293 element.SetUnsolicitedGrantInterval(1)
294 element.SetMaxSustainedTrafficRate(70)
295 element.SetToleratedJitter(10)
296 element.SetSduSize(49)
297 element.SetRequestTransmissionPolicy(0)
298 testbed_instance._elements[guid] = element
300 def create_ipcs_classifier_record(testbed_instance, guid):
301 parameters = testbed_instance._get_parameters(guid)
302 src_address = parameters.get("SrcAddress")
303 if src_address == None:
304 raise RuntimeError("No SrcAddress was found for classifier %d" % guid)
305 src_address = testbed_instance.ns3.Ipv4Address(src_address)
306 src_mask = parameters.get("SrcMask")
308 raise RuntimeError("No SrcMask was found for classifier %d" % guid)
309 src_mask = testbed_instance.ns3.Ipv4Mask(src_mask)
310 dst_address = parameters.get("DstAddress")
311 if dst_address == None:
312 raise RuntimeError("No Dstddress was found for classifier %d" % guid)
313 dst_address = testbed_instance.ns3.Ipv4Address(dst_address)
314 dst_mask = parameters.get("DstMask")
316 raise RuntimeError("No DstMask was found for classifier %d" % guid)
317 dst_mask = testbed_instance.ns3.Ipv4Mask(dst_mask)
318 src_port_low = parameters.get("SrcPortLow")
319 if src_port_low == None:
320 raise RuntimeError("No SrcPortLow was found for classifier %d" % guid)
321 src_port_high = parameters.get("SrcPortHigh")
322 if src_port_high == None:
323 raise RuntimeError("No SrcPortHigh was found for classifier %d" % guid)
324 dst_port_low = parameters.get("DstPortLow")
325 if dst_port_low == None:
326 raise RuntimeError("No DstPortLow was found for classifier %d" % guid)
327 dst_port_high = parameters.get("DstPortHigh")
328 if dst_port_high == None:
329 raise RuntimeError("No DstPortHigh was found for classifier %d" % guid)
330 protocol = parameters.get("Protocol")
331 if protocol == None or protocol not in l4_protocols:
332 raise RuntimeError("No Protocol was found for classifier %d" % guid)
333 priority = parameters.get("Priority")
335 raise RuntimeError("No Priority was found for classifier %d" % guid)
336 element = testbed_instance.ns3.IpcsClassifierRecord(src_address, src_mask,
337 dst_address, dst_mask, src_port_low, src_port_high, dst_port_low,
338 dst_port_high, l4_protocols[protocol], priority)
339 testbed_instance._elements[guid] = element
341 ### Start/Stop functions ###
343 def start_application(testbed_instance, guid):
344 element = testbed_instance.elements[guid]
345 # BUG: without doing this explicit call it doesn't start!!!
346 # Shouldn't be enough to set the StartTime?
349 def stop_application(testbed_instance, guid):
350 element = testbed_instance.elements[guid]
351 now = testbed_instance.ns3.Simulator.Now()
352 element.SetStopTime(now)
354 ### Status functions ###
356 def status_application(testbed_instance, guid):
357 if guid not in testbed_instance.elements.keys():
358 raise RuntimeError("Can't get status on guid %d" % guid )
359 now = testbed_instance.ns3.Simulator.Now()
361 return AS.STATUS_NOT_STARTED
362 app = testbed_instance.elements[guid]
363 parameters = testbed_instance._get_parameters(guid)
364 start_value = parameters.get("StartTime")
365 if start_value != None:
366 start_time = testbed_instance.ns3.Time(start_value)
367 if now.Compare(start_time) < 0:
368 return AS.STATUS_NOT_STARTED
369 stop_value = parameters.get("StopTime")
370 if stop_value != None:
371 stop_time = testbed_instance.ns3.Time(stop_value)
372 if now.Compare(stop_time) < 0:
373 return AS.STATUS_RUNNING
375 return AS.STATUS_FINISHED
376 return AS.STATUS_UNDETERMINED
378 ### Configure functions ###
380 def configure_traces(testbed_instance, guid):
381 traces = testbed_instance._get_traces(guid)
382 for trace_id in traces:
383 trace_func = trace_functions[trace_id]
384 trace_func(testbed_instance, guid, trace_id)
386 def configure_element(testbed_instance, guid):
387 configure_traces(testbed_instance, guid)
389 def configure_device(testbed_instance, guid):
390 configure_traces(testbed_instance, guid)
391 element = testbed_instance._elements[guid]
393 parameters = testbed_instance._get_parameters(guid)
394 address = parameters.get("macAddress")
396 macaddr = testbed_instance.ns3.Mac48Address(address)
398 macaddr = testbed_instance.ns3.Mac48Address.Allocate()
399 element.SetAddress(macaddr)
401 if not guid in testbed_instance._add_address:
403 # search for the node asociated with the device
404 node_guid = _get_node_guid(testbed_instance, guid)
405 node = testbed_instance.elements[node_guid]
406 # search for the Ipv4L3Protocol asociated with the device
407 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
408 ipv4 = testbed_instance._elements[ipv4_guid]
409 ns3 = testbed_instance.ns3
411 addresses = testbed_instance._add_address[guid]
412 for address in addresses:
413 (address, netprefix, broadcast) = address
414 # TODO: missing IPV6 addresses!!
415 ifindex = ipv4.AddInterface(element)
416 inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
417 ns3.Ipv4Mask("/%d" % netprefix))
418 ipv4.AddAddress(ifindex, inaddr)
419 ipv4.SetMetric(ifindex, 1)
422 def _add_static_route(ns3, static_routing,
423 address, netprefix, nexthop_address, ifindex):
425 # Default route: 0.0.0.0/0
426 static_routing.SetDefaultRoute(nexthop_address, ifindex)
427 elif netprefix == 32:
428 # Host route: x.y.z.w/32
429 static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
431 # Network route: x.y.z.w/n
432 mask = ns3.Ipv4Mask("/%d" % netprefix)
433 static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
436 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
438 # Default route: 0.0.0.0/0
439 static_routing.SetDefaultRoute(ifindex)
440 elif netprefix == 32:
441 # Host route: x.y.z.w/32
442 static_routing.AddHostRouteTo(address, ifindex)
444 # Network route: x.y.z.w/n
445 mask = ns3.Ipv4Mask("/%d" % netprefix)
446 static_routing.AddNetworkRouteTo(address, mask, ifindex)
448 def configure_node(testbed_instance, guid):
449 configure_traces(testbed_instance, guid)
451 element = testbed_instance._elements[guid]
452 if not guid in testbed_instance._add_route:
454 # search for the Ipv4L3Protocol asociated with the device
455 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
456 ipv4 = testbed_instance._elements[ipv4_guid]
457 list_routing = ipv4.GetRoutingProtocol()
458 (static_routing, priority) = list_routing.GetRoutingProtocol(0)
459 ns3 = testbed_instance.ns3
460 routes = testbed_instance._add_route[guid]
462 (destination, netprefix, nexthop, metric) = route
463 address = ns3.Ipv4Address(destination)
465 nexthop_address = ns3.Ipv4Address(nexthop)
467 # TODO: HACKISH way of getting the ifindex... improve this
468 nifaces = ipv4.GetNInterfaces()
469 for ifidx in xrange(nifaces):
470 iface = ipv4.GetInterface(ifidx)
471 naddress = iface.GetNAddresses()
472 for addridx in xrange(naddress):
473 ifaddr = iface.GetAddress(addridx)
474 ifmask = ifaddr.GetMask()
475 ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
481 # Check previous ptp routes
482 for chaindest, chainprefix, chainhop, metric in routes:
483 if chaindest == nexthop and chainprefix == 32:
484 chainhop_address = ns3.Ipv4Address(chainhop)
485 for ifidx in xrange(nifaces):
486 iface = ipv4.GetInterface(ifidx)
487 naddress = iface.GetNAddresses()
488 for addridx in xrange(naddress):
489 ifaddr = iface.GetAddress(addridx)
490 ifmask = ifaddr.GetMask()
491 ifindex = ipv4.GetInterfaceForPrefix(chainhop_address, ifmask)
495 raise RuntimeError, "Cannot associate interface for routing entry:" \
496 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
497 _add_static_route(ns3, static_routing,
498 address, netprefix, nexthop_address, ifindex)
500 mask = ns3.Ipv4Mask("/%d" % netprefix)
501 ifindex = ipv4.GetInterfaceForPrefix(address, mask)
503 raise RuntimeError, "Cannot associate interface for routing entry:" \
504 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
505 _add_static_route_if(ns3, static_routing,
506 address, netprefix, nexthop_address, ifindex)
508 def configure_station(testbed_instance, guid):
509 configure_device(testbed_instance, guid)
510 element = testbed_instance._elements[guid]
513 def configure_matrix_propagation(testbed_instance, guid):
514 create_element(testbed_instance, guid)
515 element = testbed_instance._elements[guid]
516 mp_guids = testbed_instance.get_connected(guid, "mobpair", "matrix")
518 mp = testbed_instance._elements[mpg]
519 mas = testbed_instance.get_connected(mpg, "ma", "mp")
521 raise RuntimeError("Wrong number of source mobility models for MobilityPair %d" % guid)
522 mbs = testbed_instance.get_connected(mpg, "mb", "mp")
524 raise RuntimeError("Wrong number of destination mobility models for MobilityPair %d" % guid)
525 parameters = testbed_instance._get_parameters(mpg)
526 loss = parameters.get("Loss")
527 symmetric = parameters.get("Symmetric")
528 element.SetLoss(mas[0].element, mbs[0].element, loss, symemtric)
533 factories_create_order = ["ns3::BasicEnergySource",
534 "ns3::WifiRadioEnergyModel",
535 "ns3::BSSchedulerRtps",
536 "ns3::BSSchedulerSimple",
537 "ns3::UdpTraceClient",
543 "ns3::flame::FlameProtocol",
544 "ns3::flame::FlameRtable",
545 "ns3::dot11s::AirtimeLinkMetricCalculator",
546 "ns3::dot11s::HwmpProtocol",
547 "ns3::dot11s::HwmpRtable",
548 "ns3::dot11s::PeerManagementProtocol",
549 "ns3::dot11s::PeerLink",
550 "ns3::MeshWifiInterfaceMac",
551 "ns3::MeshPointDevice",
554 "ns3::UanPhyCalcSinrDual",
555 "ns3::UanPhyPerGenDefault",
557 "ns3::UanPropModelThorp",
559 "ns3::UanNoiseModelDefault",
561 "ns3::UanPropModelIdeal",
562 "ns3::UanTransducerHd",
563 "ns3::UanPhyCalcSinrDefault",
565 "ns3::UanPhyCalcSinrFhFsk",
566 "ns3::UanPhyPerUmodem",
569 "ns3::AthstatsWifiTraceSink",
572 "ns3::NonCommunicatingNetDevice",
573 "ns3::HalfDuplexIdealPhy",
574 "ns3::AlohaNoackNetDevice",
575 "ns3::SpectrumAnalyzer",
576 "ns3::WaveformGenerator",
577 "ns3::MultiModelSpectrumChannel",
578 "ns3::SingleModelSpectrumChannel",
579 "ns3::MsduStandardAggregator",
583 "ns3::MinstrelWifiManager",
584 "ns3::CaraWifiManager",
585 "ns3::AarfcdWifiManager",
586 "ns3::OnoeWifiManager",
587 "ns3::AmrrWifiManager",
588 "ns3::ConstantRateWifiManager",
589 "ns3::IdealWifiManager",
590 "ns3::AarfWifiManager",
591 "ns3::ArfWifiManager",
592 "ns3::WifiNetDevice",
596 "ns3::YansWifiChannel",
598 "ns3::NistErrorRateModel",
599 "ns3::YansErrorRateModel",
600 "ns3::WaypointMobilityModel",
601 "ns3::ConstantAccelerationMobilityModel",
602 "ns3::RandomDirection2dMobilityModel",
603 "ns3::RandomWalk2dMobilityModel",
604 "ns3::SteadyStateRandomWaypointMobilityModel",
605 "ns3::RandomWaypointMobilityModel",
606 "ns3::GaussMarkovMobilityModel",
607 "ns3::ConstantVelocityMobilityModel",
608 "ns3::ConstantPositionMobilityModel",
609 "ns3::ListPositionAllocator",
610 "ns3::GridPositionAllocator",
611 "ns3::RandomRectanglePositionAllocator",
612 "ns3::RandomBoxPositionAllocator",
613 "ns3::RandomDiscPositionAllocator",
614 "ns3::UniformDiscPositionAllocator",
615 "ns3::HierarchicalMobilityModel",
616 "ns3::aodv::RoutingProtocol",
617 "ns3::UdpEchoServer",
618 "ns3::UdpEchoClient",
620 "ns3::OnOffApplication",
621 "ns3::VirtualNetDevice",
623 "ns3::Nepi::TunChannel",
625 "ns3::BridgeChannel",
626 "ns3::BridgeNetDevice",
629 "ns3::CsmaNetDevice",
630 "ns3::PointToPointRemoteChannel",
631 "ns3::PointToPointChannel",
632 "ns3::PointToPointNetDevice",
633 "ns3::NscTcpL4Protocol",
634 "ns3::Icmpv6L4Protocol",
635 "ns3::Ipv6OptionPad1",
636 "ns3::Ipv6OptionPadn",
637 "ns3::Ipv6OptionJumbogram",
638 "ns3::Ipv6OptionRouterAlert",
639 "ns3::Ipv6ExtensionHopByHop",
640 "ns3::Ipv6ExtensionDestination",
641 "ns3::Ipv6ExtensionFragment",
642 "ns3::Ipv6ExtensionRouting",
643 "ns3::Ipv6ExtensionLooseRouting",
644 "ns3::Ipv6ExtensionESP",
645 "ns3::Ipv6ExtensionAH",
646 "ns3::Ipv6L3Protocol",
647 "ns3::LoopbackNetDevice",
648 "ns3::Icmpv4L4Protocol",
649 "ns3::RttMeanDeviation",
650 "ns3::ArpL3Protocol",
651 "ns3::TcpL4Protocol",
652 "ns3::UdpL4Protocol",
653 "ns3::Ipv4L3Protocol",
654 "ns3::SimpleNetDevice",
655 "ns3::SimpleChannel",
657 "ns3::DropTailQueue",
659 "ns3::FriisSpectrumPropagationLossModel",
660 "ns3::Cost231PropagationLossModel",
661 "ns3::JakesPropagationLossModel",
662 "ns3::RandomPropagationLossModel",
663 "ns3::FriisPropagationLossModel",
664 "ns3::TwoRayGroundPropagationLossModel",
665 "ns3::LogDistancePropagationLossModel",
666 "ns3::ThreeLogDistancePropagationLossModel",
667 "ns3::NakagamiPropagationLossModel",
668 "ns3::FixedRssLossModel",
669 "ns3::MatrixPropagationLossModel",
670 "ns3::Nepi::MobilityPair",
671 "ns3::RangePropagationLossModel",
672 "ns3::RandomPropagationDelayModel",
673 "ns3::ConstantSpeedPropagationDelayModel",
674 "ns3::RateErrorModel",
675 "ns3::ListErrorModel",
676 "ns3::ReceiveListErrorModel",
678 "ns3::EnergySourceContainer",
679 "ns3::BSSchedulerRtps",
680 "ns3::BSSchedulerSimple",
681 "ns3::SimpleOfdmWimaxChannel",
682 "ns3::SimpleOfdmWimaxPhy",
683 "ns3::UplinkSchedulerMBQoS",
684 "ns3::UplinkSchedulerRtps",
685 "ns3::UplinkSchedulerSimple",
686 "ns3::IpcsClassifierRecord",
688 "ns3::BaseStationNetDevice",
689 "ns3::SubscriberStationNetDevice",
692 factories_configure_order = ["ns3::BasicEnergySource",
693 "ns3::WifiRadioEnergyModel",
694 "ns3::BSSchedulerRtps",
695 "ns3::BSSchedulerSimple",
696 "ns3::UdpTraceClient",
702 "ns3::flame::FlameProtocol",
703 "ns3::flame::FlameRtable",
704 "ns3::dot11s::AirtimeLinkMetricCalculator",
705 "ns3::dot11s::HwmpProtocol",
706 "ns3::dot11s::HwmpRtable",
707 "ns3::dot11s::PeerManagementProtocol",
708 "ns3::dot11s::PeerLink",
709 "ns3::MeshWifiInterfaceMac",
710 "ns3::MeshPointDevice",
713 "ns3::UanPhyCalcSinrDual",
714 "ns3::UanPhyPerGenDefault",
716 "ns3::UanPropModelThorp",
718 "ns3::UanNoiseModelDefault",
720 "ns3::UanPropModelIdeal",
721 "ns3::UanTransducerHd",
722 "ns3::UanPhyCalcSinrDefault",
724 "ns3::UanPhyCalcSinrFhFsk",
725 "ns3::UanPhyPerUmodem",
728 "ns3::AthstatsWifiTraceSink",
731 "ns3::NonCommunicatingNetDevice",
732 "ns3::HalfDuplexIdealPhy",
733 "ns3::AlohaNoackNetDevice",
734 "ns3::SpectrumAnalyzer",
735 "ns3::WaveformGenerator",
736 "ns3::MultiModelSpectrumChannel",
737 "ns3::SingleModelSpectrumChannel",
738 "ns3::MsduStandardAggregator",
742 "ns3::MinstrelWifiManager",
743 "ns3::CaraWifiManager",
744 "ns3::AarfcdWifiManager",
745 "ns3::OnoeWifiManager",
746 "ns3::AmrrWifiManager",
747 "ns3::ConstantRateWifiManager",
748 "ns3::IdealWifiManager",
749 "ns3::AarfWifiManager",
750 "ns3::ArfWifiManager",
751 "ns3::WifiNetDevice",
755 "ns3::YansWifiChannel",
757 "ns3::NistErrorRateModel",
758 "ns3::YansErrorRateModel",
759 "ns3::WaypointMobilityModel",
760 "ns3::ConstantAccelerationMobilityModel",
761 "ns3::RandomDirection2dMobilityModel",
762 "ns3::RandomWalk2dMobilityModel",
763 "ns3::SteadyStateRandomWaypointMobilityModel",
764 "ns3::RandomWaypointMobilityModel",
765 "ns3::GaussMarkovMobilityModel",
766 "ns3::ConstantVelocityMobilityModel",
767 "ns3::ConstantPositionMobilityModel",
768 "ns3::ListPositionAllocator",
769 "ns3::GridPositionAllocator",
770 "ns3::RandomRectanglePositionAllocator",
771 "ns3::RandomBoxPositionAllocator",
772 "ns3::RandomDiscPositionAllocator",
773 "ns3::UniformDiscPositionAllocator",
774 "ns3::HierarchicalMobilityModel",
775 "ns3::aodv::RoutingProtocol",
776 "ns3::UdpEchoServer",
777 "ns3::UdpEchoClient",
779 "ns3::OnOffApplication",
780 "ns3::VirtualNetDevice",
782 "ns3::Nepi::TunChannel",
784 "ns3::BridgeChannel",
785 "ns3::BridgeNetDevice",
788 "ns3::CsmaNetDevice",
789 "ns3::PointToPointRemoteChannel",
790 "ns3::PointToPointChannel",
791 "ns3::PointToPointNetDevice",
792 "ns3::BaseStationNetDevice",
793 "ns3::SubscriberStationNetDevice",
794 "ns3::NscTcpL4Protocol",
795 "ns3::Icmpv6L4Protocol",
796 "ns3::Ipv6OptionPad1",
797 "ns3::Ipv6OptionPadn",
798 "ns3::Ipv6OptionJumbogram",
799 "ns3::Ipv6OptionRouterAlert",
800 "ns3::Ipv6ExtensionHopByHop",
801 "ns3::Ipv6ExtensionDestination",
802 "ns3::Ipv6ExtensionFragment",
803 "ns3::Ipv6ExtensionRouting",
804 "ns3::Ipv6ExtensionLooseRouting",
805 "ns3::Ipv6ExtensionESP",
806 "ns3::Ipv6ExtensionAH",
807 "ns3::Ipv6L3Protocol",
808 "ns3::LoopbackNetDevice",
809 "ns3::Icmpv4L4Protocol",
810 "ns3::RttMeanDeviation",
811 "ns3::ArpL3Protocol",
812 "ns3::TcpL4Protocol",
813 "ns3::UdpL4Protocol",
814 "ns3::Ipv4L3Protocol",
815 "ns3::SimpleNetDevice",
816 "ns3::SimpleChannel",
818 "ns3::DropTailQueue",
820 "ns3::FriisSpectrumPropagationLossModel",
821 "ns3::Cost231PropagationLossModel",
822 "ns3::JakesPropagationLossModel",
823 "ns3::RandomPropagationLossModel",
824 "ns3::FriisPropagationLossModel",
825 "ns3::TwoRayGroundPropagationLossModel",
826 "ns3::LogDistancePropagationLossModel",
827 "ns3::ThreeLogDistancePropagationLossModel",
828 "ns3::NakagamiPropagationLossModel",
829 "ns3::FixedRssLossModel",
830 "ns3::MatrixPropagationLossModel",
831 "ns3::Nepi::MobilityPair",
832 "ns3::RangePropagationLossModel",
833 "ns3::RandomPropagationDelayModel",
834 "ns3::ConstantSpeedPropagationDelayModel",
835 "ns3::RateErrorModel",
836 "ns3::ListErrorModel",
837 "ns3::ReceiveListErrorModel",
839 "ns3::EnergySourceContainer",
840 "ns3::BSSchedulerRtps",
841 "ns3::BSSchedulerSimple",
842 "ns3::SimpleOfdmWimaxChannel",
843 "ns3::SimpleOfdmWimaxPhy",
844 "ns3::UplinkSchedulerMBQoS",
845 "ns3::UplinkSchedulerRtps",
846 "ns3::UplinkSchedulerSimple",
847 "ns3::IpcsClassifierRecord",
852 factories_info = dict({
854 "category": FC.CATEGORY_APPLICATIONS,
855 "create_function": create_element,
856 "configure_function": configure_element,
857 "stop_function": stop_application,
858 "start_function": start_application,
859 "status_function": status_application,
861 "connector_types": [],
862 "box_attributes": ["MaxPackets",
869 "tags": [tags.APPLICATION],
871 "ns3::UdpL4Protocol": dict({
872 "category": FC.CATEGORY_PROTOCOLS,
873 "create_function": create_element,
874 "configure_function": configure_element,
876 "connector_types": ["node"],
877 "box_attributes": ["ProtocolNumber"],
878 "tags": [tags.PROTOCOL],
880 "ns3::RandomDiscPositionAllocator": dict({
881 "category": FC.CATEGORY_MOBILITY_MODELS,
882 "create_function": create_element,
883 "configure_function": configure_element,
885 "connector_types": [],
886 "box_attributes": ["Theta",
890 "tags": [tags.MOBILE],
893 "category": FC.CATEGORY_NODES,
894 "create_function": create_node,
895 "configure_function": configure_node,
897 "connector_types": ["devs", "apps", "protos", "mobility"],
898 "box_attributes": ["Up"],
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", "mp"],
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_wifi_mac,
1069 "configure_function": configure_element,
1071 "connector_types": ["dev"],
1072 "box_attributes": ["CtsTimeout",
1074 "BasicBlockAckTimeout",
1075 "CompressedBlockAckTimeout",
1080 "MaxPropagationDelay",
1085 "ns3::ConstantAccelerationMobilityModel": dict({
1086 "category": FC.CATEGORY_MOBILITY_MODELS,
1087 "create_function": create_element,
1088 "configure_function": configure_element,
1090 "connector_types": ["node", "mp"],
1091 "box_attributes": ["Position",
1093 "tags": [tags.MOBILE],
1095 "ns3::GaussMarkovMobilityModel": dict({
1096 "category": FC.CATEGORY_MOBILITY_MODELS,
1097 "create_function": create_element,
1098 "configure_function": configure_element,
1100 "connector_types": [],
1101 "box_attributes": ["Bounds",
1112 "tags": [tags.MOBILE],
1114 "ns3::dot11s::HwmpProtocol": dict({
1115 "category": FC.CATEGORY_PROTOCOLS,
1116 "create_function": create_element,
1117 "configure_function": configure_element,
1119 "connector_types": [],
1120 "box_attributes": ["RandomStart",
1122 "Dot11MeshHWMPmaxPREQretries",
1123 "Dot11MeshHWMPnetDiameterTraversalTime",
1124 "Dot11MeshHWMPpreqMinInterval",
1125 "Dot11MeshHWMPperrMinInterval",
1126 "Dot11MeshHWMPactiveRootTimeout",
1127 "Dot11MeshHWMPactivePathTimeout",
1128 "Dot11MeshHWMPpathToRootInterval",
1129 "Dot11MeshHWMPrannInterval",
1131 "UnicastPerrThreshold",
1132 "UnicastPreqThreshold",
1133 "UnicastDataThreshold",
1137 "ns3::NscTcpL4Protocol": dict({
1138 "category": FC.CATEGORY_PROTOCOLS,
1139 "create_function": create_element,
1140 "configure_function": configure_element,
1142 "connector_types": [],
1143 "box_attributes": ["Library",
1146 "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
1148 "create_function": create_element,
1149 "configure_function": configure_element,
1151 "connector_types": [],
1152 "box_attributes": ["Dot11sMeshHeaderLength"],
1154 "ns3::UanMacCw": dict({
1156 "create_function": create_element,
1157 "configure_function": configure_element,
1159 "connector_types": [],
1160 "box_attributes": ["CW",
1163 "ns3::AthstatsWifiTraceSink": dict({
1165 "create_function": create_element,
1166 "configure_function": configure_element,
1168 "connector_types": [],
1169 "box_attributes": ["Interval"],
1171 "ns3::FlameStack": dict({
1173 "create_function": create_element,
1174 "configure_function": configure_element,
1176 "connector_types": [],
1177 "box_attributes": [],
1179 "ns3::UanMacRc": dict({
1181 "create_function": create_element,
1182 "configure_function": configure_element,
1184 "connector_types": [],
1185 "box_attributes": ["RetryRate",
1192 "NumberOfRetryRates",
1195 "ns3::WaypointMobilityModel": dict({
1196 "category": FC.CATEGORY_MOBILITY_MODELS,
1197 "create_function": create_waypoint_mobility,
1198 "configure_function": configure_element,
1199 "help": "Waypoint-based mobility model.",
1200 "connector_types": ["node"],
1201 "box_attributes": ["WaypointsLeft",
1205 "tags": [tags.MOBILE],
1207 "ns3::FdNetDevice": dict({
1208 "category": FC.CATEGORY_DEVICES,
1209 "create_function": create_element,
1210 "configure_function": configure_device,
1211 "help": "Network interface associated to a file descriptor",
1212 "connector_types": ["node", "->fd"],
1213 "box_attributes": ["Address",
1214 "tun_proto", "tun_addr", "tun_port", "tun_key", "tun_cipher_fdnd"],
1215 "traces": ["fdpcap", "fdascii"],
1216 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1218 "ns3::Nepi::TunChannel": dict({
1219 "category": FC.CATEGORY_TUNNELS,
1220 "create_function": create_tunchannel,
1221 "preconfigure_function": preconfigure_tunchannel,
1222 "configure_function": postconfigure_tunchannel,
1223 "prestart_function": prestart_tunchannel,
1224 "help": "Channel to forward FdNetDevice data to "
1225 "other TAP interfaces supporting the NEPI tunneling protocol.",
1226 "connector_types": ["fd->", "udp", "tcp"],
1227 "allow_addresses": False,
1228 "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key","tun_cipher"],
1229 "tags": [tags.TUNNEL],
1232 "ns3::CsmaNetDevice": dict({
1233 "category": FC.CATEGORY_DEVICES,
1234 "create_function": create_element,
1235 "configure_function": configure_device,
1236 "help": "CSMA (carrier sense, multiple access) interface",
1237 "connector_types": ["node", "chan", "err", "queue"],
1238 "box_attributes": ["Address",
1242 "traces": ["csmapcap", "csmapcap_promisc"],
1243 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1245 "ns3::UanPropModelThorp": dict({
1247 "create_function": create_element,
1248 "configure_function": configure_element,
1250 "connector_types": [],
1251 "box_attributes": ["SpreadCoef"],
1253 "ns3::Icmpv6L4Protocol": dict({
1254 "category": FC.CATEGORY_PROTOCOLS,
1255 "create_function": create_element,
1256 "configure_function": configure_element,
1258 "connector_types": ["node"],
1259 "box_attributes": ["DAD",
1262 "ns3::SimpleNetDevice": dict({
1263 "category": FC.CATEGORY_DEVICES,
1264 "create_function": create_element,
1265 "configure_function": configure_element,
1267 "connector_types": ["node", "chan"],
1268 "box_attributes": [],
1269 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1271 "ns3::FriisPropagationLossModel": dict({
1272 "category": FC.CATEGORY_LOSS_MODELS,
1273 "create_function": create_element,
1274 "configure_function": configure_element,
1276 "connector_types": [],
1277 "box_attributes": ["Lambda",
1281 "ns3::Ipv6OptionRouterAlert": dict({
1283 "create_function": create_element,
1284 "configure_function": configure_element,
1286 "connector_types": [],
1287 "box_attributes": ["OptionNumber"],
1289 "ns3::UniformDiscPositionAllocator": dict({
1290 "category": FC.CATEGORY_MOBILITY_MODELS,
1291 "create_function": create_element,
1292 "configure_function": configure_element,
1294 "connector_types": [],
1295 "box_attributes": ["rho",
1298 "tags": [tags.MOBILE],
1300 "ns3::RandomBoxPositionAllocator": dict({
1301 "category": FC.CATEGORY_MOBILITY_MODELS,
1302 "create_function": create_element,
1303 "configure_function": configure_element,
1305 "connector_types": [],
1306 "box_attributes": ["X",
1309 "tags": [tags.MOBILE],
1311 "ns3::Ipv6ExtensionDestination": dict({
1313 "create_function": create_element,
1314 "configure_function": configure_element,
1316 "connector_types": [],
1317 "box_attributes": ["ExtensionNumber"],
1319 "ns3::LoopbackNetDevice": dict({
1320 "category": FC.CATEGORY_DEVICES,
1321 "create_function": create_element,
1322 "configure_function": configure_element,
1324 "connector_types": [],
1325 "box_attributes": [],
1326 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1328 "ns3::ConstantSpeedPropagationDelayModel": dict({
1329 "category": FC.CATEGORY_DELAY_MODELS,
1330 "create_function": create_element,
1331 "configure_function": configure_element,
1333 "connector_types": ["chan"],
1334 "box_attributes": ["Speed"],
1336 "ns3::Ipv6ExtensionHopByHop": dict({
1338 "create_function": create_element,
1339 "configure_function": configure_element,
1341 "connector_types": [],
1342 "box_attributes": ["ExtensionNumber"],
1344 "ns3::BridgeChannel": dict({
1345 "category": FC.CATEGORY_CHANNELS,
1346 "create_function": create_element,
1347 "configure_function": configure_element,
1349 "connector_types": [],
1350 "box_attributes": [],
1352 "ns3::Radvd": dict({
1354 "create_function": create_element,
1355 "configure_function": configure_element,
1357 "connector_types": [],
1358 "box_attributes": ["StartTime",
1361 "ns3::PacketSocket": dict({
1363 "create_function": create_element,
1364 "configure_function": configure_element,
1366 "connector_types": [],
1367 "box_attributes": ["RcvBufSize"],
1369 "ns3::flame::FlameProtocol": dict({
1370 "category": FC.CATEGORY_PROTOCOLS,
1371 "create_function": create_element,
1372 "configure_function": configure_element,
1374 "connector_types": [],
1375 "box_attributes": ["BroadcastInterval",
1378 "ns3::Cost231PropagationLossModel": dict({
1379 "category": FC.CATEGORY_LOSS_MODELS,
1380 "create_function": create_element,
1381 "configure_function": configure_element,
1383 "connector_types": [],
1384 "box_attributes": ["Lambda",
1390 "ns3::Ipv6ExtensionESP": dict({
1392 "create_function": create_element,
1393 "configure_function": configure_element,
1395 "connector_types": [],
1396 "box_attributes": ["ExtensionNumber"],
1398 "ns3::CaraWifiManager": dict({
1399 "category": FC.CATEGORY_MANAGERS,
1400 "create_function": create_element,
1401 "configure_function": configure_element,
1403 "connector_types": ["dev"],
1404 "box_attributes": ["ProbeThreshold",
1412 "FragmentationThreshold",
1416 "ns3::RttMeanDeviation": dict({
1418 "create_function": create_element,
1419 "configure_function": configure_element,
1421 "connector_types": [],
1422 "box_attributes": ["Gain",
1424 "InitialEstimation",
1427 "ns3::Icmpv4L4Protocol": dict({
1428 "category": FC.CATEGORY_PROTOCOLS,
1429 "create_function": create_element,
1430 "configure_function": configure_element,
1432 "connector_types": ["node"],
1433 "box_attributes": ["ProtocolNumber"],
1435 "ns3::WaveformGenerator": dict({
1437 "create_function": create_element,
1438 "configure_function": configure_element,
1440 "connector_types": [],
1441 "box_attributes": ["Period",
1444 "ns3::YansWifiChannel": dict({
1445 "category": FC.CATEGORY_CHANNELS,
1446 "create_function": create_element,
1447 "configure_function": configure_element,
1449 "connector_types": ["phys", "delay", "loss"],
1450 "box_attributes": [],
1452 "ns3::SimpleChannel": dict({
1453 "category": FC.CATEGORY_CHANNELS,
1454 "create_function": create_element,
1455 "configure_function": configure_element,
1457 "connector_types": ["devs"],
1458 "box_attributes": [],
1460 "ns3::Ipv6ExtensionFragment": dict({
1462 "create_function": create_element,
1463 "configure_function": configure_element,
1465 "connector_types": [],
1466 "box_attributes": ["ExtensionNumber"],
1468 "ns3::Dot11sStack": dict({
1470 "create_function": create_element,
1471 "configure_function": configure_element,
1473 "connector_types": [],
1474 "box_attributes": ["Root"],
1476 "ns3::FriisSpectrumPropagationLossModel": dict({
1477 "category": FC.CATEGORY_LOSS_MODELS,
1478 "create_function": create_element,
1479 "configure_function": configure_element,
1481 "connector_types": [],
1482 "box_attributes": [],
1484 "ns3::RandomRectanglePositionAllocator": dict({
1485 "category": FC.CATEGORY_MOBILITY_MODELS,
1486 "create_function": create_element,
1487 "configure_function": configure_element,
1489 "connector_types": [],
1490 "box_attributes": ["X",
1492 "tags": [tags.MOBILE],
1494 "ns3::HierarchicalMobilityModel": dict({
1495 "category": FC.CATEGORY_MOBILITY_MODELS,
1496 "create_function": create_element,
1497 "configure_function": configure_element,
1499 "connector_types": ["node"],
1500 "box_attributes": ["Position",
1502 "tags": [tags.MOBILE],
1504 "ns3::ThreeLogDistancePropagationLossModel": dict({
1505 "category": FC.CATEGORY_LOSS_MODELS,
1506 "create_function": create_element,
1507 "configure_function": configure_element,
1509 "connector_types": [],
1510 "box_attributes": ["Distance0",
1518 "ns3::UanNoiseModelDefault": dict({
1520 "create_function": create_element,
1521 "configure_function": configure_element,
1523 "connector_types": [],
1524 "box_attributes": ["Wind",
1527 "ns3::dot11s::HwmpRtable": dict({
1529 "create_function": create_element,
1530 "configure_function": configure_element,
1532 "connector_types": [],
1533 "box_attributes": [],
1535 "ns3::PacketBurst": dict({
1537 "create_function": create_element,
1538 "configure_function": configure_element,
1540 "connector_types": [],
1541 "box_attributes": [],
1543 "ns3::RandomPropagationDelayModel": dict({
1544 "category": FC.CATEGORY_DELAY_MODELS,
1545 "create_function": create_element,
1546 "configure_function": configure_element,
1548 "connector_types": [],
1549 "box_attributes": ["Variable"],
1551 "ns3::ArpL3Protocol": dict({
1552 "category": FC.CATEGORY_PROTOCOLS,
1553 "create_function": create_element,
1554 "configure_function": configure_element,
1556 "connector_types": ["node"],
1557 "box_attributes": [],
1559 "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1560 "category": FC.CATEGORY_MOBILITY_MODELS,
1561 "create_function": create_element,
1562 "configure_function": configure_element,
1564 "connector_types": [],
1565 "box_attributes": ["MinSpeed",
1575 "tags": [tags.MOBILE],
1577 "ns3::BaseStationNetDevice": dict({
1578 "category": FC.CATEGORY_DEVICES,
1579 "create_function": create_base_station,
1580 "configure_function": configure_station,
1581 "help": "Base station for wireless mobile network",
1582 "connector_types": ["node", "chan", "phy", "uplnk", "dwnlnk"],
1583 "box_attributes": ["InitialRangInterval",
1589 "MaxRangCorrectionRetries",
1593 "traces": ["wimaxpcap", "wimaxascii"],
1594 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1596 "ns3::UdpServer": dict({
1597 "category": FC.CATEGORY_APPLICATIONS,
1598 "create_function": create_element,
1599 "configure_function": configure_element,
1601 "connector_types": ["node"],
1602 "stop_function": stop_application,
1603 "start_function": start_application,
1604 "status_function": status_application,
1605 "box_attributes": ["Port",
1610 "ns3::AarfcdWifiManager": dict({
1611 "category": FC.CATEGORY_MANAGERS,
1612 "create_function": create_element,
1613 "configure_function": configure_element,
1615 "connector_types": ["dev"],
1616 "box_attributes": ["SuccessK",
1618 "MaxSuccessThreshold",
1619 "MinTimerThreshold",
1620 "MinSuccessThreshold",
1623 "TurnOffRtsAfterRateDecrease",
1624 "TurnOnRtsAfterRateIncrease",
1629 "FragmentationThreshold",
1632 "ns3::UanTransducerHd": dict({
1634 "create_function": create_element,
1635 "configure_function": configure_element,
1637 "connector_types": [],
1638 "box_attributes": [],
1640 "ns3::LogDistancePropagationLossModel": dict({
1641 "category": FC.CATEGORY_LOSS_MODELS,
1642 "create_function": create_element,
1643 "configure_function": configure_element,
1645 "connector_types": ["prev", "next"],
1646 "box_attributes": ["Exponent",
1647 "ReferenceDistance",
1650 "ns3::EmuNetDevice": dict({
1651 "category": FC.CATEGORY_DEVICES,
1652 "create_function": create_element,
1653 "configure_function": configure_element,
1655 "connector_types": ["node", "queue"],
1656 "box_attributes": ["Mtu",
1662 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1664 "ns3::Ipv6ExtensionLooseRouting": dict({
1665 "category": FC.CATEGORY_ROUTING,
1666 "create_function": create_element,
1667 "configure_function": configure_element,
1669 "connector_types": [],
1670 "box_attributes": ["ExtensionNumber"],
1672 "ns3::RandomWaypointMobilityModel": dict({
1673 "category": FC.CATEGORY_MOBILITY_MODELS,
1674 "create_function": create_element,
1675 "configure_function": configure_element,
1677 "connector_types": ["node"],
1678 "box_attributes": ["Speed",
1682 "tags": [tags.MOBILE],
1684 "ns3::RangePropagationLossModel": dict({
1685 "category": FC.CATEGORY_LOSS_MODELS,
1686 "create_function": create_element,
1687 "configure_function": configure_element,
1689 "connector_types": [],
1690 "box_attributes": ["MaxRange"],
1692 "ns3::AlohaNoackNetDevice": dict({
1693 "category": FC.CATEGORY_DEVICES,
1694 "create_function": create_element,
1695 "configure_function": configure_element,
1697 "connector_types": [],
1698 "box_attributes": ["Address",
1700 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1702 "ns3::MatrixPropagationLossModel": dict({
1703 "category": FC.CATEGORY_LOSS_MODELS,
1704 "create_function": create_element,
1705 "configure_function": configure_matrix_propagation,
1707 "connector_types": ["mobpair", "chan"],
1708 "box_attributes": ["DefaultLoss"],
1710 "ns3::Nepi::MobilityPair": dict({
1711 "category": FC.CATEGORY_LOSS_MODELS,
1713 "connector_types": ["matrix", "ma", "mb"],
1714 "box_attributes": ["Loss", "Symmetric"],
1716 "ns3::WifiNetDevice": dict({
1717 "category": FC.CATEGORY_DEVICES,
1718 "create_function": create_element,
1719 "configure_function": configure_device,
1721 "connector_types": ["node", "mac", "phy", "manager"],
1722 "box_attributes": ["Mtu"],
1723 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1725 "ns3::CsmaChannel": dict({
1726 "category": FC.CATEGORY_CHANNELS,
1727 "create_function": create_element,
1728 "configure_function": configure_element,
1730 "connector_types": ["devs"],
1731 "box_attributes": ["DataRate",
1734 "ns3::BridgeNetDevice": dict({
1735 "category": FC.CATEGORY_DEVICES,
1736 "create_function": create_element,
1737 "configure_function": configure_element,
1739 "connector_types": ["node"],
1740 "box_attributes": ["Mtu",
1743 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1745 "ns3::Ipv6ExtensionRouting": dict({
1746 "category": FC.CATEGORY_ROUTING,
1747 "create_function": create_element,
1748 "configure_function": configure_element,
1750 "connector_types": [],
1751 "box_attributes": ["ExtensionNumber"],
1753 "ns3::StaWifiMac": dict({
1754 "category": FC.CATEGORY_MAC_MODELS,
1755 "create_function": create_wifi_mac,
1756 "configure_function": configure_element,
1757 "help": "Station Wifi MAC Model",
1758 "connector_types": ["dev"],
1759 "box_attributes": ["ProbeRequestTimeout",
1760 "AssocRequestTimeout",
1764 "BasicBlockAckTimeout",
1765 "CompressedBlockAckTimeout",
1770 "MaxPropagationDelay",
1775 "ns3::UdpEchoClient": dict({
1776 "category": FC.CATEGORY_APPLICATIONS,
1777 "create_function": create_element,
1778 "configure_function": configure_element,
1780 "connector_types": ["node"],
1781 "stop_function": stop_application,
1782 "start_function": start_application,
1783 "status_function": status_application,
1784 "box_attributes": ["MaxPackets",
1791 "tags": [tags.APPLICATION],
1793 "ns3::UdpClient": dict({
1794 "category": FC.CATEGORY_APPLICATIONS,
1795 "create_function": create_element,
1796 "configure_function": configure_element,
1798 "connector_types": ["node"],
1799 "stop_function": stop_application,
1800 "start_function": start_application,
1801 "status_function": status_application,
1802 "box_attributes": ["MaxPackets",
1809 "tags": [tags.APPLICATION],
1811 "ns3::PointToPointChannel": dict({
1812 "category": FC.CATEGORY_CHANNELS,
1813 "create_function": create_element,
1814 "configure_function": configure_element,
1816 "connector_types": ["dev2"],
1817 "box_attributes": ["Delay"],
1819 "ns3::Ipv6StaticRouting": dict({
1820 "category": FC.CATEGORY_ROUTING,
1821 "create_function": create_element,
1822 "configure_function": configure_element,
1824 "connector_types": [],
1825 "box_attributes": [],
1827 "ns3::DropTailQueue": dict({
1828 "category": FC.CATEGORY_QUEUES,
1829 "create_function": create_element,
1830 "configure_function": configure_element,
1832 "connector_types": ["dev"],
1833 "box_attributes": ["MaxPackets",
1836 "ns3::ConstantPositionMobilityModel": dict({
1837 "category": FC.CATEGORY_MOBILITY_MODELS,
1838 "create_function": create_element,
1839 "configure_function": configure_element,
1841 "connector_types": ["node", "mp"],
1842 "box_attributes": ["Position",
1844 "tags": [tags.MOBILE],
1846 "ns3::FixedRssLossModel": dict({
1847 "category": FC.CATEGORY_LOSS_MODELS,
1848 "create_function": create_element,
1849 "configure_function": configure_element,
1851 "connector_types": [],
1852 "box_attributes": ["Rss"],
1854 "ns3::EnergySourceContainer": dict({
1855 "category": FC.CATEGORY_ENERGY_MODELS,
1856 "create_function": create_element,
1857 "configure_function": configure_element,
1859 "connector_types": [],
1860 "box_attributes": [],
1862 "ns3::RandomWalk2dMobilityModel": dict({
1863 "category": FC.CATEGORY_MOBILITY_MODELS,
1864 "create_function": create_element,
1865 "configure_function": configure_element,
1867 "connector_types": ["node"],
1868 "box_attributes": ["Bounds",
1876 "tags": [tags.MOBILE],
1878 "ns3::ListPositionAllocator": dict({
1880 "create_function": create_element,
1881 "configure_function": configure_element,
1883 "connector_types": [],
1884 "box_attributes": [],
1886 "ns3::dot11s::PeerManagementProtocol": dict({
1887 "category": FC.CATEGORY_PROTOCOLS,
1888 "create_function": create_element,
1889 "configure_function": configure_element,
1891 "connector_types": [],
1892 "box_attributes": ["MaxNumberOfPeerLinks",
1893 "MaxBeaconShiftValue",
1894 "EnableBeaconCollisionAvoidance"],
1896 "ns3::MeshPointDevice": dict({
1897 "category": FC.CATEGORY_DEVICES,
1898 "create_function": create_element,
1899 "configure_function": configure_element,
1901 "connector_types": [],
1902 "box_attributes": ["Mtu"],
1903 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1905 "ns3::BasicEnergySource": dict({
1906 "category": FC.CATEGORY_ENERGY_MODELS,
1907 "create_function": create_element,
1908 "configure_function": configure_element,
1910 "connector_types": [],
1911 "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1912 "BasicEnergySupplyVoltageV",
1913 "PeriodicEnergyUpdateInterval"],
1915 "ns3::Ipv6OptionPadn": dict({
1917 "create_function": create_element,
1918 "configure_function": configure_element,
1920 "connector_types": [],
1921 "box_attributes": ["OptionNumber"],
1923 "ns3::ApWifiMac": dict({
1924 "category": FC.CATEGORY_MAC_MODELS,
1925 "create_function": create_wifi_mac,
1926 "configure_function": configure_element,
1927 "help": "Access point Wifi MAC Model",
1928 "connector_types": ["dev"],
1929 "box_attributes": ["BeaconInterval",
1933 "BasicBlockAckTimeout",
1934 "CompressedBlockAckTimeout",
1939 "MaxPropagationDelay",
1944 "ns3::YansErrorRateModel": dict({
1945 "category": FC.CATEGORY_ERROR_MODELS,
1946 "create_function": create_element,
1947 "configure_function": configure_element,
1949 "connector_types": [],
1950 "box_attributes": [],
1952 "ns3::WifiMacQueue": dict({
1953 "category": FC.CATEGORY_QUEUES,
1954 "create_function": create_element,
1955 "configure_function": configure_element,
1957 "connector_types": [],
1958 "box_attributes": ["MaxPacketNumber",
1961 "ns3::NonCommunicatingNetDevice": dict({
1962 "category": FC.CATEGORY_DEVICES,
1963 "create_function": create_element,
1964 "configure_function": configure_element,
1966 "connector_types": [],
1967 "box_attributes": [],
1968 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1970 "ns3::RateErrorModel": dict({
1971 "category": FC.CATEGORY_ERROR_MODELS,
1972 "create_function": create_element,
1973 "configure_function": configure_element,
1975 "connector_types": [],
1976 "box_attributes": ["ErrorUnit",
1981 "ns3::MeshWifiInterfaceMac": dict({
1982 "category": FC.CATEGORY_MAC_MODELS,
1983 "create_function": create_element,
1984 "configure_function": configure_element,
1986 "connector_types": [],
1987 "box_attributes": ["BeaconInterval",
1992 "BasicBlockAckTimeout",
1993 "CompressedBlockAckTimeout",
1998 "MaxPropagationDelay",
2001 "ns3::UanPhyCalcSinrDual": dict({
2003 "create_function": create_element,
2004 "configure_function": configure_element,
2006 "connector_types": [],
2007 "box_attributes": [],
2009 "ns3::Ipv6ExtensionAH": dict({
2011 "create_function": create_element,
2012 "configure_function": configure_element,
2014 "connector_types": [],
2015 "box_attributes": ["ExtensionNumber"],
2017 "ns3::SingleModelSpectrumChannel": dict({
2018 "category": FC.CATEGORY_CHANNELS,
2019 "create_function": create_element,
2020 "configure_function": configure_element,
2022 "connector_types": [],
2023 "box_attributes": [],
2025 "ns3::YansWifiPhy": dict({
2026 "category": FC.CATEGORY_PHY_MODELS,
2027 "create_function": create_wifi_phy,
2028 "configure_function": configure_element,
2030 "connector_types": ["dev", "err", "chan"],
2031 "box_attributes": ["EnergyDetectionThreshold",
2032 "CcaMode1Threshold",
2039 "ChannelSwitchDelay",
2042 "traces": ["yanswifipcap"]
2044 "ns3::WifiRadioEnergyModel": dict({
2045 "category": FC.CATEGORY_ENERGY_MODELS,
2046 "create_function": create_element,
2047 "configure_function": configure_element,
2049 "connector_types": [],
2050 "box_attributes": ["TxCurrentA",
2055 "ns3::EdcaTxopN": dict({
2057 "create_function": create_element,
2058 "configure_function": configure_element,
2060 "connector_types": [],
2061 "box_attributes": ["BlockAckThreshold",
2066 "ns3::UanPhyPerGenDefault": dict({
2068 "create_function": create_element,
2069 "configure_function": configure_element,
2071 "connector_types": [],
2072 "box_attributes": ["Threshold"],
2074 "ns3::IdealWifiManager": dict({
2075 "category": FC.CATEGORY_MANAGERS,
2076 "create_function": create_element,
2077 "configure_function": configure_element,
2079 "connector_types": ["dev"],
2080 "box_attributes": ["BerThreshold",
2085 "FragmentationThreshold",
2088 "ns3::MultiModelSpectrumChannel": dict({
2089 "category": FC.CATEGORY_CHANNELS,
2090 "create_function": create_element,
2091 "configure_function": configure_element,
2093 "connector_types": [],
2094 "box_attributes": [],
2096 "ns3::HalfDuplexIdealPhy": dict({
2097 "category": FC.CATEGORY_PHY_MODELS,
2098 "create_function": create_element,
2099 "configure_function": configure_element,
2101 "connector_types": [],
2102 "box_attributes": ["Rate"],
2104 "ns3::UanPhyCalcSinrDefault": dict({
2105 "category": FC.CATEGORY_PHY_MODELS,
2106 "create_function": create_element,
2107 "configure_function": configure_element,
2109 "connector_types": [],
2110 "box_attributes": [],
2112 "ns3::ReceiveListErrorModel": dict({
2113 "category": FC.CATEGORY_ERROR_MODELS,
2114 "create_function": create_element,
2115 "configure_function": configure_element,
2117 "connector_types": [],
2118 "box_attributes": ["IsEnabled"],
2120 "ns3::SpectrumAnalyzer": dict({
2122 "create_function": create_element,
2123 "configure_function": configure_element,
2125 "connector_types": [],
2126 "box_attributes": ["Resolution",
2127 "NoisePowerSpectralDensity"],
2129 "ns3::ConstantRateWifiManager": dict({
2130 "category": FC.CATEGORY_MANAGERS,
2131 "create_function": create_element,
2132 "configure_function": configure_element,
2134 "connector_types": ["dev"],
2135 "box_attributes": ["DataMode",
2141 "FragmentationThreshold",
2144 "ns3::Ipv6OptionPad1": dict({
2146 "create_function": create_element,
2147 "configure_function": configure_element,
2149 "connector_types": [],
2150 "box_attributes": ["OptionNumber"],
2152 "ns3::UdpTraceClient": dict({
2154 "create_function": create_element,
2155 "configure_function": configure_element,
2157 "connector_types": [],
2158 "box_attributes": ["RemoteAddress",
2164 "ns3::RraaWifiManager": dict({
2165 "category": FC.CATEGORY_MANAGERS,
2166 "create_function": create_element,
2167 "configure_function": configure_element,
2169 "connector_types": ["dev"],
2170 "box_attributes": ["Basic",
2198 "FragmentationThreshold",
2201 "ns3::RandomPropagationLossModel": dict({
2202 "category": FC.CATEGORY_LOSS_MODELS,
2203 "create_function": create_element,
2204 "configure_function": configure_element,
2206 "connector_types": [],
2207 "box_attributes": ["Variable"],
2209 "ns3::UanChannel": dict({
2210 "category": FC.CATEGORY_CHANNELS,
2211 "create_function": create_element,
2212 "configure_function": configure_element,
2214 "connector_types": [],
2215 "box_attributes": [],
2217 "ns3::MinstrelWifiManager": dict({
2218 "category": FC.CATEGORY_MANAGERS,
2219 "create_function": create_element,
2220 "configure_function": configure_element,
2222 "connector_types": ["dev"],
2223 "box_attributes": ["UpdateStatistics",
2233 "FragmentationThreshold",
2236 "ns3::UanPhyDual": dict({
2237 "category": FC.CATEGORY_PHY_MODELS,
2238 "create_function": create_element,
2239 "configure_function": configure_element,
2241 "connector_types": [],
2242 "box_attributes": ["CcaThresholdPhy1",
2248 "SupportedModesPhy1",
2249 "SupportedModesPhy2"],
2251 "ns3::ListErrorModel": dict({
2252 "category": FC.CATEGORY_ERROR_MODELS,
2253 "create_function": create_element,
2254 "configure_function": configure_element,
2256 "connector_types": ["dev"],
2257 "box_attributes": ["IsEnabled"],
2259 "ns3::VirtualNetDevice": dict({
2260 "category": FC.CATEGORY_DEVICES,
2261 "create_function": create_element,
2262 "configure_function": configure_element,
2264 "connector_types": [],
2265 "box_attributes": ["Mtu"],
2266 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2268 "ns3::UanPhyGen": dict({
2269 "category": FC.CATEGORY_PHY_MODELS,
2270 "create_function": create_element,
2271 "configure_function": configure_element,
2273 "connector_types": [],
2274 "box_attributes": ["CcaThreshold",
2280 "ns3::Ipv6L3Protocol": dict({
2281 "category": FC.CATEGORY_PROTOCOLS,
2282 "create_function": create_element,
2283 "configure_function": configure_element,
2285 "connector_types": ["node"],
2286 "box_attributes": ["DefaultTtl",
2289 "ns3::PointToPointRemoteChannel": dict({
2290 "category": FC.CATEGORY_CHANNELS,
2291 "create_function": create_element,
2292 "configure_function": configure_element,
2294 "connector_types": [],
2295 "box_attributes": ["Delay"],
2297 "ns3::UanPhyPerUmodem": dict({
2298 "category": FC.CATEGORY_PHY_MODELS,
2299 "create_function": create_element,
2300 "configure_function": configure_element,
2302 "connector_types": [],
2303 "box_attributes": [],
2305 "ns3::OnoeWifiManager": dict({
2306 "category": FC.CATEGORY_MANAGERS,
2307 "create_function": create_element,
2308 "configure_function": configure_element,
2310 "connector_types": ["dev"],
2311 "box_attributes": ["UpdatePeriod",
2313 "AddCreditThreshold",
2318 "FragmentationThreshold",
2321 "ns3::JakesPropagationLossModel": dict({
2322 "category": FC.CATEGORY_LOSS_MODELS,
2323 "create_function": create_element,
2324 "configure_function": configure_element,
2326 "connector_types": [],
2327 "box_attributes": ["NumberOfRaysPerPath",
2328 "NumberOfOscillatorsPerRay",
2332 "ns3::PacketSink": dict({
2333 "category": FC.CATEGORY_APPLICATIONS,
2334 "create_function": create_element,
2335 "configure_function": configure_element,
2337 "connector_types": ["node"],
2338 "stop_function": stop_application,
2339 "start_function": start_application,
2340 "status_function": status_application,
2341 "box_attributes": ["Local",
2345 "tags": [tags.APPLICATION],
2347 "ns3::RandomDirection2dMobilityModel": dict({
2348 "category": FC.CATEGORY_MOBILITY_MODELS,
2349 "create_function": create_element,
2350 "configure_function": configure_element,
2352 "connector_types": ["node"],
2353 "box_attributes": ["Bounds",
2358 "tags": [tags.MOBILE],
2360 "ns3::UanMacAloha": dict({
2362 "create_function": create_element,
2363 "configure_function": configure_element,
2365 "connector_types": [],
2366 "box_attributes": [],
2368 "ns3::MsduStandardAggregator": dict({
2370 "create_function": create_element,
2371 "configure_function": configure_element,
2373 "connector_types": [],
2374 "box_attributes": ["MaxAmsduSize"],
2376 "ns3::DcaTxop": dict({
2378 "create_function": create_element,
2379 "configure_function": configure_element,
2381 "connector_types": [],
2382 "box_attributes": ["MinCw",
2386 "ns3::UanPhyCalcSinrFhFsk": dict({
2387 "category": FC.CATEGORY_PHY_MODELS,
2388 "create_function": create_element,
2389 "configure_function": configure_element,
2391 "connector_types": [],
2392 "box_attributes": ["NumberOfHops"],
2394 "ns3::UanPropModelIdeal": dict({
2396 "create_function": create_element,
2397 "configure_function": configure_element,
2399 "connector_types": [],
2400 "box_attributes": [],
2402 "ns3::UanMacRcGw": dict({
2404 "create_function": create_element,
2405 "configure_function": configure_element,
2407 "connector_types": [],
2408 "box_attributes": ["MaxReservations",
2416 "NumberOfRetryRates",
2421 "ns3::NistErrorRateModel": dict({
2422 "category": FC.CATEGORY_ERROR_MODELS,
2423 "create_function": create_element,
2424 "configure_function": configure_element,
2426 "connector_types": ["phy"],
2427 "box_attributes": [],
2429 "ns3::Ipv4L3Protocol": dict({
2430 "category": FC.CATEGORY_PROTOCOLS,
2431 "create_function": create_ipv4protocol,
2432 "configure_function": configure_element,
2434 "connector_types": ["node"],
2435 "box_attributes": ["DefaultTtl",
2439 "ns3::aodv::RoutingProtocol": dict({
2440 "category": FC.CATEGORY_PROTOCOLS,
2441 "create_function": create_element,
2442 "configure_function": configure_element,
2444 "connector_types": [],
2445 "box_attributes": ["HelloInterval",
2448 "NodeTraversalTime",
2450 "ActiveRouteTimeout",
2457 "PathDiscoveryTime",
2466 "ns3::TcpL4Protocol": dict({
2467 "category": FC.CATEGORY_PROTOCOLS,
2468 "create_function": create_element,
2469 "configure_function": configure_element,
2471 "connector_types": ["node"],
2472 "box_attributes": ["RttEstimatorFactory",
2475 "ns3::olsr::RoutingProtocol": dict({
2476 "category": FC.CATEGORY_PROTOCOLS,
2477 "create_function": create_element,
2478 "configure_function": configure_element,
2480 "connector_types": [],
2481 "box_attributes": ["HelloInterval",
2487 "ns3::UdpEchoServer": dict({
2488 "category": FC.CATEGORY_APPLICATIONS,
2489 "create_function": create_element,
2490 "configure_function": configure_element,
2492 "connector_types": ["node"],
2493 "stop_function": stop_application,
2494 "start_function": start_application,
2495 "status_function": status_application,
2496 "box_attributes": ["Port",
2499 "tags": [tags.APPLICATION],
2501 "ns3::AmrrWifiManager": dict({
2502 "category": FC.CATEGORY_MANAGERS,
2503 "create_function": create_element,
2504 "configure_function": configure_element,
2506 "connector_types": ["dev"],
2507 "box_attributes": ["UpdatePeriod",
2510 "MaxSuccessThreshold",
2511 "MinSuccessThreshold",
2516 "FragmentationThreshold",
2519 "ns3::ArfWifiManager": dict({
2520 "category": FC.CATEGORY_MANAGERS,
2521 "create_function": create_element,
2522 "configure_function": configure_element,
2524 "connector_types": ["dev"],
2525 "box_attributes": ["TimerThreshold",
2531 "FragmentationThreshold",
2534 "ns3::SubscriberStationNetDevice": dict({
2535 "category": FC.CATEGORY_DEVICES,
2536 "create_function": create_subscriber_station,
2537 "configure_function": configure_station,
2538 "help": "Subscriber station for mobile wireless network",
2539 "connector_types": ["node", "chan", "phy", "sflows"],
2540 "box_attributes": ["LostDlMapInterval",
2541 "LostUlMapInterval",
2551 "MaxContentionRangingRetries",
2555 "traces": ["wimaxpcap", "wimaxascii"],
2556 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2558 "ns3::flame::FlameRtable": dict({
2560 "create_function": create_element,
2561 "configure_function": configure_element,
2563 "connector_types": [],
2564 "box_attributes": ["Lifetime"],
2566 "ns3::BSSchedulerRtps": dict({
2567 "category": FC.CATEGORY_SERVICE_FLOWS,
2568 "create_function": create_element,
2569 "configure_function": configure_element,
2570 "help": "Simple downlink scheduler for rtPS flows",
2571 "connector_types": ["dev"],
2572 "box_attributes": [],
2574 "ns3::BSSchedulerSimple": dict({
2575 "category": FC.CATEGORY_SERVICE_FLOWS,
2576 "create_function": create_element,
2577 "configure_function": configure_element,
2578 "help": "simple downlink scheduler for service flows",
2579 "connector_types": ["dev"],
2580 "box_attributes": [],
2582 "ns3::SimpleOfdmWimaxChannel": dict({
2583 "category": FC.CATEGORY_CHANNELS,
2584 "create_function": create_wimax_channel,
2585 "configure_function": configure_element,
2586 "help": "Wimax channel",
2587 "connector_types": ["devs"],
2588 "box_attributes": [],
2590 "ns3::SimpleOfdmWimaxPhy": dict({
2591 "category": FC.CATEGORY_PHY_MODELS,
2592 "create_function": create_wimax_phy,
2593 "configure_function": configure_element,
2594 "help": "Wimax Phy",
2595 "connector_types": ["dev"],
2596 "box_attributes": [],
2598 "ns3::UplinkSchedulerSimple": dict({
2599 "category": FC.CATEGORY_SERVICE_FLOWS,
2600 "create_function": create_element_no_constructor,
2601 "configure_function": configure_element,
2602 "help": "Simple uplink scheduler for service flows",
2603 "connector_types": ["dev"],
2604 "box_attributes": [],
2606 "ns3::UplinkSchedulerRtps": dict({
2607 "category": FC.CATEGORY_SERVICE_FLOWS,
2608 "create_function": create_element_no_constructor,
2609 "configure_function": configure_element,
2610 "help": "Simple uplink scheduler for rtPS flows",
2611 "connector_types": ["dev"],
2612 "box_attributes": [],
2614 "ns3::IpcsClassifierRecord": dict({
2615 "category": FC.CATEGORY_SERVICE_FLOWS,
2616 "create_function": create_ipcs_classifier_record,
2617 "configure_function": configure_element,
2618 "help": "Classifier record for service flow",
2619 "connector_types": ["sflow"],
2620 "box_attributes": ["ClassifierSrcAddress",
2621 "ClassifierSrcMask",
2622 "ClassifierDstAddress",
2623 "ClassifierDstMask",
2624 "ClassifierSrcPortLow",
2625 "ClassifierSrcPortHigh",
2626 "ClassifierDstPortLow",
2627 "ClassifierDstPortHigh",
2628 "ClassifierProtocol",
2629 "ClassifierPriority"],
2631 "ns3::ServiceFlow": dict({
2632 "category": FC.CATEGORY_SERVICE_FLOWS,
2633 "create_function": create_service_flow,
2634 "configure_function": configure_element,
2635 "help": "Service flow for QoS",
2636 "connector_types": ["classif", "dev"],
2637 "box_attributes": ["ServiceFlowDirection",
2638 "ServiceFlowSchedulingType"],