src/nepi/testbeds/ns3/factories_metadata_v3_9_RC3.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.util.constants import AF_INET, STATUS_NOT_STARTED, STATUS_RUNNING, \
   5         STATUS_FINISHED, STATUS_UNDETERMINED
   6
   7 def _get_ipv4_protocol_guid(testbed_instance, node_guid):
   8     # search for the Ipv4L3Protocol asociated with the device
   9     protos_guids = testbed_instance.get_connected(node_guid, "protos", "node")
  10     if len(protos_guids) == 0:
  11         raise RuntimeError("No protocols where found for the node %d" % node_guid)
  12     ipv4_guid = None
  13     for proto_guid in protos_guids:
  14         proto_factory_id = testbed_instance._create[proto_guid]
  15         if proto_factory_id == "ns3::Ipv4L3Protocol":
  16             ipv4_guid = proto_guid
  17             break
  18     if not ipv4_guid:
  19         raise RuntimeError("No Ipv4L3Protocol associated to node %d. \
  20                 can't add Ipv4 addresses" % node_guid)
  21     return ipv4_guid
  22
  23 def _get_node_guid(testbed_instance, guid):
  24     # search for the node asociated with the device
  25     node_guids = testbed_instance.get_connected(guid, "node", "devs")
  26     if len(node_guids) == 0:
  27         raise RuntimeError("Can't instantiate interface %d outside netns \
  28                 node" % guid)
  29     node_guid = node_guids[0]
  30     return node_guid
  31
  32 def _get_dev_number(testbed_instance, guid):
  33     node_guid = _get_node_guid(testbed_instance, guid)
  34     dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
  35     interface_number = 0
  36     for guid_ in dev_guids:
  37         if guid_ == guid:
  38             break
  39         interface_number += 1
  40     return interface_number
  41
  42 ### create traces functions ###
  43
  44 def p2pascii_trace(testbed_instance, guid, trace_id):
  45     node_guid = _get_node_guid(testbed_instance, guid)
  46     interface_number = _get_dev_number(testbed_instance, guid)
  47     element = testbed_instance._elements[guid]
  48     filename = "trace-p2p-node-%d-dev-%d.tr" % (node_guid, interface_number)
  49     testbed_instance.follow_trace(guid, trace_id, filename)
  50     filepath = testbed_instance.trace_filename(guid, trace_id)
  51     helper = testbed_instance.ns3.PointToPointHelper()
  52     asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
  53     stream = asciiHelper.CreateFileStream (filepath)
  54     helper.EnableAscii(stream, element)
  55
  56 def p2ppcap_trace(testbed_instance, guid, trace_id):
  57     node_guid = _get_node_guid(testbed_instance, guid)
  58     interface_number = _get_dev_number(testbed_instance, guid)
  59     element = testbed_instance._elements[guid]
  60     filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  61     testbed_instance.follow_trace(guid, trace_id, filename)
  62     filepath = testbed_instance.trace_filename(guid, trace_id)
  63     helper = testbed_instance.ns3.PointToPointHelper()
  64     helper.EnablePcap(filepath, element, explicitFilename = True)
  65
  66 def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
  67     node_guid = _get_node_guid(testbed_instance, guid)
  68     interface_number = _get_dev_number(testbed_instance, guid)
  69     element = testbed_instance._elements[guid]
  70     filename = "trace-csma-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  71     testbed_instance.follow_trace(guid, trace_id, filename)
  72     filepath = testbed_instance.trace_filename(guid, trace_id)
  73     helper = testbed_instance.ns3.CsmaHelper()
  74     helper.EnablePcap(filepath, element, promiscuous = promisc,
  75             explicitFilename = True)
  76
  77 def csmapcap_trace(testbed_instance, guid, trace_id):
  78     promisc = False
  79     _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
  80
  81 def csmapcap_promisc_trace(testbed_instance, guid, trace_id):
  82     promisc = True
  83     _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
  84
  85 def fdpcap_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-fd-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  90     testbed_instance.follow_trace(guid, trace_id, filename)
  91     filepath = testbed_instance.trace_filename(guid, trace_id)
  92     helper = testbed_instance.ns3.FileDescriptorHelper()
  93     helper.EnablePcap(filepath, element, explicitFilename = True)
  94
  95 def yanswifipcap_trace(testbed_instance, guid, trace_id):
  96     dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
  97     node_guid = _get_node_guid(testbed_instance, dev_guid)
  98     interface_number = _get_dev_number(testbed_instance, dev_guid)
  99     element = testbed_instance._elements[dev_guid]
 100     filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
 101     testbed_instance.follow_trace(guid, trace_id, filename)
 102     filepath = testbed_instance.trace_filename(guid, trace_id)
 103     helper = testbed_instance.ns3.YansWifiPhyHelper()
 104     helper.EnablePcap(filepath, element, explicitFilename = True)
 105
 106 trace_functions = dict({
 107     "P2PPcapTrace": p2ppcap_trace,
 108     "P2PAsciiTrace": p2pascii_trace,
 109     "CsmaPcapTrace": csmapcap_trace,
 110     "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
 111     "FileDescriptorPcapTrace": fdpcap_trace,
 112     "YansWifiPhyPcapTrace": yanswifipcap_trace
 113     })
 114
 115 ### Creation functions ###
 116
 117 wifi_standards = dict({
 118     "WIFI_PHY_STANDARD_holland": 5,
 119     "WIFI_PHY_STANDARD_80211p_SCH": 7,
 120     "WIFI_PHY_STANDARD_80211_5Mhz": 4,
 121     "WIFI_PHY_UNKNOWN": 8,
 122     "WIFI_PHY_STANDARD_80211_10Mhz": 3,
 123     "WIFI_PHY_STANDARD_80211g": 2,
 124     "WIFI_PHY_STANDARD_80211p_CCH": 6,
 125     "WIFI_PHY_STANDARD_80211a": 0,
 126     "WIFI_PHY_STANDARD_80211b": 1
 127 })
 128
 129 def create_element(testbed_instance, guid):
 130     element_factory = testbed_instance.ns3.ObjectFactory()
 131     factory_id = testbed_instance._create[guid]
 132     element_factory.SetTypeId(factory_id)
 133     construct_parameters = testbed_instance._get_construct_parameters(guid)
 134     for name, value in construct_parameters.iteritems():
 135         ns3_value = testbed_instance._to_ns3_value(guid, name, value)
 136         element_factory.Set(name, ns3_value)
 137     element = element_factory.Create()
 138     testbed_instance._elements[guid] = element
 139
 140 def create_node(testbed_instance, guid):
 141     create_element(testbed_instance, guid)
 142     element = testbed_instance._elements[guid]
 143     element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
 144
 145 def create_wifi_standard_model(testbed_instance, guid):
 146     create_element(testbed_instance, guid)
 147     element = testbed_instance._elements[guid]
 148     parameters = testbed_instance._get_parameters(guid)
 149     if "Standard" in parameters:
 150         standard = parameters["Standard"]
 151         if standard:
 152             element.ConfigureStandard(wifi_standards[standard])
 153
 154 def create_ipv4protocol(testbed_instance, guid):
 155     create_element(testbed_instance, guid)
 156     element = testbed_instance._elements[guid]
 157     list_routing = testbed_instance.ns3.Ipv4ListRouting()
 158     element.SetRoutingProtocol(list_routing)
 159     static_routing = testbed_instance.ns3.Ipv4StaticRouting()
 160     list_routing.AddRoutingProtocol(static_routing, 1)
 161
 162 ### Start/Stop functions ###
 163
 164 def start_application(testbed_instance, guid):
 165     element = testbed_instance.elements[guid]
 166     # BUG: without doing this explicit call it doesn't start!!!
 167     # Shouldn't be enough to set the StartTime?
 168     element.Start()
 169
 170 def stop_application(testbed_instance, guid):
 171     element = testbed_instance.elements[guid]
 172     now = testbed_instance.ns3.Simulator.Now()
 173     element.SetStopTime(now)
 174
 175 ### Status functions ###
 176
 177 def status_application(testbed_instance, guid):
 178     if guid not in testbed_instance.elements.keys():
 179         raise RuntimeError("Can't get status on guid %d" % guid )
 180     now = testbed_instance.ns3.Simulator.Now()
 181     if now.IsZero():
 182         return STATUS_NOT_STARTED
 183     app = testbed_instance.elements[guid]
 184     parameters = testbed_instance._get_parameters(guid)
 185     if "StartTime" in parameters and parameters["StartTime"]:
 186         start_value = parameters["StartTime"]
 187         start_time = testbed_instance.ns3.Time(start_value)
 188         if now.Compare(start_time) < 0:
 189             return STATUS_NOT_RUNNING
 190     if "StopTime" in parameters and parameters["StopTime"]:
 191         stop_value = parameters["StopTime"]
 192         stop_time = testbed_instance.ns3.Time(stop_value)
 193         if now.Compare(stop_time) < 0:
 194             return STATUS_RUNNING
 195         else:
 196             return STATUS_FINISHED
 197     return STATUS_UNDETERMINED
 198
 199 ### Configure functions ###
 200
 201 def configure_traces(testbed_instance, guid):
 202     traces = testbed_instance._get_traces(guid)
 203     for trace_id in traces:
 204         trace_func = trace_functions[trace_id]
 205         trace_func(testbed_instance, guid, trace_id)
 206
 207 def configure_element(testbed_instance, guid):
 208     configure_traces(testbed_instance, guid)
 209
 210 def configure_device(testbed_instance, guid):
 211     configure_traces(testbed_instance, guid)
 212
 213     element = testbed_instance._elements[guid]
 214
 215     parameters = testbed_instance._get_parameters(guid)
 216     if "macAddress" in parameters:
 217         address = parameters["macAddress"]
 218         macaddr = testbed_instance.ns3.Mac48Address(address)
 219     else:
 220         macaddr = testbed_instance.ns3.Mac48Address.Allocate()
 221     element.SetAddress(macaddr)
 222
 223     if not guid in testbed_instance._add_address:
 224         return
 225     # search for the node asociated with the device
 226     node_guid = _get_node_guid(testbed_instance, guid)
 227     node = testbed_instance.elements[node_guid]
 228     # search for the Ipv4L3Protocol asociated with the device
 229     ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
 230     ipv4 = testbed_instance._elements[ipv4_guid]
 231     ns3 = testbed_instance.ns3
 232     # add addresses
 233     addresses = testbed_instance._add_address[guid]
 234     for address in addresses:
 235         (address, netprefix, broadcast) = address
 236         # TODO: missing IPV6 addresses!!
 237         ifindex = ipv4.AddInterface(element)
 238         inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
 239                 ns3.Ipv4Mask("/%d" % netprefix))
 240         ipv4.AddAddress(ifindex, inaddr)
 241         ipv4.SetMetric(ifindex, 1)
 242         ipv4.SetUp(ifindex)
 243
 244 def _add_static_route(ns3, static_routing,
 245         address, netprefix, nexthop_address, ifindex):
 246     if netprefix == 0:
 247         # Default route: 0.0.0.0/0
 248         static_routing.SetDefaultRoute(nexthop_address, ifindex)
 249     elif netprefix == 32:
 250         # Host route: x.y.z.w/32
 251         static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
 252     else:
 253         # Network route: x.y.z.w/n
 254         mask = ns3.Ipv4Mask("/%d" % netprefix)
 255         static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
 256                 ifindex)
 257
 258 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
 259     if netprefix == 0:
 260         # Default route: 0.0.0.0/0
 261         static_routing.SetDefaultRoute(ifindex)
 262     elif netprefix == 32:
 263         # Host route: x.y.z.w/32
 264         static_routing.AddHostRouteTo(address, ifindex)
 265     else:
 266         # Network route: x.y.z.w/n
 267         mask = ns3.Ipv4Mask("/%d" % netprefix)
 268         static_routing.AddNetworkRouteTo(address, mask, ifindex)
 269
 270 def configure_node(testbed_instance, guid):
 271     configure_traces(testbed_instance, guid)
 272
 273     element = testbed_instance._elements[guid]
 274     if not guid in testbed_instance._add_route:
 275         return
 276     # search for the Ipv4L3Protocol asociated with the device
 277     ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
 278     ipv4 = testbed_instance._elements[ipv4_guid]
 279     list_routing = ipv4.GetRoutingProtocol()
 280     (static_routing, priority) = list_routing.GetRoutingProtocol(0)
 281     ns3 = testbed_instance.ns3
 282     routes = testbed_instance._add_route[guid]
 283     for route in routes:
 284         (destination, netprefix, nexthop) = route
 285         address = ns3.Ipv4Address(destination)
 286         if nexthop:
 287             nexthop_address = ns3.Ipv4Address(nexthop)
 288             ifindex = -1
 289             # TODO: HACKISH way of getting the ifindex... improve this
 290             nifaces = ipv4.GetNInterfaces()
 291             for ifidx in range(nifaces):
 292                 iface = ipv4.GetInterface(ifidx)
 293                 naddress = iface.GetNAddresses()
 294                 for addridx in range(naddress):
 295                     ifaddr = iface.GetAddress(addridx)
 296                     ifmask = ifaddr.GetMask()
 297                     ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
 298                     if ifindex == ifidx:
 299                         break
 300             _add_static_route(ns3, static_routing,
 301                 address, netprefix, nexthop_address, ifindex)
 302         else:
 303             mask = ns3.Ipv4Mask("/%d" % netprefix)
 304             ifindex = ipv4.GetInterfaceForPrefix(address, mask)
 305             _add_static_route_if(ns3, static_routing,
 306                 address, netprefix, nexthop_address, ifindex)
 307
 308 factories_info = dict({
 309     "ns3::Ping6": dict({
 310         "category": "Application",
 311         "create_function": create_element,
 312         "configure_function": configure_element,
 313         "help": "",
 314         "connector_types": [],
 315         "stop_function": stop_application,
 316         "start_function": start_application,
 317         "status_function": status_application,
 318         "box_attributes": ["MaxPackets",
 319             "Interval",
 320             "RemoteIpv6",
 321             "LocalIpv6",
 322             "PacketSize",
 323             "StartTime",
 324             "StopTime"],
 325     }),
 326      "ns3::UdpL4Protocol": dict({
 327         "category": "Protocol",
 328         "create_function": create_element,
 329         "configure_function": configure_element,
 330         "help": "",
 331         "connector_types": ["node"],
 332         "box_attributes": ["ProtocolNumber"],
 333     }),
 334      "ns3::RandomDiscPositionAllocator": dict({
 335         "category": "Mobility",
 336         "create_function": create_element,
 337         "configure_function": configure_element,
 338         "help": "",
 339         "connector_types": [],
 340         "box_attributes": ["Theta",
 341             "Rho",
 342             "X",
 343             "Y"],
 344     }),
 345      "ns3::Node": dict({
 346         "category": "Topology",
 347         "create_function": create_node,
 348         "configure_function": configure_node,
 349         "help": "",
 350         "connector_types": ["devs", "apps", "protos", "mobility"],
 351         "allow_routes": True,
 352         "box_attributes": [],
 353     }),
 354      "ns3::GridPositionAllocator": dict({
 355         "category": "Mobility",
 356         "create_function": create_element,
 357         "configure_function": configure_element,
 358         "help": "",
 359         "connector_types": [],
 360         "box_attributes": ["GridWidth",
 361             "MinX",
 362             "MinY",
 363             "DeltaX",
 364             "DeltaY",
 365             "LayoutType"],
 366     }),
 367      "ns3::TapBridge": dict({
 368         "category": "Device",
 369         "create_function": create_element,
 370         "configure_function": configure_element,
 371         "help": "",
 372         "connector_types": [],
 373         "allow_addresses": True,
 374         "box_attributes": ["Mtu",
 375             "DeviceName",
 376             "Gateway",
 377             "IpAddress",
 378             "MacAddress",
 379             "Netmask",
 380             "Start",
 381             "Stop"],
 382     }),
 383      "ns3::FlowMonitor": dict({
 384         "category": "",
 385         "create_function": create_element,
 386         "configure_function": configure_element,
 387         "help": "",
 388         "connector_types": [],
 389         "box_attributes": ["MaxPerHopDelay",
 390             "DelayBinWidth",
 391             "JitterBinWidth",
 392             "PacketSizeBinWidth",
 393             "FlowInterruptionsBinWidth",
 394             "FlowInterruptionsMinTime"],
 395     }),
 396      "ns3::ConstantVelocityMobilityModel": dict({
 397         "category": "Mobility",
 398         "create_function": create_element,
 399         "configure_function": configure_element,
 400         "help": "",
 401         "connector_types": ["node"],
 402         "box_attributes": ["Position",
 403            "Velocity"],
 404     }),
 405      "ns3::V4Ping": dict({
 406         "category": "Application",
 407         "create_function": create_element,
 408         "configure_function": configure_element,
 409         "help": "",
 410         "connector_types": ["node"],
 411         "stop_function": stop_application,
 412         "start_function": start_application,
 413         "status_function": status_application,
 414         "box_attributes": ["Remote",
 415             "Verbose",
 416             "Interval",
 417             "Size",
 418             "StartTime",
 419             "StopTime"],
 420     }),
 421      "ns3::dot11s::PeerLink": dict({
 422         "category": "",
 423         "create_function": create_element,
 424         "configure_function": configure_element,
 425         "help": "",
 426         "connector_types": [],
 427         "box_attributes": ["RetryTimeout",
 428             "HoldingTimeout",
 429             "ConfirmTimeout",
 430             "MaxRetries",
 431             "MaxBeaconLoss",
 432             "MaxPacketFailure"],
 433     }),
 434      "ns3::PointToPointNetDevice": dict({
 435         "category": "Device",
 436         "create_function": create_element,
 437         "configure_function": configure_device,
 438         "help": "",
 439         "connector_types": ["node", "err", "queue", "chan"],
 440         "allow_addresses": True,
 441         "box_attributes": ["Mtu",
 442             "Address",
 443             "DataRate",
 444             "InterframeGap"],
 445         "traces": ["p2ppcap", "p2pascii"]
 446     }),
 447      "ns3::NakagamiPropagationLossModel": dict({
 448         "category": "Loss",
 449         "create_function": create_element,
 450         "configure_function": configure_element,
 451         "help": "",
 452         "connector_types": [],
 453         "box_attributes": ["Distance1",
 454             "Distance2",
 455             "m0",
 456             "m1",
 457             "m2"],
 458     }),
 459      "ns3::AarfWifiManager": dict({
 460         "category": "Manager",
 461         "create_function": create_element,
 462         "configure_function": configure_element,
 463         "help": "",
 464         "connector_types": [],
 465         "box_attributes": ["SuccessK",
 466             "TimerK",
 467             "MaxSuccessThreshold",
 468             "MinTimerThreshold",
 469             "MinSuccessThreshold",
 470             "IsLowLatency",
 471             "MaxSsrc",
 472             "MaxSlrc",
 473             "RtsCtsThreshold",
 474             "FragmentationThreshold",
 475             "NonUnicastMode"],
 476     }),
 477      "ns3::Ipv6OptionJumbogram": dict({
 478         "category": "",
 479         "create_function": create_element,
 480         "configure_function": configure_element,
 481         "help": "",
 482         "connector_types": [],
 483         "box_attributes": ["OptionNumber"],
 484     }),
 485      "ns3::TwoRayGroundPropagationLossModel": dict({
 486         "category": "Loss",
 487         "create_function": create_element,
 488         "configure_function": configure_element,
 489         "help": "",
 490         "connector_types": [],
 491         "box_attributes": ["Lambda",
 492             "SystemLoss",
 493             "MinDistance",
 494             "HeightAboveZ"],
 495     }),
 496      "ns3::OnOffApplication": dict({
 497         "category": "Application",
 498         "create_function": create_element,
 499         "configure_function": configure_element,
 500         "help": "",
 501         "connector_types": ["node"],
 502         "stop_function": stop_application,
 503         "start_function": start_application,
 504         "status_function": status_application,
 505         "box_attributes": ["DataRate",
 506             "PacketSize",
 507             "Remote",
 508             "OnTime",
 509             "OffTime",
 510             "MaxBytes",
 511             "Protocol",
 512             "StartTime",
 513             "StopTime"],
 514     }),
 515      "ns3::AdhocWifiMac": dict({
 516         "category": "Mac",
 517         "create_function": create_element,
 518         "configure_function": configure_element,
 519         "help": "",
 520         "connector_types": [],
 521         "box_attributes": ["CtsTimeout",
 522             "AckTimeout",
 523             "BasicBlockAckTimeout",
 524             "CompressedBlockAckTimeout",
 525             "Sifs",
 526             "EifsNoDifs",
 527             "Slot",
 528             "Pifs",
 529             "MaxPropagationDelay",
 530             "Ssid"],
 531     }),
 532      "ns3::ConstantAccelerationMobilityModel": dict({
 533         "category": "Mobility",
 534         "create_function": create_element,
 535         "configure_function": configure_element,
 536         "help": "",
 537         "connector_types": ["node"],
 538         "box_attributes": ["Position",
 539             "Velocity"],
 540     }),
 541      "ns3::GaussMarkovMobilityModel": dict({
 542         "category": "Mobility",
 543         "create_function": create_element,
 544         "configure_function": configure_element,
 545         "help": "",
 546         "connector_types": [],
 547         "box_attributes": ["Bounds",
 548             "TimeStep",
 549             "Alpha",
 550             "MeanVelocity",
 551             "MeanDirection",
 552             "MeanPitch",
 553             "NormalVelocity",
 554             "NormalDirection",
 555             "NormalPitch",
 556             "Position",
 557             "Velocity"],
 558     }),
 559      "ns3::dot11s::HwmpProtocol": dict({
 560         "category": "Protocol",
 561         "create_function": create_element,
 562         "configure_function": configure_element,
 563         "help": "",
 564         "connector_types": [],
 565         "box_attributes": ["RandomStart",
 566             "MaxQueueSize",
 567             "Dot11MeshHWMPmaxPREQretries",
 568             "Dot11MeshHWMPnetDiameterTraversalTime",
 569             "Dot11MeshHWMPpreqMinInterval",
 570             "Dot11MeshHWMPperrMinInterval",
 571             "Dot11MeshHWMPactiveRootTimeout",
 572             "Dot11MeshHWMPactivePathTimeout",
 573             "Dot11MeshHWMPpathToRootInterval",
 574             "Dot11MeshHWMPrannInterval",
 575             "MaxTtl",
 576             "UnicastPerrThreshold",
 577             "UnicastPreqThreshold",
 578             "UnicastDataThreshold",
 579             "DoFlag",
 580             "RfFlag"],
 581     }),
 582      "ns3::NscTcpL4Protocol": dict({
 583         "category": "Protocol",
 584         "create_function": create_element,
 585         "configure_function": configure_element,
 586         "help": "",
 587         "connector_types": [],
 588         "box_attributes": ["Library",
 589           "ProtocolNumber"],
 590     }),
 591      "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
 592         "category": "",
 593         "create_function": create_element,
 594         "configure_function": configure_element,
 595         "help": "",
 596         "connector_types": [],
 597         "box_attributes": ["Dot11sMeshHeaderLength"],
 598     }),
 599      "ns3::UanMacCw": dict({
 600         "category": "",
 601         "create_function": create_element,
 602         "configure_function": configure_element,
 603         "help": "",
 604         "connector_types": [],
 605         "box_attributes": ["CW",
 606            "SlotTime"],
 607     }),
 608      "ns3::AthstatsWifiTraceSink": dict({
 609         "category": "",
 610         "create_function": create_element,
 611         "configure_function": configure_element,
 612         "help": "",
 613         "connector_types": [],
 614         "box_attributes": ["Interval"],
 615     }),
 616      "ns3::FlameStack": dict({
 617         "category": "",
 618         "create_function": create_element,
 619         "configure_function": configure_element,
 620         "help": "",
 621         "connector_types": [],
 622         "box_attributes": [],
 623     }),
 624      "ns3::UanMacRc": dict({
 625         "category": "",
 626         "create_function": create_element,
 627         "configure_function": configure_element,
 628         "help": "",
 629         "connector_types": [],
 630         "box_attributes": ["RetryRate",
 631             "MaxFrames",
 632             "QueueLimit",
 633             "SIFS",
 634             "NumberOfRates",
 635             "MinRetryRate",
 636             "RetryStep",
 637             "NumberOfRetryRates",
 638             "MaxPropDelay"],
 639     }),
 640      "ns3::WaypointMobilityModel": dict({
 641         "category": "Mobility",
 642         "create_function": create_element,
 643         "configure_function": configure_element,
 644         "help": "",
 645         "connector_types": [],
 646         "box_attributes": ["WaypointsLeft",
 647             "Position",
 648             "Velocity"],
 649     }),
 650      "ns3::FileDescriptorNetDevice": dict({
 651         "category": "Device",
 652         "create_function": create_element,
 653         "configure_function": configure_device,
 654         "help": "Network interface associated to a file descriptor",
 655         "connector_types": ["node", "->fd"],
 656         "allow_addresses": True,
 657         "box_attributes": ["Address",
 658             "LinuxSocketAddress",
 659             "tun_proto", "tun_addr", "tun_port", "tun_key"],
 660         "traces": ["fdpcap"]
 661     }),
 662      "ns3::CsmaNetDevice": dict({
 663         "category": "Device",
 664         "create_function": create_element,
 665         "configure_function": configure_device,
 666         "help": "CSMA (carrier sense, multiple access) interface",
 667         "connector_types": ["node", "chan", "err", "queue"],
 668         "allow_addresses": True,
 669         "box_attributes": ["Address",
 670             "Mtu",
 671             "SendEnable",
 672             "ReceiveEnable"],
 673         "traces": ["csmapcap", "csmapcap_promisc"]
 674     }),
 675      "ns3::UanPropModelThorp": dict({
 676         "category": "",
 677         "create_function": create_element,
 678         "configure_function": configure_element,
 679         "help": "",
 680         "connector_types": [],
 681         "box_attributes": ["SpreadCoef"],
 682     }),
 683      "ns3::NqstaWifiMac": dict({
 684         "category": "Mac",
 685         "create_function": create_element,
 686         "configure_function": configure_element,
 687         "help": "",
 688         "connector_types": [],
 689         "box_attributes": ["ProbeRequestTimeout",
 690             "AssocRequestTimeout",
 691             "MaxMissedBeacons",
 692             "CtsTimeout",
 693             "AckTimeout",
 694             "BasicBlockAckTimeout",
 695             "CompressedBlockAckTimeout",
 696             "Sifs",
 697             "EifsNoDifs",
 698             "Slot",
 699             "Pifs",
 700             "MaxPropagationDelay",
 701             "Ssid"],
 702     }),
 703      "ns3::Icmpv6L4Protocol": dict({
 704         "category": "Protocol",
 705         "create_function": create_element,
 706         "configure_function": configure_element,
 707         "help": "",
 708         "connector_types": ["node"],
 709         "box_attributes": ["DAD",
 710             "ProtocolNumber"],
 711     }),
 712      "ns3::SimpleNetDevice": dict({
 713         "category": "Device",
 714         "create_function": create_element,
 715         "configure_function": configure_element,
 716         "help": "",
 717         "connector_types": ["node", "chan"],
 718         "allow_addresses": True,
 719         "box_attributes": [],
 720     }),
 721      "ns3::FriisPropagationLossModel": dict({
 722         "category": "Loss",
 723         "create_function": create_element,
 724         "configure_function": configure_element,
 725         "help": "",
 726         "connector_types": [],
 727         "box_attributes": ["Lambda",
 728             "SystemLoss",
 729             "MinDistance"],
 730     }),
 731      "ns3::Ipv6OptionRouterAlert": dict({
 732         "category": "",
 733         "create_function": create_element,
 734         "configure_function": configure_element,
 735         "help": "",
 736         "connector_types": [],
 737         "box_attributes": ["OptionNumber"],
 738     }),
 739      "ns3::UniformDiscPositionAllocator": dict({
 740         "category": "Mobility",
 741         "create_function": create_element,
 742         "configure_function": configure_element,
 743         "help": "",
 744         "connector_types": [],
 745         "box_attributes": ["rho",
 746             "X",
 747             "Y"],
 748     }),
 749      "ns3::RandomBoxPositionAllocator": dict({
 750         "category": "Mobility",
 751         "create_function": create_element,
 752         "configure_function": configure_element,
 753         "help": "",
 754         "connector_types": [],
 755         "box_attributes": ["X",
 756             "Y",
 757             "Z"],
 758     }),
 759      "ns3::Ipv6ExtensionDestination": dict({
 760         "category": "",
 761         "create_function": create_element,
 762         "configure_function": configure_element,
 763         "help": "",
 764         "connector_types": [],
 765         "box_attributes": ["ExtensionNumber"],
 766     }),
 767      "ns3::LoopbackNetDevice": dict({
 768         "category": "Device",
 769         "create_function": create_element,
 770         "configure_function": configure_element,
 771         "help": "",
 772         "connector_types": [],
 773         "box_attributes": [],
 774     }),
 775      "ns3::ConstantSpeedPropagationDelayModel": dict({
 776         "category": "Delay",
 777         "create_function": create_element,
 778         "configure_function": configure_element,
 779         "help": "",
 780         "connector_types": ["chan"],
 781         "box_attributes": ["Speed"],
 782     }),
 783      "ns3::Ipv6ExtensionHopByHop": dict({
 784         "category": "",
 785         "create_function": create_element,
 786         "configure_function": configure_element,
 787         "help": "",
 788         "connector_types": [],
 789         "box_attributes": ["ExtensionNumber"],
 790     }),
 791      "ns3::BridgeChannel": dict({
 792         "category": "Channel",
 793         "create_function": create_element,
 794         "configure_function": configure_element,
 795         "help": "",
 796         "connector_types": [],
 797         "box_attributes": [],
 798     }),
 799      "ns3::Radvd": dict({
 800         "category": "",
 801         "create_function": create_element,
 802         "configure_function": configure_element,
 803         "help": "",
 804         "connector_types": [],
 805         "box_attributes": ["StartTime",
 806             "StopTime"],
 807     }),
 808      "ns3::PacketSocket": dict({
 809         "category": "",
 810         "create_function": create_element,
 811         "configure_function": configure_element,
 812         "help": "",
 813         "connector_types": [],
 814         "box_attributes": ["RcvBufSize"],
 815     }),
 816      "ns3::flame::FlameProtocol": dict({
 817         "category": "Protocol",
 818         "create_function": create_element,
 819         "configure_function": configure_element,
 820         "help": "",
 821         "connector_types": [],
 822         "box_attributes": ["BroadcastInterval",
 823             "MaxCost"],
 824     }),
 825      "ns3::Cost231PropagationLossModel": dict({
 826         "category": "Loss",
 827         "create_function": create_element,
 828         "configure_function": configure_element,
 829         "help": "",
 830         "connector_types": [],
 831         "box_attributes": ["Lambda",
 832             "Frequency",
 833             "BSAntennaHeight",
 834             "SSAntennaHeight",
 835             "MinDistance"],
 836     }),
 837      "ns3::Ipv6ExtensionESP": dict({
 838         "category": "",
 839         "create_function": create_element,
 840         "configure_function": configure_element,
 841         "help": "",
 842         "connector_types": [],
 843         "box_attributes": ["ExtensionNumber"],
 844     }),
 845      "ns3::CaraWifiManager": dict({
 846         "category": "Manager",
 847         "create_function": create_element,
 848         "configure_function": configure_element,
 849         "help": "",
 850         "connector_types": [],
 851         "box_attributes": ["ProbeThreshold",
 852             "FailureThreshold",
 853             "SuccessThreshold",
 854             "Timeout",
 855             "IsLowLatency",
 856             "MaxSsrc",
 857             "MaxSlrc",
 858             "RtsCtsThreshold",
 859             "FragmentationThreshold",
 860             "NonUnicastMode"],
 861
 862     }),
 863      "ns3::RttMeanDeviation": dict({
 864         "category": "",
 865         "create_function": create_element,
 866         "configure_function": configure_element,
 867         "help": "",
 868         "connector_types": [],
 869         "box_attributes": ["Gain",
 870             "MaxMultiplier",
 871             "InitialEstimation",
 872             "MinRTO"],
 873     }),
 874      "ns3::Icmpv4L4Protocol": dict({
 875         "category": "Protocol",
 876         "create_function": create_element,
 877         "configure_function": configure_element,
 878         "help": "",
 879         "connector_types": ["node"],
 880         "box_attributes": ["ProtocolNumber"],
 881     }),
 882      "ns3::WaveformGenerator": dict({
 883         "category": "",
 884         "create_function": create_element,
 885         "configure_function": configure_element,
 886         "help": "",
 887         "connector_types": [],
 888         "box_attributes": ["Period",
 889             "DutyCycle"],
 890     }),
 891      "ns3::YansWifiChannel": dict({
 892         "category": "Channel",
 893         "create_function": create_element,
 894         "configure_function": configure_element,
 895         "help": "",
 896         "connector_types": ["phys", "delay", "loss"],
 897         "box_attributes": [],
 898     }),
 899      "ns3::SimpleChannel": dict({
 900         "category": "Channel",
 901         "create_function": create_element,
 902         "configure_function": configure_element,
 903         "help": "",
 904         "connector_types": ["devs"],
 905         "box_attributes": [],
 906     }),
 907      "ns3::Ipv6ExtensionFragment": dict({
 908         "category": "",
 909         "create_function": create_element,
 910         "configure_function": configure_element,
 911         "help": "",
 912         "connector_types": [],
 913         "box_attributes": ["ExtensionNumber"],
 914     }),
 915      "ns3::Dot11sStack": dict({
 916         "category": "",
 917         "create_function": create_element,
 918         "configure_function": configure_element,
 919         "help": "",
 920         "connector_types": [],
 921         "box_attributes": ["Root"],
 922     }),
 923      "ns3::FriisSpectrumPropagationLossModel": dict({
 924         "category": "Loss",
 925         "create_function": create_element,
 926         "configure_function": configure_element,
 927         "help": "",
 928         "connector_types": [],
 929         "box_attributes": [],
 930     }),
 931      "ns3::RandomRectanglePositionAllocator": dict({
 932         "category": "Mobility",
 933         "create_function": create_element,
 934         "configure_function": configure_element,
 935         "help": "",
 936         "connector_types": [],
 937         "box_attributes": ["X",
 938            "Y"],
 939     }),
 940      "ns3::NqapWifiMac": dict({
 941         "category": "",
 942         "create_function": create_element,
 943         "configure_function": configure_element,
 944         "help": "",
 945         "connector_types": [],
 946         "box_attributes": ["BeaconInterval",
 947             "BeaconGeneration",
 948             "CtsTimeout",
 949             "AckTimeout",
 950             "BasicBlockAckTimeout",
 951             "CompressedBlockAckTimeout",
 952             "Sifs",
 953             "EifsNoDifs",
 954             "Slot",
 955             "Pifs",
 956             "MaxPropagationDelay",
 957             "Ssid"],
 958     }),
 959      "ns3::HierarchicalMobilityModel": dict({
 960         "category": "Mobility",
 961         "create_function": create_element,
 962         "configure_function": configure_element,
 963         "help": "",
 964         "connector_types": ["node"],
 965         "box_attributes": ["Position",
 966             "Velocity"],
 967     }),
 968      "ns3::ThreeLogDistancePropagationLossModel": dict({
 969         "category": "Loss",
 970         "create_function": create_element,
 971         "configure_function": configure_element,
 972         "help": "",
 973         "connector_types": [],
 974         "box_attributes": ["Distance0",
 975             "Distance1",
 976             "Distance2",
 977             "Exponent0",
 978             "Exponent1",
 979             "Exponent2",
 980             "ReferenceLoss"],
 981     }),
 982      "ns3::UanNoiseModelDefault": dict({
 983         "category": "",
 984         "create_function": create_element,
 985         "configure_function": configure_element,
 986         "help": "",
 987         "connector_types": [],
 988         "box_attributes": ["Wind",
 989             "Shipping"],
 990     }),
 991      "ns3::dot11s::HwmpRtable": dict({
 992         "category": "",
 993         "create_function": create_element,
 994         "configure_function": configure_element,
 995         "help": "",
 996         "connector_types": [],
 997         "box_attributes": [],
 998     }),
 999      "ns3::PacketBurst": dict({
1000         "category": "",
1001         "create_function": create_element,
1002         "configure_function": configure_element,
1003         "help": "",
1004         "connector_types": [],
1005         "box_attributes": [],
1006     }),
1007      "ns3::RandomPropagationDelayModel": dict({
1008         "category": "Delay",
1009         "create_function": create_element,
1010         "configure_function": configure_element,
1011         "help": "",
1012         "connector_types": [],
1013         "box_attributes": ["Variable"],
1014     }),
1015      "ns3::ArpL3Protocol": dict({
1016         "category": "Protocol",
1017         "create_function": create_element,
1018         "configure_function": configure_element,
1019         "help": "",
1020         "connector_types": ["node"],
1021         "box_attributes": [],
1022     }),
1023      "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1024         "category": "Mobility",
1025         "create_function": create_element,
1026         "configure_function": configure_element,
1027         "help": "",
1028         "connector_types": [],
1029         "box_attributes": ["MinSpeed",
1030             "MaxSpeed",
1031             "MinPause",
1032             "MaxPause",
1033             "MinX",
1034             "MaxX",
1035             "MinY",
1036             "MaxY",
1037             "Position",
1038             "Velocity"],
1039     }),
1040      "ns3::BaseStationNetDevice": dict({
1041         "category": "Device",
1042         "create_function": create_element,
1043         "configure_function": configure_device,
1044         "help": "",
1045         "connector_types": [],
1046         "allow_addresses": True,
1047         "box_attributes": ["InitialRangInterval",
1048             "DcdInterval",
1049             "UcdInterval",
1050             "IntervalT8",
1051             "RangReqOppSize",
1052             "BwReqOppSize",
1053             "MaxRangCorrectionRetries",
1054             "Mtu",
1055             "RTG",
1056             "TTG"],
1057     }),
1058      "ns3::UdpServer": dict({
1059         "category": "Application",
1060         "create_function": create_element,
1061         "configure_function": configure_element,
1062         "help": "",
1063         "connector_types": [],
1064         "stop_function": stop_application,
1065         "start_function": start_application,
1066         "status_function": status_application,
1067         "box_attributes": ["Port",
1068             "PacketWindowSize",
1069             "StartTime",
1070             "StopTime"],
1071     }),
1072      "ns3::AarfcdWifiManager": dict({
1073         "category": "Manager",
1074         "create_function": create_element,
1075         "configure_function": configure_element,
1076         "help": "",
1077         "connector_types": [],
1078         "box_attributes": ["SuccessK",
1079             "TimerK",
1080             "MaxSuccessThreshold",
1081             "MinTimerThreshold",
1082             "MinSuccessThreshold",
1083             "MinRtsWnd",
1084             "MaxRtsWnd",
1085             "TurnOffRtsAfterRateDecrease",
1086             "TurnOnRtsAfterRateIncrease",
1087             "IsLowLatency",
1088             "MaxSsrc",
1089             "MaxSlrc",
1090             "RtsCtsThreshold",
1091             "FragmentationThreshold",
1092             "NonUnicastMode"],
1093     }),
1094      "ns3::UanTransducerHd": dict({
1095         "category": "",
1096         "create_function": create_element,
1097         "configure_function": configure_element,
1098         "help": "",
1099         "connector_types": [],
1100         "box_attributes": [],
1101     }),
1102      "ns3::LogDistancePropagationLossModel": dict({
1103         "category": "Loss",
1104         "create_function": create_element,
1105         "configure_function": configure_element,
1106         "help": "",
1107         "connector_types": ["prev", "next"],
1108         "box_attributes": ["Exponent",
1109             "ReferenceDistance",
1110             "ReferenceLoss"],
1111     }),
1112      "ns3::EmuNetDevice": dict({
1113         "category": "Device",
1114         "create_function": create_element,
1115         "configure_function": configure_element,
1116         "help": "",
1117         "connector_types": ["node", "queue"],
1118         "box_attributes": ["Mtu",
1119             "Address",
1120             "DeviceName",
1121             "Start",
1122             "Stop",
1123             "RxQueueSize"],
1124     }),
1125      "ns3::Ipv6ExtensionLooseRouting": dict({
1126         "category": "",
1127         "create_function": create_element,
1128         "configure_function": configure_element,
1129         "help": "",
1130         "connector_types": [],
1131         "box_attributes": ["ExtensionNumber"],
1132     }),
1133      "ns3::RandomWaypointMobilityModel": dict({
1134         "category": "Mobility",
1135         "create_function": create_element,
1136         "configure_function": configure_element,
1137         "help": "",
1138         "connector_types": ["node"],
1139         "box_attributes": ["Speed",
1140             "Pause",
1141             "Position",
1142             "Velocity"],
1143     }),
1144      "ns3::RangePropagationLossModel": dict({
1145         "category": "",
1146         "create_function": create_element,
1147         "configure_function": configure_element,
1148         "help": "",
1149         "connector_types": [],
1150         "box_attributes": ["MaxRange"],
1151     }),
1152      "ns3::AlohaNoackNetDevice": dict({
1153         "category": "Device",
1154         "create_function": create_element,
1155         "configure_function": configure_element,
1156         "help": "",
1157         "connector_types": [],
1158         "box_attributes": ["Address",
1159             "Mtu"],
1160     }),
1161      "ns3::MatrixPropagationLossModel": dict({
1162         "category": "Loss",
1163         "create_function": create_element,
1164         "configure_function": configure_element,
1165         "help": "",
1166         "connector_types": [],
1167         "box_attributes": ["DefaultLoss"],
1168     }),
1169      "ns3::WifiNetDevice": dict({
1170         "category": "Device",
1171         "create_function": create_element,
1172         "configure_function": configure_device,
1173         "help": "",
1174         "connector_types": ["node", "mac", "phy", "manager"],
1175         "allow_addresses": True,
1176         "box_attributes": ["Mtu"],
1177     }),
1178      "ns3::CsmaChannel": dict({
1179         "category": "Channel",
1180         "create_function": create_element,
1181         "configure_function": configure_element,
1182         "help": "",
1183         "connector_types": ["devs"],
1184         "box_attributes": ["DataRate",
1185             "Delay"],
1186     }),
1187      "ns3::BridgeNetDevice": dict({
1188         "category": "Device",
1189         "create_function": create_element,
1190         "configure_function": configure_element,
1191         "help": "",
1192         "connector_types": ["node"],
1193         "allow_addresses": True,
1194         "box_attributes": ["Mtu",
1195            "EnableLearning",
1196            "ExpirationTime"],
1197     }),
1198      "ns3::Ipv6ExtensionRouting": dict({
1199         "category": "",
1200         "create_function": create_element,
1201         "configure_function": configure_element,
1202         "help": "",
1203         "connector_types": [],
1204         "box_attributes": ["ExtensionNumber"],
1205     }),
1206      "ns3::QstaWifiMac": dict({
1207         "category": "Mac",
1208         "create_function": create_wifi_standard_model,
1209         "configure_function": configure_element,
1210         "help": "Station Wifi MAC Model",
1211         "connector_types": ["dev"],
1212         "box_attributes": ["ProbeRequestTimeout",
1213             "AssocRequestTimeout",
1214             "MaxMissedBeacons",
1215             "CtsTimeout",
1216             "AckTimeout",
1217             "BasicBlockAckTimeout",
1218             "CompressedBlockAckTimeout",
1219             "Sifs",
1220             "EifsNoDifs",
1221             "Slot",
1222             "Pifs",
1223             "MaxPropagationDelay",
1224             "Ssid",
1225             "Standard"],
1226     }),
1227      "ns3::UdpEchoClient": dict({
1228         "category": "Application",
1229         "create_function": create_element,
1230         "configure_function": configure_element,
1231         "help": "",
1232         "connector_types": ["node"],
1233         "stop_function": stop_application,
1234         "start_function": start_application,
1235         "status_function": status_application,
1236         "box_attributes": ["MaxPackets",
1237             "Interval",
1238             "RemoteAddress",
1239             "RemotePort",
1240             "PacketSize",
1241             "StartTime",
1242             "StopTime"],
1243     }),
1244      "ns3::UdpClient": dict({
1245         "category": "Application",
1246         "create_function": create_element,
1247         "configure_function": configure_element,
1248         "help": "",
1249         "connector_types": [],
1250         "stop_function": stop_application,
1251         "start_function": start_application,
1252         "status_function": status_application,
1253         "box_attributes": ["MaxPackets",
1254             "Interval",
1255             "RemoteAddress",
1256             "RemotePort",
1257             "PacketSize",
1258             "StartTime",
1259             "StopTime"],
1260     }),
1261      "ns3::PointToPointChannel": dict({
1262         "category": "Channel",
1263         "create_function": create_element,
1264         "configure_function": configure_element,
1265         "help": "",
1266         "connector_types": ["dev2"],
1267         "box_attributes": ["Delay"],
1268     }),
1269      "ns3::Ipv6StaticRouting": dict({
1270         "category": "",
1271         "create_function": create_element,
1272         "configure_function": configure_element,
1273         "help": "",
1274         "connector_types": [],
1275         "box_attributes": [],
1276     }),
1277      "ns3::DropTailQueue": dict({
1278         "category": "Device",
1279         "create_function": create_element,
1280         "configure_function": configure_element,
1281         "help": "",
1282         "connector_types": ["dev"],
1283         "box_attributes": ["MaxPackets",
1284            "MaxBytes"],
1285     }),
1286      "ns3::ConstantPositionMobilityModel": dict({
1287         "category": "Mobility",
1288         "create_function": create_element,
1289         "configure_function": configure_element,
1290         "help": "",
1291         "connector_types": ["node"],
1292         "box_attributes": ["Position",
1293             "Velocity"],
1294     }),
1295      "ns3::FixedRssLossModel": dict({
1296         "category": "Loss",
1297         "create_function": create_element,
1298         "configure_function": configure_element,
1299         "help": "",
1300         "connector_types": [],
1301         "box_attributes": ["Rss"],
1302     }),
1303      "ns3::EnergySourceContainer": dict({
1304         "category": "",
1305         "create_function": create_element,
1306         "configure_function": configure_element,
1307         "help": "",
1308         "connector_types": [],
1309         "box_attributes": [],
1310     }),
1311      "ns3::RandomWalk2dMobilityModel": dict({
1312         "category": "Mobility",
1313         "create_function": create_element,
1314         "configure_function": configure_element,
1315         "help": "",
1316         "connector_types": ["node"],
1317         "box_attributes": ["Bounds",
1318             "Time",
1319             "Distance",
1320             "Mode",
1321             "Direction",
1322             "Speed",
1323             "Position",
1324             "Velocity"],
1325     }),
1326      "ns3::ListPositionAllocator": dict({
1327         "category": "",
1328         "create_function": create_element,
1329         "configure_function": configure_element,
1330         "help": "",
1331         "connector_types": [],
1332         "box_attributes": [],
1333     }),
1334      "ns3::dot11s::PeerManagementProtocol": dict({
1335         "category": "Protocol",
1336         "create_function": create_element,
1337         "configure_function": configure_element,
1338         "help": "",
1339         "connector_types": [],
1340         "box_attributes": ["MaxNumberOfPeerLinks",
1341             "MaxBeaconShiftValue",
1342             "EnableBeaconCollisionAvoidance"],
1343     }),
1344      "ns3::MeshPointDevice": dict({
1345         "category": "Device",
1346         "create_function": create_element,
1347         "configure_function": configure_element,
1348         "help": "",
1349         "connector_types": [],
1350         "allow_addresses": True,
1351         "box_attributes": ["Mtu"],
1352     }),
1353      "ns3::BasicEnergySource": dict({
1354         "category": "",
1355         "create_function": create_element,
1356         "configure_function": configure_element,
1357         "help": "",
1358         "connector_types": [],
1359         "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1360             "BasicEnergySupplyVoltageV",
1361             "PeriodicEnergyUpdateInterval"],
1362     }),
1363      "ns3::Ipv6OptionPadn": dict({
1364         "category": "",
1365         "create_function": create_element,
1366         "configure_function": configure_element,
1367         "help": "",
1368         "connector_types": [],
1369         "box_attributes": ["OptionNumber"],
1370     }),
1371      "ns3::QapWifiMac": dict({
1372         "category": "Mac",
1373         "create_function": create_wifi_standard_model,
1374         "configure_function": configure_element,
1375         "help": "Access point Wifi MAC Model",
1376         "connector_types": ["dev"],
1377         "box_attributes": ["BeaconInterval",
1378             "BeaconGeneration",
1379             "CtsTimeout",
1380             "AckTimeout",
1381             "BasicBlockAckTimeout",
1382             "CompressedBlockAckTimeout",
1383             "Sifs",
1384             "EifsNoDifs",
1385             "Slot",
1386             "Pifs",
1387             "MaxPropagationDelay",
1388             "Ssid",
1389             "Standard"],
1390     }),
1391      "ns3::YansErrorRateModel": dict({
1392         "category": "Error",
1393         "create_function": create_element,
1394         "configure_function": configure_element,
1395         "help": "",
1396         "connector_types": [],
1397         "box_attributes": [],
1398     }),
1399      "ns3::WifiMacQueue": dict({
1400         "category": "",
1401         "create_function": create_element,
1402         "configure_function": configure_element,
1403         "help": "",
1404         "connector_types": [],
1405         "box_attributes": ["MaxPacketNumber",
1406            "MaxDelay"],
1407     }),
1408      "ns3::NonCommunicatingNetDevice": dict({
1409         "category": "Device",
1410         "create_function": create_element,
1411         "configure_function": configure_element,
1412         "help": "",
1413         "connector_types": [],
1414         "allow_addresses": True,
1415         "box_attributes": [],
1416     }),
1417      "ns3::RateErrorModel": dict({
1418         "category": "Error",
1419         "create_function": create_element,
1420         "configure_function": configure_element,
1421         "help": "",
1422         "connector_types": [],
1423         "box_attributes": ["ErrorUnit",
1424             "ErrorRate",
1425             "RanVar",
1426             "IsEnabled"],
1427     }),
1428      "ns3::MeshWifiInterfaceMac": dict({
1429         "category": "",
1430         "create_function": create_element,
1431         "configure_function": configure_element,
1432         "help": "",
1433         "connector_types": [],
1434         "box_attributes": ["BeaconInterval",
1435             "RandomStart",
1436             "BeaconGeneration",
1437             "CtsTimeout",
1438             "AckTimeout",
1439             "BasicBlockAckTimeout",
1440             "CompressedBlockAckTimeout",
1441             "Sifs",
1442             "EifsNoDifs",
1443             "Slot",
1444             "Pifs",
1445             "MaxPropagationDelay",
1446             "Ssid"],
1447     }),
1448      "ns3::UanPhyCalcSinrDual": dict({
1449         "category": "",
1450         "create_function": create_element,
1451         "configure_function": configure_element,
1452         "help": "",
1453         "connector_types": [],
1454         "box_attributes": [],
1455     }),
1456      "ns3::Ipv6ExtensionAH": dict({
1457         "category": "",
1458         "create_function": create_element,
1459         "configure_function": configure_element,
1460         "help": "",
1461         "connector_types": [],
1462         "box_attributes": ["ExtensionNumber"],
1463     }),
1464      "ns3::SingleModelSpectrumChannel": dict({
1465         "category": "Channel",
1466         "create_function": create_element,
1467         "configure_function": configure_element,
1468         "help": "",
1469         "connector_types": [],
1470         "box_attributes": [],
1471     }),
1472      "ns3::YansWifiPhy": dict({
1473         "category": "Phy",
1474         "create_function": create_wifi_standard_model,
1475         "configure_function": configure_element,
1476         "help": "",
1477         "connector_types": ["dev", "err", "chan"],
1478         "box_attributes": ["EnergyDetectionThreshold",
1479             "CcaMode1Threshold",
1480             "TxGain",
1481             "RxGain",
1482             "TxPowerLevels",
1483             "TxPowerEnd",
1484             "TxPowerStart",
1485             "RxNoiseFigure",
1486             "ChannelSwitchDelay",
1487             "ChannelNumber",
1488             "Standard"],
1489         "traces": ["yanswifipcap"]
1490     }),
1491      "ns3::WifiRadioEnergyModel": dict({
1492         "category": "",
1493         "create_function": create_element,
1494         "configure_function": configure_element,
1495         "help": "",
1496         "connector_types": [],
1497         "box_attributes": ["TxCurrentA",
1498             "RxCurrentA",
1499             "IdleCurrentA",
1500             "SleepCurrentA"],
1501     }),
1502      "ns3::EdcaTxopN": dict({
1503         "category": "",
1504         "create_function": create_element,
1505         "configure_function": configure_element,
1506         "help": "",
1507         "connector_types": [],
1508         "box_attributes": ["BlockAckThreshold",
1509             "MinCw",
1510             "MaxCw",
1511             "Aifsn"],
1512     }),
1513      "ns3::UanPhyPerGenDefault": dict({
1514         "category": "",
1515         "create_function": create_element,
1516         "configure_function": configure_element,
1517         "help": "",
1518         "connector_types": [],
1519         "box_attributes": ["Threshold"],
1520     }),
1521      "ns3::IdealWifiManager": dict({
1522         "category": "Manager",
1523         "create_function": create_element,
1524         "configure_function": configure_element,
1525         "help": "",
1526         "connector_types": [],
1527         "box_attributes": ["BerThreshold",
1528             "IsLowLatency",
1529             "MaxSsrc",
1530             "MaxSlrc",
1531             "RtsCtsThreshold",
1532             "FragmentationThreshold",
1533             "NonUnicastMode"],
1534     }),
1535      "ns3::MultiModelSpectrumChannel": dict({
1536         "category": "Channel",
1537         "create_function": create_element,
1538         "configure_function": configure_element,
1539         "help": "",
1540         "connector_types": [],
1541         "box_attributes": [],
1542     }),
1543      "ns3::HalfDuplexIdealPhy": dict({
1544         "category": "Phy",
1545         "create_function": create_element,
1546         "configure_function": configure_element,
1547         "help": "",
1548         "connector_types": [],
1549         "box_attributes": ["Rate"],
1550     }),
1551      "ns3::UanPhyCalcSinrDefault": dict({
1552         "category": "Phy",
1553         "create_function": create_element,
1554         "configure_function": configure_element,
1555         "help": "",
1556         "connector_types": [],
1557         "box_attributes": [],
1558     }),
1559      "ns3::ReceiveListErrorModel": dict({
1560         "category": "Error",
1561         "create_function": create_element,
1562         "configure_function": configure_element,
1563         "help": "",
1564         "connector_types": [],
1565         "box_attributes": ["IsEnabled"],
1566     }),
1567      "ns3::SpectrumAnalyzer": dict({
1568         "category": "",
1569         "create_function": create_element,
1570         "configure_function": configure_element,
1571         "help": "",
1572         "connector_types": [],
1573         "box_attributes": ["Resolution",
1574         "NoisePowerSpectralDensity"],
1575     }),
1576      "ns3::ConstantRateWifiManager": dict({
1577         "category": "Manager",
1578         "create_function": create_element,
1579         "configure_function": configure_element,
1580         "help": "",
1581         "connector_types": ["dev"],
1582         "box_attributes": ["DataMode",
1583             "ControlMode",
1584             "IsLowLatency",
1585             "MaxSsrc",
1586             "MaxSlrc",
1587             "RtsCtsThreshold",
1588             "FragmentationThreshold",
1589             "NonUnicastMode"],
1590     }),
1591      "ns3::Ipv6OptionPad1": dict({
1592         "category": "",
1593         "create_function": create_element,
1594         "configure_function": configure_element,
1595         "help": "",
1596         "connector_types": [],
1597         "box_attributes": ["OptionNumber"],
1598     }),
1599      "ns3::UdpTraceClient": dict({
1600         "category": "",
1601         "create_function": create_element,
1602         "configure_function": configure_element,
1603         "help": "",
1604         "connector_types": [],
1605         "box_attributes": ["RemoteAddress",
1606             "RemotePort",
1607             "MaxPacketSize",
1608             "StartTime",
1609             "StopTime"],
1610     }),
1611      "ns3::RraaWifiManager": dict({
1612         "category": "Manager",
1613         "create_function": create_element,
1614         "configure_function": configure_element,
1615         "help": "",
1616         "connector_types": [],
1617         "box_attributes": ["Basic",
1618             "Timeout",
1619             "ewndFor54mbps",
1620             "ewndFor48mbps",
1621             "ewndFor36mbps",
1622             "ewndFor24mbps",
1623             "ewndFor18mbps",
1624             "ewndFor12mbps",
1625             "ewndFor9mbps",
1626             "ewndFor6mbps",
1627             "poriFor48mbps",
1628             "poriFor36mbps",
1629             "poriFor24mbps",
1630             "poriFor18mbps",
1631             "poriFor12mbps",
1632             "poriFor9mbps",
1633             "poriFor6mbps",
1634             "pmtlFor54mbps",
1635             "pmtlFor48mbps",
1636             "pmtlFor36mbps",
1637             "pmtlFor24mbps",
1638             "pmtlFor18mbps",
1639             "pmtlFor12mbps",
1640             "pmtlFor9mbps",
1641             "IsLowLatency",
1642             "MaxSsrc",
1643             "MaxSlrc",
1644             "RtsCtsThreshold",
1645             "FragmentationThreshold",
1646             "NonUnicastMode"],
1647     }),
1648      "ns3::RandomPropagationLossModel": dict({
1649         "category": "Loss",
1650         "create_function": create_element,
1651         "configure_function": configure_element,
1652         "help": "",
1653         "connector_types": [],
1654         "box_attributes": ["Variable"],
1655     }),
1656      "ns3::UanChannel": dict({
1657         "category": "Channel",
1658         "create_function": create_element,
1659         "configure_function": configure_element,
1660         "help": "",
1661         "connector_types": [],
1662         "box_attributes": [],
1663     }),
1664      "ns3::MinstrelWifiManager": dict({
1665         "category": "Manager",
1666         "create_function": create_element,
1667         "configure_function": configure_element,
1668         "help": "",
1669         "connector_types": [],
1670         "box_attributes": ["UpdateStatistics",
1671             "LookAroundRate",
1672             "EWMA",
1673             "SegmentSize",
1674             "SampleColumn",
1675             "PacketLength",
1676             "IsLowLatency",
1677             "MaxSsrc",
1678             "MaxSlrc",
1679             "RtsCtsThreshold",
1680             "FragmentationThreshold",
1681             "NonUnicastMode"],
1682     }),
1683      "ns3::UanPhyDual": dict({
1684         "category": "Phy",
1685         "create_function": create_element,
1686         "configure_function": configure_element,
1687         "help": "",
1688         "connector_types": [],
1689         "box_attributes": ["CcaThresholdPhy1",
1690             "CcaThresholdPhy2",
1691             "TxPowerPhy1",
1692             "TxPowerPhy2",
1693             "RxGainPhy1",
1694             "RxGainPhy2",
1695             "SupportedModesPhy1",
1696             "SupportedModesPhy2"],
1697     }),
1698      "ns3::ListErrorModel": dict({
1699         "category": "Error",
1700         "create_function": create_element,
1701         "configure_function": configure_element,
1702         "help": "",
1703         "connector_types": ["dev"],
1704         "box_attributes": ["IsEnabled"],
1705     }),
1706      "ns3::VirtualNetDevice": dict({
1707         "category": "Device",
1708         "create_function": create_element,
1709         "configure_function": configure_element,
1710         "help": "",
1711         "connector_types": [],
1712         "allow_addresses": True,
1713         "box_attributes": ["Mtu"],
1714     }),
1715      "ns3::UanPhyGen": dict({
1716         "category": "Phy",
1717         "create_function": create_element,
1718         "configure_function": configure_element,
1719         "help": "",
1720         "connector_types": [],
1721         "box_attributes": ["CcaThreshold",
1722             "RxThreshold",
1723             "TxPower",
1724             "RxGain",
1725             "SupportedModes"],
1726     }),
1727      "ns3::Ipv6L3Protocol": dict({
1728         "category": "Protocol",
1729         "create_function": create_element,
1730         "configure_function": configure_element,
1731         "help": "",
1732         "connector_types": ["node"],
1733         "box_attributes": ["DefaultTtl",
1734             "IpForward"],
1735     }),
1736      "ns3::PointToPointRemoteChannel": dict({
1737         "category": "Channel",
1738         "create_function": create_element,
1739         "configure_function": configure_element,
1740         "help": "",
1741         "connector_types": [],
1742         "box_attributes": ["Delay"],
1743     }),
1744      "ns3::UanPhyPerUmodem": dict({
1745         "category": "Phy",
1746         "create_function": create_element,
1747         "configure_function": configure_element,
1748         "help": "",
1749         "connector_types": [],
1750         "box_attributes": [],
1751     }),
1752      "ns3::OnoeWifiManager": dict({
1753         "category": "Manager",
1754         "create_function": create_element,
1755         "configure_function": configure_element,
1756         "help": "",
1757         "connector_types": [],
1758         "box_attributes": ["UpdatePeriod",
1759             "RaiseThreshold",
1760             "AddCreditThreshold",
1761             "IsLowLatency",
1762             "MaxSsrc",
1763             "MaxSlrc",
1764             "RtsCtsThreshold",
1765             "FragmentationThreshold",
1766             "NonUnicastMode"],
1767     }),
1768      "ns3::QadhocWifiMac": dict({
1769         "category": "Mac",
1770         "create_function": create_element,
1771         "configure_function": configure_element,
1772         "help": "",
1773         "connector_types": [],
1774         "box_attributes": ["CtsTimeout",
1775             "AckTimeout",
1776             "BasicBlockAckTimeout",
1777             "CompressedBlockAckTimeout",
1778             "Sifs",
1779             "EifsNoDifs",
1780             "Slot",
1781             "Pifs",
1782             "MaxPropagationDelay",
1783             "Ssid"],
1784     }),
1785      "ns3::JakesPropagationLossModel": dict({
1786         "category": "Loss",
1787         "create_function": create_element,
1788         "configure_function": configure_element,
1789         "help": "",
1790         "connector_types": [],
1791         "box_attributes": ["NumberOfRaysPerPath",
1792             "NumberOfOscillatorsPerRay",
1793             "DopplerFreq",
1794             "Distribution"],
1795     }),
1796      "ns3::PacketSink": dict({
1797         "category": "Application",
1798         "create_function": create_element,
1799         "configure_function": configure_element,
1800         "help": "",
1801         "connector_types": ["node"],
1802         "stop_function": stop_application,
1803         "start_function": start_application,
1804         "status_function": status_application,
1805         "box_attributes": ["Local",
1806             "Protocol",
1807             "StartTime",
1808             "StopTime"],
1809     }),
1810      "ns3::RandomDirection2dMobilityModel": dict({
1811         "category": "Mobility",
1812         "create_function": create_element,
1813         "configure_function": configure_element,
1814         "help": "",
1815         "connector_types": ["node"],
1816         "box_attributes": ["Bounds",
1817             "RndSpeed",
1818             "Pause",
1819             "Position",
1820             "Velocity"],
1821     }),
1822      "ns3::UanMacAloha": dict({
1823         "category": "",
1824         "create_function": create_element,
1825         "configure_function": configure_element,
1826         "help": "",
1827         "connector_types": [],
1828         "box_attributes": [],
1829     }),
1830      "ns3::MsduStandardAggregator": dict({
1831         "category": "",
1832         "create_function": create_element,
1833         "configure_function": configure_element,
1834         "help": "",
1835         "connector_types": [],
1836         "box_attributes": ["MaxAmsduSize"],
1837     }),
1838      "ns3::DcaTxop": dict({
1839         "category": "",
1840         "create_function": create_element,
1841         "configure_function": configure_element,
1842         "help": "",
1843         "connector_types": [],
1844         "box_attributes": ["MinCw",
1845             "MaxCw",
1846             "Aifsn"],
1847     }),
1848      "ns3::UanPhyCalcSinrFhFsk": dict({
1849         "category": "Phy",
1850         "create_function": create_element,
1851         "configure_function": configure_element,
1852         "help": "",
1853         "connector_types": [],
1854         "box_attributes": ["NumberOfHops"],
1855     }),
1856      "ns3::UanPropModelIdeal": dict({
1857         "category": "",
1858         "create_function": create_element,
1859         "configure_function": configure_element,
1860         "help": "",
1861         "connector_types": [],
1862         "box_attributes": [],
1863     }),
1864      "ns3::UanMacRcGw": dict({
1865         "category": "",
1866         "create_function": create_element,
1867         "configure_function": configure_element,
1868         "help": "",
1869         "connector_types": [],
1870         "box_attributes": ["MaxReservations",
1871             "NumberOfRates",
1872             "RetryRate",
1873             "MaxPropDelay",
1874             "SIFS",
1875             "NumberOfNodes",
1876             "MinRetryRate",
1877             "RetryStep",
1878             "NumberOfRetryRates",
1879             "TotalRate",
1880             "RateStep",
1881             "FrameSize"],
1882     }),
1883      "ns3::NistErrorRateModel": dict({
1884         "category": "Error",
1885         "create_function": create_element,
1886         "configure_function": configure_element,
1887         "help": "",
1888         "connector_types": ["phy"],
1889         "box_attributes": [],
1890     }),
1891      "ns3::Ipv4L3Protocol": dict({
1892         "category": "Protocol",
1893         "create_function": create_ipv4protocol,
1894         "configure_function": configure_element,
1895         "help": "",
1896         "connector_types": ["node"],
1897         "box_attributes": ["DefaultTtl",
1898             "IpForward",
1899             "WeakEsModel"],
1900     }),
1901      "ns3::aodv::RoutingProtocol": dict({
1902         "category": "Protocol",
1903         "create_function": create_element,
1904         "configure_function": configure_element,
1905         "help": "",
1906         "connector_types": [],
1907         "box_attributes": ["HelloInterval",
1908             "RreqRetries",
1909             "RreqRateLimit",
1910             "NodeTraversalTime",
1911             "NextHopWait",
1912             "ActiveRouteTimeout",
1913             "MyRouteTimeout",
1914             "BlackListTimeout",
1915             "DeletePeriod",
1916             "TimeoutBuffer",
1917             "NetDiameter",
1918             "NetTraversalTime",
1919             "PathDiscoveryTime",
1920             "MaxQueueLen",
1921             "MaxQueueTime",
1922             "AllowedHelloLoss",
1923             "GratuitousReply",
1924             "DestinationOnly",
1925             "EnableHello",
1926             "EnableBroadcast"],
1927     }),
1928      "ns3::TcpL4Protocol": dict({
1929         "category": "Protocol",
1930         "create_function": create_element,
1931         "configure_function": configure_element,
1932         "help": "",
1933         "connector_types": ["node"],
1934         "box_attributes": ["RttEstimatorFactory",
1935             "ProtocolNumber"],
1936     }),
1937      "ns3::olsr::RoutingProtocol": dict({
1938         "category": "Protocol",
1939         "create_function": create_element,
1940         "configure_function": configure_element,
1941         "help": "",
1942         "connector_types": [],
1943         "box_attributes": ["HelloInterval",
1944             "TcInterval",
1945             "MidInterval",
1946             "HnaInterval",
1947             "Willingness"],
1948     }),
1949      "ns3::UdpEchoServer": dict({
1950         "category": "Application",
1951         "create_function": create_element,
1952         "configure_function": configure_element,
1953         "help": "",
1954         "connector_types": ["node"],
1955         "stop_function": stop_application,
1956         "start_function": start_application,
1957         "status_function": status_application,
1958         "box_attributes": ["Port",
1959            "StartTime",
1960            "StopTime"],
1961     }),
1962      "ns3::AmrrWifiManager": dict({
1963         "category": "Manager",
1964         "create_function": create_element,
1965         "configure_function": configure_element,
1966         "help": "",
1967         "connector_types": [],
1968         "box_attributes": ["UpdatePeriod",
1969             "FailureRatio",
1970             "SuccessRatio",
1971             "MaxSuccessThreshold",
1972             "MinSuccessThreshold",
1973             "IsLowLatency",
1974             "MaxSsrc",
1975             "MaxSlrc",
1976             "RtsCtsThreshold",
1977             "FragmentationThreshold",
1978             "NonUnicastMode"],
1979     }),
1980      "ns3::ArfWifiManager": dict({
1981         "category": "Manager",
1982         "create_function": create_element,
1983         "configure_function": configure_element,
1984         "help": "",
1985         "connector_types": ["dev"],
1986         "box_attributes": ["TimerThreshold",
1987             "SuccessThreshold",
1988             "IsLowLatency",
1989             "MaxSsrc",
1990             "MaxSlrc",
1991             "RtsCtsThreshold",
1992             "FragmentationThreshold",
1993             "NonUnicastMode"],
1994     }),
1995      "ns3::SubscriberStationNetDevice": dict({
1996         "category": "Device",
1997         "create_function": create_element,
1998         "configure_function": configure_element,
1999         "help": "",
2000         "connector_types": [],
2001         "allow_addresses": True,
2002         "box_attributes": ["LostDlMapInterval",
2003             "LostUlMapInterval",
2004             "MaxDcdInterval",
2005             "MaxUcdInterval",
2006             "IntervalT1",
2007             "IntervalT2",
2008             "IntervalT3",
2009             "IntervalT7",
2010             "IntervalT12",
2011             "IntervalT20",
2012             "IntervalT21",
2013             "MaxContentionRangingRetries",
2014             "Mtu",
2015             "RTG",
2016             "TTG"],
2017     }),
2018      "ns3::flame::FlameRtable": dict({
2019         "category": "",
2020         "create_function": create_element,
2021         "configure_function": configure_element,
2022         "help": "",
2023         "connector_types": [],
2024         "box_attributes": ["Lifetime"],
2025     }),
2026 })