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)
411 element = testbed_instance._elements[guid]
413 parameters = testbed_instance._get_parameters(guid)
414 address = parameters.get("macAddress")
416 macaddr = testbed_instance.ns3.Mac48Address(address)
418 macaddr = testbed_instance.ns3.Mac48Address.Allocate()
419 element.SetAddress(macaddr)
421 if not guid in testbed_instance._add_address:
423 # search for the node asociated with the device
424 node_guid = _get_node_guid(testbed_instance, guid)
425 node = testbed_instance.elements[node_guid]
426 # search for the Ipv4L3Protocol asociated with the device
427 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
428 ipv4 = testbed_instance._elements[ipv4_guid]
429 ns3 = testbed_instance.ns3
431 addresses = testbed_instance._add_address[guid]
432 for address in addresses:
433 (address, netprefix, broadcast) = address
434 # TODO: missing IPV6 addresses!!
435 ifindex = ipv4.AddInterface(element)
436 inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
437 ns3.Ipv4Mask("/%d" % netprefix))
438 ipv4.AddAddress(ifindex, inaddr)
439 ipv4.SetMetric(ifindex, 1)
442 def _add_static_route(ns3, static_routing,
443 address, netprefix, nexthop_address, ifindex):
445 # Default route: 0.0.0.0/0
446 static_routing.SetDefaultRoute(nexthop_address, ifindex)
447 elif netprefix == 32:
448 # Host route: x.y.z.w/32
449 static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
451 # Network route: x.y.z.w/n
452 mask = ns3.Ipv4Mask("/%d" % netprefix)
453 static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
456 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
458 # Default route: 0.0.0.0/0
459 static_routing.SetDefaultRoute(ifindex)
460 elif netprefix == 32:
461 # Host route: x.y.z.w/32
462 static_routing.AddHostRouteTo(address, ifindex)
464 # Network route: x.y.z.w/n
465 mask = ns3.Ipv4Mask("/%d" % netprefix)
466 static_routing.AddNetworkRouteTo(address, mask, ifindex)
468 def configure_node(testbed_instance, guid):
469 configure_traces(testbed_instance, guid)
471 element = testbed_instance._elements[guid]
472 if not guid in testbed_instance._add_route:
474 # search for the Ipv4L3Protocol asociated with the device
475 ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
476 ipv4 = testbed_instance._elements[ipv4_guid]
477 list_routing = ipv4.GetRoutingProtocol()
478 (static_routing, priority) = list_routing.GetRoutingProtocol(0)
479 ns3 = testbed_instance.ns3
480 routes = testbed_instance._add_route[guid]
482 (destination, netprefix, nexthop, metric) = route
483 address = ns3.Ipv4Address(destination)
485 nexthop_address = ns3.Ipv4Address(nexthop)
487 # TODO: HACKISH way of getting the ifindex... improve this
488 nifaces = ipv4.GetNInterfaces()
489 for ifidx in xrange(nifaces):
490 iface = ipv4.GetInterface(ifidx)
491 naddress = iface.GetNAddresses()
492 for addridx in xrange(naddress):
493 ifaddr = iface.GetAddress(addridx)
494 ifmask = ifaddr.GetMask()
495 ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
499 # Check previous ptp routes
500 for chaindest, chainprefix, chainhop in routes:
501 if chaindest == nexthop and chainprefix == 32:
502 chainhop_address = ns3.Ipv4Address(chainhop)
503 for ifidx in xrange(nifaces):
504 iface = ipv4.GetInterface(ifidx)
505 naddress = iface.GetNAddresses()
506 for addridx in xrange(naddress):
507 ifaddr = iface.GetAddress(addridx)
508 ifmask = ifaddr.GetMask()
509 ifindex = ipv4.GetInterfaceForPrefix(chainhop_address, ifmask)
513 raise RuntimeError, "Cannot associate interface for routing entry:" \
514 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
515 _add_static_route(ns3, static_routing,
516 address, netprefix, nexthop_address, ifindex)
518 mask = ns3.Ipv4Mask("/%d" % netprefix)
519 ifindex = ipv4.GetInterfaceForPrefix(address, mask)
521 raise RuntimeError, "Cannot associate interface for routing entry:" \
522 "%s/%s -> %s. At node %s" % (destination, netprefix, nexthop, guid)
523 _add_static_route_if(ns3, static_routing,
524 address, netprefix, nexthop_address, ifindex)
526 def configure_station(testbed_instance, guid):
527 configure_device(testbed_instance, guid)
528 element = testbed_instance._elements[guid]
533 factories_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::QadhocWifiMac",
584 "ns3::MinstrelWifiManager",
585 "ns3::CaraWifiManager",
586 "ns3::AarfcdWifiManager",
587 "ns3::OnoeWifiManager",
588 "ns3::AmrrWifiManager",
589 "ns3::ConstantRateWifiManager",
590 "ns3::IdealWifiManager",
591 "ns3::AarfWifiManager",
592 "ns3::ArfWifiManager",
593 "ns3::WifiNetDevice",
597 "ns3::YansWifiChannel",
599 "ns3::NistErrorRateModel",
600 "ns3::YansErrorRateModel",
601 "ns3::WaypointMobilityModel",
602 "ns3::ConstantAccelerationMobilityModel",
603 "ns3::RandomDirection2dMobilityModel",
604 "ns3::RandomWalk2dMobilityModel",
605 "ns3::SteadyStateRandomWaypointMobilityModel",
606 "ns3::RandomWaypointMobilityModel",
607 "ns3::GaussMarkovMobilityModel",
608 "ns3::ConstantVelocityMobilityModel",
609 "ns3::ConstantPositionMobilityModel",
610 "ns3::ListPositionAllocator",
611 "ns3::GridPositionAllocator",
612 "ns3::RandomRectanglePositionAllocator",
613 "ns3::RandomBoxPositionAllocator",
614 "ns3::RandomDiscPositionAllocator",
615 "ns3::UniformDiscPositionAllocator",
616 "ns3::HierarchicalMobilityModel",
617 "ns3::aodv::RoutingProtocol",
618 "ns3::UdpEchoServer",
619 "ns3::UdpEchoClient",
621 "ns3::OnOffApplication",
622 "ns3::VirtualNetDevice",
624 "ns3::Nepi::TunChannel",
626 "ns3::BridgeChannel",
627 "ns3::BridgeNetDevice",
630 "ns3::CsmaNetDevice",
631 "ns3::PointToPointRemoteChannel",
632 "ns3::PointToPointChannel",
633 "ns3::PointToPointNetDevice",
634 "ns3::NscTcpL4Protocol",
635 "ns3::Icmpv6L4Protocol",
636 "ns3::Ipv6OptionPad1",
637 "ns3::Ipv6OptionPadn",
638 "ns3::Ipv6OptionJumbogram",
639 "ns3::Ipv6OptionRouterAlert",
640 "ns3::Ipv6ExtensionHopByHop",
641 "ns3::Ipv6ExtensionDestination",
642 "ns3::Ipv6ExtensionFragment",
643 "ns3::Ipv6ExtensionRouting",
644 "ns3::Ipv6ExtensionLooseRouting",
645 "ns3::Ipv6ExtensionESP",
646 "ns3::Ipv6ExtensionAH",
647 "ns3::Ipv6L3Protocol",
648 "ns3::LoopbackNetDevice",
649 "ns3::Icmpv4L4Protocol",
650 "ns3::RttMeanDeviation",
651 "ns3::ArpL3Protocol",
652 "ns3::TcpL4Protocol",
653 "ns3::UdpL4Protocol",
654 "ns3::Ipv4L3Protocol",
655 "ns3::SimpleNetDevice",
656 "ns3::SimpleChannel",
658 "ns3::DropTailQueue",
660 "ns3::FriisSpectrumPropagationLossModel",
661 "ns3::Cost231PropagationLossModel",
662 "ns3::JakesPropagationLossModel",
663 "ns3::RandomPropagationLossModel",
664 "ns3::FriisPropagationLossModel",
665 "ns3::TwoRayGroundPropagationLossModel",
666 "ns3::LogDistancePropagationLossModel",
667 "ns3::ThreeLogDistancePropagationLossModel",
668 "ns3::NakagamiPropagationLossModel",
669 "ns3::FixedRssLossModel",
670 "ns3::MatrixPropagationLossModel",
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_info = dict({
694 "category": FC.CATEGORY_APPLICATIONS,
695 "create_function": create_element,
696 "configure_function": configure_element,
697 "stop_function": stop_application,
698 "start_function": start_application,
699 "status_function": status_application,
701 "connector_types": [],
702 "box_attributes": ["MaxPackets",
709 "tags": [tags.APPLICATION],
711 "ns3::UdpL4Protocol": dict({
712 "category": FC.CATEGORY_PROTOCOLS,
713 "create_function": create_element,
714 "configure_function": configure_element,
716 "connector_types": ["node"],
717 "box_attributes": ["ProtocolNumber"],
718 "tags": [tags.PROTOCOL],
720 "ns3::RandomDiscPositionAllocator": dict({
721 "category": FC.CATEGORY_MOBILITY_MODELS,
722 "create_function": create_element,
723 "configure_function": configure_element,
725 "connector_types": [],
726 "box_attributes": ["Theta",
730 "tags": [tags.MOBILE],
733 "category": FC.CATEGORY_NODES,
734 "create_function": create_node,
735 "configure_function": configure_node,
737 "connector_types": ["devs", "apps", "protos", "mobility"],
738 "tags": [tags.NODE, tags.ALLOW_ROUTES],
740 "ns3::GridPositionAllocator": dict({
741 "category": FC.CATEGORY_MOBILITY_MODELS,
742 "create_function": create_element,
743 "configure_function": configure_element,
745 "connector_types": [],
746 "box_attributes": ["GridWidth",
753 "ns3::TapBridge": dict({
754 "category": FC.CATEGORY_DEVICES,
755 "create_function": create_element,
756 "configure_function": configure_element,
758 "connector_types": [],
759 "box_attributes": ["Mtu",
767 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
769 "ns3::FlowMonitor": dict({
770 "category": FC.CATEGORY_SERVICE_FLOWS,
771 "create_function": create_element,
772 "configure_function": configure_element,
774 "connector_types": [],
775 "box_attributes": ["MaxPerHopDelay",
778 "PacketSizeBinWidth",
779 "FlowInterruptionsBinWidth",
780 "FlowInterruptionsMinTime"],
782 "ns3::ConstantVelocityMobilityModel": dict({
783 "category": FC.CATEGORY_MOBILITY_MODELS,
784 "create_function": create_element,
785 "configure_function": configure_element,
787 "connector_types": ["node"],
788 "box_attributes": ["Position",
790 "tags": [tags.MOBILE],
792 "ns3::V4Ping": dict({
793 "category": FC.CATEGORY_APPLICATIONS,
794 "create_function": create_element,
795 "configure_function": configure_element,
797 "connector_types": ["node"],
798 "stop_function": stop_application,
799 "start_function": start_application,
800 "status_function": status_application,
801 "box_attributes": ["Remote",
808 "tags": [tags.APPLICATION],
810 "ns3::dot11s::PeerLink": dict({
812 "create_function": create_element,
813 "configure_function": configure_element,
815 "connector_types": [],
816 "box_attributes": ["RetryTimeout",
823 "ns3::PointToPointNetDevice": dict({
824 "category": FC.CATEGORY_DEVICES,
825 "create_function": create_element,
826 "configure_function": configure_device,
828 "connector_types": ["node", "err", "queue", "chan"],
829 "box_attributes": ["Mtu",
833 "traces": ["p2ppcap", "p2pascii"],
834 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
836 "ns3::NakagamiPropagationLossModel": dict({
837 "category": FC.CATEGORY_LOSS_MODELS,
838 "create_function": create_element,
839 "configure_function": configure_element,
841 "connector_types": [],
842 "box_attributes": ["Distance1",
848 "ns3::AarfWifiManager": dict({
849 "category": FC.CATEGORY_MANAGERS,
850 "create_function": create_element,
851 "configure_function": configure_element,
853 "connector_types": ["dev"],
854 "box_attributes": ["SuccessK",
856 "MaxSuccessThreshold",
858 "MinSuccessThreshold",
863 "FragmentationThreshold",
866 "ns3::Ipv6OptionJumbogram": dict({
868 "create_function": create_element,
869 "configure_function": configure_element,
871 "connector_types": [],
872 "box_attributes": ["OptionNumber"],
874 "ns3::TwoRayGroundPropagationLossModel": dict({
875 "category": FC.CATEGORY_LOSS_MODELS,
876 "create_function": create_element,
877 "configure_function": configure_element,
879 "connector_types": [],
880 "box_attributes": ["Lambda",
885 "ns3::OnOffApplication": dict({
886 "category": FC.CATEGORY_APPLICATIONS,
887 "create_function": create_element,
888 "configure_function": configure_element,
890 "connector_types": ["node"],
891 "stop_function": stop_application,
892 "start_function": start_application,
893 "status_function": status_application,
894 "box_attributes": ["DataRate",
903 "tags": [tags.APPLICATION],
905 "ns3::AdhocWifiMac": dict({
906 "category": FC.CATEGORY_MAC_MODELS,
907 "create_function": create_element,
908 "configure_function": configure_element,
910 "connector_types": [],
911 "box_attributes": ["CtsTimeout",
913 "BasicBlockAckTimeout",
914 "CompressedBlockAckTimeout",
919 "MaxPropagationDelay",
922 "ns3::ConstantAccelerationMobilityModel": dict({
923 "category": FC.CATEGORY_MOBILITY_MODELS,
924 "create_function": create_element,
925 "configure_function": configure_element,
927 "connector_types": ["node"],
928 "box_attributes": ["Position",
930 "tags": [tags.MOBILE],
932 "ns3::GaussMarkovMobilityModel": dict({
933 "category": FC.CATEGORY_MOBILITY_MODELS,
934 "create_function": create_element,
935 "configure_function": configure_element,
937 "connector_types": [],
938 "box_attributes": ["Bounds",
949 "tags": [tags.MOBILE],
951 "ns3::dot11s::HwmpProtocol": dict({
952 "category": FC.CATEGORY_PROTOCOLS,
953 "create_function": create_element,
954 "configure_function": configure_element,
956 "connector_types": [],
957 "box_attributes": ["RandomStart",
959 "Dot11MeshHWMPmaxPREQretries",
960 "Dot11MeshHWMPnetDiameterTraversalTime",
961 "Dot11MeshHWMPpreqMinInterval",
962 "Dot11MeshHWMPperrMinInterval",
963 "Dot11MeshHWMPactiveRootTimeout",
964 "Dot11MeshHWMPactivePathTimeout",
965 "Dot11MeshHWMPpathToRootInterval",
966 "Dot11MeshHWMPrannInterval",
968 "UnicastPerrThreshold",
969 "UnicastPreqThreshold",
970 "UnicastDataThreshold",
974 "ns3::NscTcpL4Protocol": dict({
975 "category": FC.CATEGORY_PROTOCOLS,
976 "create_function": create_element,
977 "configure_function": configure_element,
979 "connector_types": [],
980 "box_attributes": ["Library",
983 "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
985 "create_function": create_element,
986 "configure_function": configure_element,
988 "connector_types": [],
989 "box_attributes": ["Dot11sMeshHeaderLength"],
991 "ns3::UanMacCw": dict({
993 "create_function": create_element,
994 "configure_function": configure_element,
996 "connector_types": [],
997 "box_attributes": ["CW",
1000 "ns3::AthstatsWifiTraceSink": dict({
1002 "create_function": create_element,
1003 "configure_function": configure_element,
1005 "connector_types": [],
1006 "box_attributes": ["Interval"],
1008 "ns3::FlameStack": dict({
1010 "create_function": create_element,
1011 "configure_function": configure_element,
1013 "connector_types": [],
1014 "box_attributes": [],
1016 "ns3::UanMacRc": dict({
1018 "create_function": create_element,
1019 "configure_function": configure_element,
1021 "connector_types": [],
1022 "box_attributes": ["RetryRate",
1029 "NumberOfRetryRates",
1032 "ns3::WaypointMobilityModel": dict({
1033 "category": FC.CATEGORY_MOBILITY_MODELS,
1034 "create_function": create_waypoint_mobility,
1035 "configure_function": configure_element,
1036 "help": "Waypoint-based mobility model.",
1037 "connector_types": ["node"],
1038 "box_attributes": ["WaypointsLeft",
1042 "tags": [tags.MOBILE],
1044 "ns3::FdNetDevice": dict({
1045 "category": FC.CATEGORY_DEVICES,
1046 "create_function": create_element,
1047 "configure_function": configure_device,
1048 "help": "Network interface associated to a file descriptor",
1049 "connector_types": ["node", "->fd"],
1050 "box_attributes": ["Address",
1051 "tun_proto", "tun_addr", "tun_port", "tun_key", "tun_cipher_fdnd"],
1052 "traces": ["fdpcap", "fdascii"],
1053 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1055 "ns3::Nepi::TunChannel": dict({
1056 "category": FC.CATEGORY_TUNNELS,
1057 "create_function": create_tunchannel,
1058 "preconfigure_function": preconfigure_tunchannel,
1059 "configure_function": postconfigure_tunchannel,
1060 "prestart_function": prestart_tunchannel,
1061 "help": "Channel to forward FdNetDevice data to "
1062 "other TAP interfaces supporting the NEPI tunneling protocol.",
1063 "connector_types": ["fd->", "udp", "tcp"],
1064 "allow_addresses": False,
1065 "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key","tun_cipher"],
1066 "tags": [tags.TUNNEL],
1069 "ns3::CsmaNetDevice": dict({
1070 "category": FC.CATEGORY_DEVICES,
1071 "create_function": create_element,
1072 "configure_function": configure_device,
1073 "help": "CSMA (carrier sense, multiple access) interface",
1074 "connector_types": ["node", "chan", "err", "queue"],
1075 "box_attributes": ["Address",
1079 "traces": ["csmapcap", "csmapcap_promisc"],
1080 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1082 "ns3::UanPropModelThorp": dict({
1084 "create_function": create_element,
1085 "configure_function": configure_element,
1087 "connector_types": [],
1088 "box_attributes": ["SpreadCoef"],
1090 "ns3::Icmpv6L4Protocol": dict({
1091 "category": FC.CATEGORY_PROTOCOLS,
1092 "create_function": create_element,
1093 "configure_function": configure_element,
1095 "connector_types": ["node"],
1096 "box_attributes": ["DAD",
1099 "ns3::SimpleNetDevice": dict({
1100 "category": FC.CATEGORY_DEVICES,
1101 "create_function": create_element,
1102 "configure_function": configure_element,
1104 "connector_types": ["node", "chan"],
1105 "box_attributes": [],
1106 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1108 "ns3::FriisPropagationLossModel": dict({
1109 "category": FC.CATEGORY_LOSS_MODELS,
1110 "create_function": create_element,
1111 "configure_function": configure_element,
1113 "connector_types": [],
1114 "box_attributes": ["Lambda",
1118 "ns3::Ipv6OptionRouterAlert": dict({
1120 "create_function": create_element,
1121 "configure_function": configure_element,
1123 "connector_types": [],
1124 "box_attributes": ["OptionNumber"],
1126 "ns3::UniformDiscPositionAllocator": dict({
1127 "category": FC.CATEGORY_MOBILITY_MODELS,
1128 "create_function": create_element,
1129 "configure_function": configure_element,
1131 "connector_types": [],
1132 "box_attributes": ["rho",
1135 "tags": [tags.MOBILE],
1137 "ns3::RandomBoxPositionAllocator": dict({
1138 "category": FC.CATEGORY_MOBILITY_MODELS,
1139 "create_function": create_element,
1140 "configure_function": configure_element,
1142 "connector_types": [],
1143 "box_attributes": ["X",
1146 "tags": [tags.MOBILE],
1148 "ns3::Ipv6ExtensionDestination": dict({
1150 "create_function": create_element,
1151 "configure_function": configure_element,
1153 "connector_types": [],
1154 "box_attributes": ["ExtensionNumber"],
1156 "ns3::LoopbackNetDevice": dict({
1157 "category": FC.CATEGORY_DEVICES,
1158 "create_function": create_element,
1159 "configure_function": configure_element,
1161 "connector_types": [],
1162 "box_attributes": [],
1163 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1165 "ns3::ConstantSpeedPropagationDelayModel": dict({
1166 "category": FC.CATEGORY_DELAY_MODELS,
1167 "create_function": create_element,
1168 "configure_function": configure_element,
1170 "connector_types": ["chan"],
1171 "box_attributes": ["Speed"],
1173 "ns3::Ipv6ExtensionHopByHop": dict({
1175 "create_function": create_element,
1176 "configure_function": configure_element,
1178 "connector_types": [],
1179 "box_attributes": ["ExtensionNumber"],
1181 "ns3::BridgeChannel": dict({
1182 "category": FC.CATEGORY_CHANNELS,
1183 "create_function": create_element,
1184 "configure_function": configure_element,
1186 "connector_types": [],
1187 "box_attributes": [],
1189 "ns3::Radvd": dict({
1191 "create_function": create_element,
1192 "configure_function": configure_element,
1194 "connector_types": [],
1195 "box_attributes": ["StartTime",
1198 "ns3::PacketSocket": dict({
1200 "create_function": create_element,
1201 "configure_function": configure_element,
1203 "connector_types": [],
1204 "box_attributes": ["RcvBufSize"],
1206 "ns3::flame::FlameProtocol": dict({
1207 "category": FC.CATEGORY_PROTOCOLS,
1208 "create_function": create_element,
1209 "configure_function": configure_element,
1211 "connector_types": [],
1212 "box_attributes": ["BroadcastInterval",
1215 "ns3::Cost231PropagationLossModel": dict({
1216 "category": FC.CATEGORY_LOSS_MODELS,
1217 "create_function": create_element,
1218 "configure_function": configure_element,
1220 "connector_types": [],
1221 "box_attributes": ["Lambda",
1227 "ns3::Ipv6ExtensionESP": dict({
1229 "create_function": create_element,
1230 "configure_function": configure_element,
1232 "connector_types": [],
1233 "box_attributes": ["ExtensionNumber"],
1235 "ns3::CaraWifiManager": dict({
1236 "category": FC.CATEGORY_MANAGERS,
1237 "create_function": create_element,
1238 "configure_function": configure_element,
1240 "connector_types": ["dev"],
1241 "box_attributes": ["ProbeThreshold",
1249 "FragmentationThreshold",
1253 "ns3::RttMeanDeviation": dict({
1255 "create_function": create_element,
1256 "configure_function": configure_element,
1258 "connector_types": [],
1259 "box_attributes": ["Gain",
1261 "InitialEstimation",
1264 "ns3::Icmpv4L4Protocol": dict({
1265 "category": FC.CATEGORY_PROTOCOLS,
1266 "create_function": create_element,
1267 "configure_function": configure_element,
1269 "connector_types": ["node"],
1270 "box_attributes": ["ProtocolNumber"],
1272 "ns3::WaveformGenerator": dict({
1274 "create_function": create_element,
1275 "configure_function": configure_element,
1277 "connector_types": [],
1278 "box_attributes": ["Period",
1281 "ns3::YansWifiChannel": dict({
1282 "category": FC.CATEGORY_CHANNELS,
1283 "create_function": create_element,
1284 "configure_function": configure_element,
1286 "connector_types": ["phys", "delay", "loss"],
1287 "box_attributes": [],
1289 "ns3::SimpleChannel": dict({
1290 "category": FC.CATEGORY_CHANNELS,
1291 "create_function": create_element,
1292 "configure_function": configure_element,
1294 "connector_types": ["devs"],
1295 "box_attributes": [],
1297 "ns3::Ipv6ExtensionFragment": dict({
1299 "create_function": create_element,
1300 "configure_function": configure_element,
1302 "connector_types": [],
1303 "box_attributes": ["ExtensionNumber"],
1305 "ns3::Dot11sStack": dict({
1307 "create_function": create_element,
1308 "configure_function": configure_element,
1310 "connector_types": [],
1311 "box_attributes": ["Root"],
1313 "ns3::FriisSpectrumPropagationLossModel": dict({
1314 "category": FC.CATEGORY_LOSS_MODELS,
1315 "create_function": create_element,
1316 "configure_function": configure_element,
1318 "connector_types": [],
1319 "box_attributes": [],
1321 "ns3::RandomRectanglePositionAllocator": dict({
1322 "category": FC.CATEGORY_MOBILITY_MODELS,
1323 "create_function": create_element,
1324 "configure_function": configure_element,
1326 "connector_types": [],
1327 "box_attributes": ["X",
1329 "tags": [tags.MOBILE],
1331 "ns3::HierarchicalMobilityModel": dict({
1332 "category": FC.CATEGORY_MOBILITY_MODELS,
1333 "create_function": create_element,
1334 "configure_function": configure_element,
1336 "connector_types": ["node"],
1337 "box_attributes": ["Position",
1339 "tags": [tags.MOBILE],
1341 "ns3::ThreeLogDistancePropagationLossModel": dict({
1342 "category": FC.CATEGORY_LOSS_MODELS,
1343 "create_function": create_element,
1344 "configure_function": configure_element,
1346 "connector_types": [],
1347 "box_attributes": ["Distance0",
1355 "ns3::UanNoiseModelDefault": dict({
1357 "create_function": create_element,
1358 "configure_function": configure_element,
1360 "connector_types": [],
1361 "box_attributes": ["Wind",
1364 "ns3::dot11s::HwmpRtable": dict({
1366 "create_function": create_element,
1367 "configure_function": configure_element,
1369 "connector_types": [],
1370 "box_attributes": [],
1372 "ns3::PacketBurst": dict({
1374 "create_function": create_element,
1375 "configure_function": configure_element,
1377 "connector_types": [],
1378 "box_attributes": [],
1380 "ns3::RandomPropagationDelayModel": dict({
1381 "category": FC.CATEGORY_DELAY_MODELS,
1382 "create_function": create_element,
1383 "configure_function": configure_element,
1385 "connector_types": [],
1386 "box_attributes": ["Variable"],
1388 "ns3::ArpL3Protocol": dict({
1389 "category": FC.CATEGORY_PROTOCOLS,
1390 "create_function": create_element,
1391 "configure_function": configure_element,
1393 "connector_types": ["node"],
1394 "box_attributes": [],
1396 "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1397 "category": FC.CATEGORY_MOBILITY_MODELS,
1398 "create_function": create_element,
1399 "configure_function": configure_element,
1401 "connector_types": [],
1402 "box_attributes": ["MinSpeed",
1412 "tags": [tags.MOBILE],
1414 "ns3::BaseStationNetDevice": dict({
1415 "category": FC.CATEGORY_DEVICES,
1416 "create_function": create_base_station,
1417 "configure_function": configure_station,
1418 "help": "Base station for wireless mobile network",
1419 "connector_types": ["node", "chan", "phy", "uplnk", "dwnlnk"],
1420 "box_attributes": ["InitialRangInterval",
1426 "MaxRangCorrectionRetries",
1430 "traces": ["wimaxpcap", "wimaxascii"],
1431 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1433 "ns3::UdpServer": dict({
1434 "category": FC.CATEGORY_APPLICATIONS,
1435 "create_function": create_element,
1436 "configure_function": configure_element,
1438 "connector_types": ["node"],
1439 "stop_function": stop_application,
1440 "start_function": start_application,
1441 "status_function": status_application,
1442 "box_attributes": ["Port",
1447 "ns3::AarfcdWifiManager": dict({
1448 "category": FC.CATEGORY_MANAGERS,
1449 "create_function": create_element,
1450 "configure_function": configure_element,
1452 "connector_types": ["dev"],
1453 "box_attributes": ["SuccessK",
1455 "MaxSuccessThreshold",
1456 "MinTimerThreshold",
1457 "MinSuccessThreshold",
1460 "TurnOffRtsAfterRateDecrease",
1461 "TurnOnRtsAfterRateIncrease",
1466 "FragmentationThreshold",
1469 "ns3::UanTransducerHd": dict({
1471 "create_function": create_element,
1472 "configure_function": configure_element,
1474 "connector_types": [],
1475 "box_attributes": [],
1477 "ns3::LogDistancePropagationLossModel": dict({
1478 "category": FC.CATEGORY_LOSS_MODELS,
1479 "create_function": create_element,
1480 "configure_function": configure_element,
1482 "connector_types": ["prev", "next"],
1483 "box_attributes": ["Exponent",
1484 "ReferenceDistance",
1487 "ns3::EmuNetDevice": dict({
1488 "category": FC.CATEGORY_DEVICES,
1489 "create_function": create_element,
1490 "configure_function": configure_element,
1492 "connector_types": ["node", "queue"],
1493 "box_attributes": ["Mtu",
1499 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1501 "ns3::Ipv6ExtensionLooseRouting": dict({
1502 "category": FC.CATEGORY_ROUTING,
1503 "create_function": create_element,
1504 "configure_function": configure_element,
1506 "connector_types": [],
1507 "box_attributes": ["ExtensionNumber"],
1509 "ns3::RandomWaypointMobilityModel": dict({
1510 "category": FC.CATEGORY_MOBILITY_MODELS,
1511 "create_function": create_element,
1512 "configure_function": configure_element,
1514 "connector_types": ["node"],
1515 "box_attributes": ["Speed",
1519 "tags": [tags.MOBILE],
1521 "ns3::RangePropagationLossModel": dict({
1522 "category": FC.CATEGORY_LOSS_MODELS,
1523 "create_function": create_element,
1524 "configure_function": configure_element,
1526 "connector_types": [],
1527 "box_attributes": ["MaxRange"],
1529 "ns3::AlohaNoackNetDevice": dict({
1530 "category": FC.CATEGORY_DEVICES,
1531 "create_function": create_element,
1532 "configure_function": configure_element,
1534 "connector_types": [],
1535 "box_attributes": ["Address",
1537 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1539 "ns3::MatrixPropagationLossModel": dict({
1540 "category": FC.CATEGORY_LOSS_MODELS,
1541 "create_function": create_element,
1542 "configure_function": configure_element,
1544 "connector_types": [],
1545 "box_attributes": ["DefaultLoss"],
1547 "ns3::WifiNetDevice": dict({
1548 "category": FC.CATEGORY_DEVICES,
1549 "create_function": create_element,
1550 "configure_function": configure_device,
1552 "connector_types": ["node", "mac", "phy", "manager"],
1553 "box_attributes": ["Mtu"],
1554 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1556 "ns3::CsmaChannel": dict({
1557 "category": FC.CATEGORY_CHANNELS,
1558 "create_function": create_element,
1559 "configure_function": configure_element,
1561 "connector_types": ["devs"],
1562 "box_attributes": ["DataRate",
1565 "ns3::BridgeNetDevice": dict({
1566 "category": FC.CATEGORY_DEVICES,
1567 "create_function": create_element,
1568 "configure_function": configure_element,
1570 "connector_types": ["node"],
1571 "box_attributes": ["Mtu",
1574 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1576 "ns3::Ipv6ExtensionRouting": dict({
1577 "category": FC.CATEGORY_ROUTING,
1578 "create_function": create_element,
1579 "configure_function": configure_element,
1581 "connector_types": [],
1582 "box_attributes": ["ExtensionNumber"],
1584 "ns3::StaWifiMac": dict({
1585 "category": FC.CATEGORY_MAC_MODELS,
1586 "create_function": create_wifi_standard_model,
1587 "configure_function": configure_element,
1588 "help": "Station Wifi MAC Model",
1589 "connector_types": ["dev"],
1590 "box_attributes": ["ProbeRequestTimeout",
1591 "AssocRequestTimeout",
1595 "BasicBlockAckTimeout",
1596 "CompressedBlockAckTimeout",
1601 "MaxPropagationDelay",
1605 "ns3::UdpEchoClient": dict({
1606 "category": FC.CATEGORY_APPLICATIONS,
1607 "create_function": create_element,
1608 "configure_function": configure_element,
1610 "connector_types": ["node"],
1611 "stop_function": stop_application,
1612 "start_function": start_application,
1613 "status_function": status_application,
1614 "box_attributes": ["MaxPackets",
1621 "tags": [tags.APPLICATION],
1623 "ns3::UdpClient": dict({
1624 "category": FC.CATEGORY_APPLICATIONS,
1625 "create_function": create_element,
1626 "configure_function": configure_element,
1628 "connector_types": ["node"],
1629 "stop_function": stop_application,
1630 "start_function": start_application,
1631 "status_function": status_application,
1632 "box_attributes": ["MaxPackets",
1639 "tags": [tags.APPLICATION],
1641 "ns3::PointToPointChannel": dict({
1642 "category": FC.CATEGORY_CHANNELS,
1643 "create_function": create_element,
1644 "configure_function": configure_element,
1646 "connector_types": ["dev2"],
1647 "box_attributes": ["Delay"],
1649 "ns3::Ipv6StaticRouting": dict({
1650 "category": FC.CATEGORY_ROUTING,
1651 "create_function": create_element,
1652 "configure_function": configure_element,
1654 "connector_types": [],
1655 "box_attributes": [],
1657 "ns3::DropTailQueue": dict({
1658 "category": FC.CATEGORY_QUEUES,
1659 "create_function": create_element,
1660 "configure_function": configure_element,
1662 "connector_types": ["dev"],
1663 "box_attributes": ["MaxPackets",
1666 "ns3::ConstantPositionMobilityModel": dict({
1667 "category": FC.CATEGORY_MOBILITY_MODELS,
1668 "create_function": create_element,
1669 "configure_function": configure_element,
1671 "connector_types": ["node"],
1672 "box_attributes": ["Position",
1674 "tags": [tags.MOBILE],
1676 "ns3::FixedRssLossModel": dict({
1677 "category": FC.CATEGORY_LOSS_MODELS,
1678 "create_function": create_element,
1679 "configure_function": configure_element,
1681 "connector_types": [],
1682 "box_attributes": ["Rss"],
1684 "ns3::EnergySourceContainer": dict({
1685 "category": FC.CATEGORY_ENERGY_MODELS,
1686 "create_function": create_element,
1687 "configure_function": configure_element,
1689 "connector_types": [],
1690 "box_attributes": [],
1692 "ns3::RandomWalk2dMobilityModel": dict({
1693 "category": FC.CATEGORY_MOBILITY_MODELS,
1694 "create_function": create_element,
1695 "configure_function": configure_element,
1697 "connector_types": ["node"],
1698 "box_attributes": ["Bounds",
1706 "tags": [tags.MOBILE],
1708 "ns3::ListPositionAllocator": dict({
1710 "create_function": create_element,
1711 "configure_function": configure_element,
1713 "connector_types": [],
1714 "box_attributes": [],
1716 "ns3::dot11s::PeerManagementProtocol": dict({
1717 "category": FC.CATEGORY_PROTOCOLS,
1718 "create_function": create_element,
1719 "configure_function": configure_element,
1721 "connector_types": [],
1722 "box_attributes": ["MaxNumberOfPeerLinks",
1723 "MaxBeaconShiftValue",
1724 "EnableBeaconCollisionAvoidance"],
1726 "ns3::MeshPointDevice": dict({
1727 "category": FC.CATEGORY_DEVICES,
1728 "create_function": create_element,
1729 "configure_function": configure_element,
1731 "connector_types": [],
1732 "box_attributes": ["Mtu"],
1733 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1735 "ns3::BasicEnergySource": dict({
1736 "category": FC.CATEGORY_ENERGY_MODELS,
1737 "create_function": create_element,
1738 "configure_function": configure_element,
1740 "connector_types": [],
1741 "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1742 "BasicEnergySupplyVoltageV",
1743 "PeriodicEnergyUpdateInterval"],
1745 "ns3::Ipv6OptionPadn": dict({
1747 "create_function": create_element,
1748 "configure_function": configure_element,
1750 "connector_types": [],
1751 "box_attributes": ["OptionNumber"],
1753 "ns3::ApWifiMac": dict({
1754 "category": FC.CATEGORY_MAC_MODELS,
1755 "create_function": create_wifi_standard_model,
1756 "configure_function": configure_element,
1757 "help": "Access point Wifi MAC Model",
1758 "connector_types": ["dev"],
1759 "box_attributes": ["BeaconInterval",
1763 "BasicBlockAckTimeout",
1764 "CompressedBlockAckTimeout",
1769 "MaxPropagationDelay",
1773 "ns3::YansErrorRateModel": dict({
1774 "category": FC.CATEGORY_ERROR_MODELS,
1775 "create_function": create_element,
1776 "configure_function": configure_element,
1778 "connector_types": [],
1779 "box_attributes": [],
1781 "ns3::WifiMacQueue": dict({
1782 "category": FC.CATEGORY_QUEUES,
1783 "create_function": create_element,
1784 "configure_function": configure_element,
1786 "connector_types": [],
1787 "box_attributes": ["MaxPacketNumber",
1790 "ns3::NonCommunicatingNetDevice": dict({
1791 "category": FC.CATEGORY_DEVICES,
1792 "create_function": create_element,
1793 "configure_function": configure_element,
1795 "connector_types": [],
1796 "box_attributes": [],
1797 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
1799 "ns3::RateErrorModel": dict({
1800 "category": FC.CATEGORY_ERROR_MODELS,
1801 "create_function": create_element,
1802 "configure_function": configure_element,
1804 "connector_types": [],
1805 "box_attributes": ["ErrorUnit",
1810 "ns3::MeshWifiInterfaceMac": dict({
1811 "category": FC.CATEGORY_MAC_MODELS,
1812 "create_function": create_element,
1813 "configure_function": configure_element,
1815 "connector_types": [],
1816 "box_attributes": ["BeaconInterval",
1821 "BasicBlockAckTimeout",
1822 "CompressedBlockAckTimeout",
1827 "MaxPropagationDelay",
1830 "ns3::UanPhyCalcSinrDual": dict({
1832 "create_function": create_element,
1833 "configure_function": configure_element,
1835 "connector_types": [],
1836 "box_attributes": [],
1838 "ns3::Ipv6ExtensionAH": dict({
1840 "create_function": create_element,
1841 "configure_function": configure_element,
1843 "connector_types": [],
1844 "box_attributes": ["ExtensionNumber"],
1846 "ns3::SingleModelSpectrumChannel": dict({
1847 "category": FC.CATEGORY_CHANNELS,
1848 "create_function": create_element,
1849 "configure_function": configure_element,
1851 "connector_types": [],
1852 "box_attributes": [],
1854 "ns3::YansWifiPhy": dict({
1855 "category": FC.CATEGORY_PHY_MODELS,
1856 "create_function": create_wifi_standard_model,
1857 "configure_function": configure_element,
1859 "connector_types": ["dev", "err", "chan"],
1860 "box_attributes": ["EnergyDetectionThreshold",
1861 "CcaMode1Threshold",
1868 "ChannelSwitchDelay",
1871 "traces": ["yanswifipcap"]
1873 "ns3::WifiRadioEnergyModel": dict({
1874 "category": FC.CATEGORY_ENERGY_MODELS,
1875 "create_function": create_element,
1876 "configure_function": configure_element,
1878 "connector_types": [],
1879 "box_attributes": ["TxCurrentA",
1884 "ns3::EdcaTxopN": dict({
1886 "create_function": create_element,
1887 "configure_function": configure_element,
1889 "connector_types": [],
1890 "box_attributes": ["BlockAckThreshold",
1895 "ns3::UanPhyPerGenDefault": dict({
1897 "create_function": create_element,
1898 "configure_function": configure_element,
1900 "connector_types": [],
1901 "box_attributes": ["Threshold"],
1903 "ns3::IdealWifiManager": dict({
1904 "category": FC.CATEGORY_MANAGERS,
1905 "create_function": create_element,
1906 "configure_function": configure_element,
1908 "connector_types": ["dev"],
1909 "box_attributes": ["BerThreshold",
1914 "FragmentationThreshold",
1917 "ns3::MultiModelSpectrumChannel": dict({
1918 "category": FC.CATEGORY_CHANNELS,
1919 "create_function": create_element,
1920 "configure_function": configure_element,
1922 "connector_types": [],
1923 "box_attributes": [],
1925 "ns3::HalfDuplexIdealPhy": dict({
1926 "category": FC.CATEGORY_PHY_MODELS,
1927 "create_function": create_element,
1928 "configure_function": configure_element,
1930 "connector_types": [],
1931 "box_attributes": ["Rate"],
1933 "ns3::UanPhyCalcSinrDefault": dict({
1934 "category": FC.CATEGORY_PHY_MODELS,
1935 "create_function": create_element,
1936 "configure_function": configure_element,
1938 "connector_types": [],
1939 "box_attributes": [],
1941 "ns3::ReceiveListErrorModel": dict({
1942 "category": FC.CATEGORY_ERROR_MODELS,
1943 "create_function": create_element,
1944 "configure_function": configure_element,
1946 "connector_types": [],
1947 "box_attributes": ["IsEnabled"],
1949 "ns3::SpectrumAnalyzer": dict({
1951 "create_function": create_element,
1952 "configure_function": configure_element,
1954 "connector_types": [],
1955 "box_attributes": ["Resolution",
1956 "NoisePowerSpectralDensity"],
1958 "ns3::ConstantRateWifiManager": dict({
1959 "category": FC.CATEGORY_MANAGERS,
1960 "create_function": create_element,
1961 "configure_function": configure_element,
1963 "connector_types": ["dev"],
1964 "box_attributes": ["DataMode",
1970 "FragmentationThreshold",
1973 "ns3::Ipv6OptionPad1": dict({
1975 "create_function": create_element,
1976 "configure_function": configure_element,
1978 "connector_types": [],
1979 "box_attributes": ["OptionNumber"],
1981 "ns3::UdpTraceClient": dict({
1983 "create_function": create_element,
1984 "configure_function": configure_element,
1986 "connector_types": [],
1987 "box_attributes": ["RemoteAddress",
1993 "ns3::RraaWifiManager": dict({
1994 "category": FC.CATEGORY_MANAGERS,
1995 "create_function": create_element,
1996 "configure_function": configure_element,
1998 "connector_types": ["dev"],
1999 "box_attributes": ["Basic",
2027 "FragmentationThreshold",
2030 "ns3::RandomPropagationLossModel": dict({
2031 "category": FC.CATEGORY_LOSS_MODELS,
2032 "create_function": create_element,
2033 "configure_function": configure_element,
2035 "connector_types": [],
2036 "box_attributes": ["Variable"],
2038 "ns3::UanChannel": dict({
2039 "category": FC.CATEGORY_CHANNELS,
2040 "create_function": create_element,
2041 "configure_function": configure_element,
2043 "connector_types": [],
2044 "box_attributes": [],
2046 "ns3::MinstrelWifiManager": dict({
2047 "category": FC.CATEGORY_MANAGERS,
2048 "create_function": create_element,
2049 "configure_function": configure_element,
2051 "connector_types": ["dev"],
2052 "box_attributes": ["UpdateStatistics",
2062 "FragmentationThreshold",
2065 "ns3::UanPhyDual": dict({
2066 "category": FC.CATEGORY_PHY_MODELS,
2067 "create_function": create_element,
2068 "configure_function": configure_element,
2070 "connector_types": [],
2071 "box_attributes": ["CcaThresholdPhy1",
2077 "SupportedModesPhy1",
2078 "SupportedModesPhy2"],
2080 "ns3::ListErrorModel": dict({
2081 "category": FC.CATEGORY_ERROR_MODELS,
2082 "create_function": create_element,
2083 "configure_function": configure_element,
2085 "connector_types": ["dev"],
2086 "box_attributes": ["IsEnabled"],
2088 "ns3::VirtualNetDevice": dict({
2089 "category": FC.CATEGORY_DEVICES,
2090 "create_function": create_element,
2091 "configure_function": configure_element,
2093 "connector_types": [],
2094 "box_attributes": ["Mtu"],
2095 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2097 "ns3::UanPhyGen": dict({
2098 "category": FC.CATEGORY_PHY_MODELS,
2099 "create_function": create_element,
2100 "configure_function": configure_element,
2102 "connector_types": [],
2103 "box_attributes": ["CcaThreshold",
2109 "ns3::Ipv6L3Protocol": dict({
2110 "category": FC.CATEGORY_PROTOCOLS,
2111 "create_function": create_element,
2112 "configure_function": configure_element,
2114 "connector_types": ["node"],
2115 "box_attributes": ["DefaultTtl",
2118 "ns3::PointToPointRemoteChannel": dict({
2119 "category": FC.CATEGORY_CHANNELS,
2120 "create_function": create_element,
2121 "configure_function": configure_element,
2123 "connector_types": [],
2124 "box_attributes": ["Delay"],
2126 "ns3::UanPhyPerUmodem": dict({
2127 "category": FC.CATEGORY_PHY_MODELS,
2128 "create_function": create_element,
2129 "configure_function": configure_element,
2131 "connector_types": [],
2132 "box_attributes": [],
2134 "ns3::OnoeWifiManager": dict({
2135 "category": FC.CATEGORY_MANAGERS,
2136 "create_function": create_element,
2137 "configure_function": configure_element,
2139 "connector_types": ["dev"],
2140 "box_attributes": ["UpdatePeriod",
2142 "AddCreditThreshold",
2147 "FragmentationThreshold",
2150 "ns3::QadhocWifiMac": dict({
2151 "category": FC.CATEGORY_MAC_MODELS,
2152 "create_function": create_element,
2153 "configure_function": configure_element,
2155 "connector_types": [],
2156 "box_attributes": ["CtsTimeout",
2158 "BasicBlockAckTimeout",
2159 "CompressedBlockAckTimeout",
2164 "MaxPropagationDelay",
2167 "ns3::JakesPropagationLossModel": dict({
2168 "category": FC.CATEGORY_LOSS_MODELS,
2169 "create_function": create_element,
2170 "configure_function": configure_element,
2172 "connector_types": [],
2173 "box_attributes": ["NumberOfRaysPerPath",
2174 "NumberOfOscillatorsPerRay",
2178 "ns3::PacketSink": dict({
2179 "category": FC.CATEGORY_APPLICATIONS,
2180 "create_function": create_element,
2181 "configure_function": configure_element,
2183 "connector_types": ["node"],
2184 "stop_function": stop_application,
2185 "start_function": start_application,
2186 "status_function": status_application,
2187 "box_attributes": ["Local",
2191 "tags": [tags.APPLICATION],
2193 "ns3::RandomDirection2dMobilityModel": dict({
2194 "category": FC.CATEGORY_MOBILITY_MODELS,
2195 "create_function": create_element,
2196 "configure_function": configure_element,
2198 "connector_types": ["node"],
2199 "box_attributes": ["Bounds",
2204 "tags": [tags.MOBILE],
2206 "ns3::UanMacAloha": dict({
2208 "create_function": create_element,
2209 "configure_function": configure_element,
2211 "connector_types": [],
2212 "box_attributes": [],
2214 "ns3::MsduStandardAggregator": dict({
2216 "create_function": create_element,
2217 "configure_function": configure_element,
2219 "connector_types": [],
2220 "box_attributes": ["MaxAmsduSize"],
2222 "ns3::DcaTxop": dict({
2224 "create_function": create_element,
2225 "configure_function": configure_element,
2227 "connector_types": [],
2228 "box_attributes": ["MinCw",
2232 "ns3::UanPhyCalcSinrFhFsk": dict({
2233 "category": FC.CATEGORY_PHY_MODELS,
2234 "create_function": create_element,
2235 "configure_function": configure_element,
2237 "connector_types": [],
2238 "box_attributes": ["NumberOfHops"],
2240 "ns3::UanPropModelIdeal": dict({
2242 "create_function": create_element,
2243 "configure_function": configure_element,
2245 "connector_types": [],
2246 "box_attributes": [],
2248 "ns3::UanMacRcGw": dict({
2250 "create_function": create_element,
2251 "configure_function": configure_element,
2253 "connector_types": [],
2254 "box_attributes": ["MaxReservations",
2262 "NumberOfRetryRates",
2267 "ns3::NistErrorRateModel": dict({
2268 "category": FC.CATEGORY_ERROR_MODELS,
2269 "create_function": create_element,
2270 "configure_function": configure_element,
2272 "connector_types": ["phy"],
2273 "box_attributes": [],
2275 "ns3::Ipv4L3Protocol": dict({
2276 "category": FC.CATEGORY_PROTOCOLS,
2277 "create_function": create_ipv4protocol,
2278 "configure_function": configure_element,
2280 "connector_types": ["node"],
2281 "box_attributes": ["DefaultTtl",
2285 "ns3::aodv::RoutingProtocol": dict({
2286 "category": FC.CATEGORY_PROTOCOLS,
2287 "create_function": create_element,
2288 "configure_function": configure_element,
2290 "connector_types": [],
2291 "box_attributes": ["HelloInterval",
2294 "NodeTraversalTime",
2296 "ActiveRouteTimeout",
2303 "PathDiscoveryTime",
2312 "ns3::TcpL4Protocol": dict({
2313 "category": FC.CATEGORY_PROTOCOLS,
2314 "create_function": create_element,
2315 "configure_function": configure_element,
2317 "connector_types": ["node"],
2318 "box_attributes": ["RttEstimatorFactory",
2321 "ns3::olsr::RoutingProtocol": dict({
2322 "category": FC.CATEGORY_PROTOCOLS,
2323 "create_function": create_element,
2324 "configure_function": configure_element,
2326 "connector_types": [],
2327 "box_attributes": ["HelloInterval",
2333 "ns3::UdpEchoServer": dict({
2334 "category": FC.CATEGORY_APPLICATIONS,
2335 "create_function": create_element,
2336 "configure_function": configure_element,
2338 "connector_types": ["node"],
2339 "stop_function": stop_application,
2340 "start_function": start_application,
2341 "status_function": status_application,
2342 "box_attributes": ["Port",
2345 "tags": [tags.APPLICATION],
2347 "ns3::AmrrWifiManager": dict({
2348 "category": FC.CATEGORY_MANAGERS,
2349 "create_function": create_element,
2350 "configure_function": configure_element,
2352 "connector_types": ["dev"],
2353 "box_attributes": ["UpdatePeriod",
2356 "MaxSuccessThreshold",
2357 "MinSuccessThreshold",
2362 "FragmentationThreshold",
2365 "ns3::ArfWifiManager": dict({
2366 "category": FC.CATEGORY_MANAGERS,
2367 "create_function": create_element,
2368 "configure_function": configure_element,
2370 "connector_types": ["dev"],
2371 "box_attributes": ["TimerThreshold",
2377 "FragmentationThreshold",
2380 "ns3::SubscriberStationNetDevice": dict({
2381 "category": FC.CATEGORY_DEVICES,
2382 "create_function": create_subscriber_station,
2383 "configure_function": configure_station,
2384 "help": "Subscriber station for mobile wireless network",
2385 "connector_types": ["node", "chan", "phy", "sflows"],
2386 "box_attributes": ["LostDlMapInterval",
2387 "LostUlMapInterval",
2397 "MaxContentionRangingRetries",
2401 "traces": ["wimaxpcap", "wimaxascii"],
2402 "tags": [tags.INTERFACE, tags.ALLOW_ADDRESSES],
2404 "ns3::flame::FlameRtable": dict({
2406 "create_function": create_element,
2407 "configure_function": configure_element,
2409 "connector_types": [],
2410 "box_attributes": ["Lifetime"],
2412 "ns3::BSSchedulerRtps": dict({
2413 "category": FC.CATEGORY_SERVICE_FLOWS,
2414 "create_function": create_element,
2415 "configure_function": configure_element,
2416 "help": "Simple downlink scheduler for rtPS flows",
2417 "connector_types": ["dev"],
2418 "box_attributes": [],
2420 "ns3::BSSchedulerSimple": dict({
2421 "category": FC.CATEGORY_SERVICE_FLOWS,
2422 "create_function": create_element,
2423 "configure_function": configure_element,
2424 "help": "simple downlink scheduler for service flows",
2425 "connector_types": ["dev"],
2426 "box_attributes": [],
2428 "ns3::SimpleOfdmWimaxChannel": dict({
2429 "category": FC.CATEGORY_CHANNELS,
2430 "create_function": create_wimax_channel,
2431 "configure_function": configure_element,
2432 "help": "Wimax channel",
2433 "connector_types": ["devs"],
2434 "box_attributes": [],
2436 "ns3::SimpleOfdmWimaxPhy": dict({
2437 "category": FC.CATEGORY_PHY_MODELS,
2438 "create_function": create_wimax_phy,
2439 "configure_function": configure_element,
2440 "help": "Wimax Phy",
2441 "connector_types": ["dev"],
2442 "box_attributes": [],
2444 "ns3::UplinkSchedulerSimple": dict({
2445 "category": FC.CATEGORY_SERVICE_FLOWS,
2446 "create_function": create_element_no_constructor,
2447 "configure_function": configure_element,
2448 "help": "Simple uplink scheduler for service flows",
2449 "connector_types": ["dev"],
2450 "box_attributes": [],
2452 "ns3::UplinkSchedulerRtps": dict({
2453 "category": FC.CATEGORY_SERVICE_FLOWS,
2454 "create_function": create_element_no_constructor,
2455 "configure_function": configure_element,
2456 "help": "Simple uplink scheduler for rtPS flows",
2457 "connector_types": ["dev"],
2458 "box_attributes": [],
2460 "ns3::IpcsClassifierRecord": dict({
2461 "category": FC.CATEGORY_SERVICE_FLOWS,
2462 "create_function": create_ipcs_classifier_record,
2463 "configure_function": configure_element,
2464 "help": "Classifier record for service flow",
2465 "connector_types": ["sflow"],
2466 "box_attributes": ["ClassifierSrcAddress",
2467 "ClassifierSrcMask",
2468 "ClassifierDstAddress",
2469 "ClassifierDstMask",
2470 "ClassifierSrcPortLow",
2471 "ClassifierSrcPortHigh",
2472 "ClassifierDstPortLow",
2473 "ClassifierDstPortHigh",
2474 "ClassifierProtocol",
2475 "ClassifierPriority"],
2477 "ns3::ServiceFlow": dict({
2478 "category": FC.CATEGORY_SERVICE_FLOWS,
2479 "create_function": create_service_flow,
2480 "configure_function": configure_element,
2481 "help": "Service flow for QoS",
2482 "connector_types": ["classif", "dev"],
2483 "box_attributes": ["ServiceFlowDirection",
2484 "ServiceFlowSchedulingType"],