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