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         "traces": ["fdpcap"]
 633     }),
 634      "ns3::CsmaNetDevice": dict({
 635         "category": "Device",
 636         "create_function": create_element,
 637         "configure_function": configure_device,
 638         "help": "CSMA (carrier sense, multiple access) interface",
 639         "connector_types": ["node", "chan", "err", "queue"],
 640         "allow_addresses": True,
 641         "box_attributes": ["Address",
 642             "Mtu",
 643             "SendEnable",
 644             "ReceiveEnable"],
 645         "traces": ["csmapcap", "csmapcap_promisc"]
 646     }),
 647      "ns3::UanPropModelThorp": dict({
 648         "category": "",
 649         "create_function": create_element,
 650         "configure_function": configure_element,
 651         "help": "",
 652         "connector_types": [],
 653         "box_attributes": ["SpreadCoef"],
 654     }),
 655      "ns3::NqstaWifiMac": dict({
 656         "category": "Mac",
 657         "create_function": create_element,
 658         "configure_function": configure_element,
 659         "help": "",
 660         "connector_types": [],
 661         "box_attributes": ["ProbeRequestTimeout",
 662             "AssocRequestTimeout",
 663             "MaxMissedBeacons",
 664             "CtsTimeout",
 665             "AckTimeout",
 666             "BasicBlockAckTimeout",
 667             "CompressedBlockAckTimeout",
 668             "Sifs",
 669             "EifsNoDifs",
 670             "Slot",
 671             "Pifs",
 672             "MaxPropagationDelay",
 673             "Ssid"],
 674     }),
 675      "ns3::Icmpv6L4Protocol": dict({
 676         "category": "Protocol",
 677         "create_function": create_element,
 678         "configure_function": configure_element,
 679         "help": "",
 680         "connector_types": [],
 681         "box_attributes": ["DAD",
 682             "ProtocolNumber"],
 683     }),
 684      "ns3::SimpleNetDevice": dict({
 685         "category": "Device",
 686         "create_function": create_element,
 687         "configure_function": configure_element,
 688         "help": "",
 689         "connector_types": ["node", "chan"],
 690         "allow_addresses": True,
 691         "box_attributes": [],
 692     }),
 693      "ns3::FriisPropagationLossModel": dict({
 694         "category": "Loss",
 695         "create_function": create_element,
 696         "configure_function": configure_element,
 697         "help": "",
 698         "connector_types": [],
 699         "box_attributes": ["Lambda",
 700             "SystemLoss",
 701             "MinDistance"],
 702     }),
 703      "ns3::Ipv6OptionRouterAlert": dict({
 704         "category": "",
 705         "create_function": create_element,
 706         "configure_function": configure_element,
 707         "help": "",
 708         "connector_types": [],
 709         "box_attributes": ["OptionNumber"],
 710     }),
 711      "ns3::UniformDiscPositionAllocator": dict({
 712         "category": "Mobility",
 713         "create_function": create_element,
 714         "configure_function": configure_element,
 715         "help": "",
 716         "connector_types": [],
 717         "box_attributes": ["rho",
 718             "X",
 719             "Y"],
 720     }),
 721      "ns3::RandomBoxPositionAllocator": dict({
 722         "category": "Mobility",
 723         "create_function": create_element,
 724         "configure_function": configure_element,
 725         "help": "",
 726         "connector_types": [],
 727         "box_attributes": ["X",
 728             "Y",
 729             "Z"],
 730     }),
 731      "ns3::Ipv6ExtensionDestination": dict({
 732         "category": "",
 733         "create_function": create_element,
 734         "configure_function": configure_element,
 735         "help": "",
 736         "connector_types": [],
 737         "box_attributes": ["ExtensionNumber"],
 738     }),
 739      "ns3::LoopbackNetDevice": dict({
 740         "category": "Device",
 741         "create_function": create_element,
 742         "configure_function": configure_element,
 743         "help": "",
 744         "connector_types": [],
 745         "box_attributes": [],
 746     }),
 747      "ns3::ConstantSpeedPropagationDelayModel": dict({
 748         "category": "Delay",
 749         "create_function": create_element,
 750         "configure_function": configure_element,
 751         "help": "",
 752         "connector_types": ["chan"],
 753         "box_attributes": ["Speed"],
 754     }),
 755      "ns3::Ipv6ExtensionHopByHop": dict({
 756         "category": "",
 757         "create_function": create_element,
 758         "configure_function": configure_element,
 759         "help": "",
 760         "connector_types": [],
 761         "box_attributes": ["ExtensionNumber"],
 762     }),
 763      "ns3::BridgeChannel": dict({
 764         "category": "Channel",
 765         "create_function": create_element,
 766         "configure_function": configure_element,
 767         "help": "",
 768         "connector_types": [],
 769         "box_attributes": [],
 770     }),
 771      "ns3::Radvd": dict({
 772         "category": "",
 773         "create_function": create_element,
 774         "configure_function": configure_element,
 775         "help": "",
 776         "connector_types": [],
 777         "box_attributes": ["StartTime",
 778             "StopTime"],
 779     }),
 780      "ns3::PacketSocket": dict({
 781         "category": "",
 782         "create_function": create_element,
 783         "configure_function": configure_element,
 784         "help": "",
 785         "connector_types": [],
 786         "box_attributes": ["RcvBufSize"],
 787     }),
 788      "ns3::flame::FlameProtocol": dict({
 789         "category": "Protocol",
 790         "create_function": create_element,
 791         "configure_function": configure_element,
 792         "help": "",
 793         "connector_types": [],
 794         "box_attributes": ["BroadcastInterval",
 795             "MaxCost"],
 796     }),
 797      "ns3::Cost231PropagationLossModel": dict({
 798         "category": "Loss",
 799         "create_function": create_element,
 800         "configure_function": configure_element,
 801         "help": "",
 802         "connector_types": [],
 803         "box_attributes": ["Lambda",
 804             "Frequency",
 805             "BSAntennaHeight",
 806             "SSAntennaHeight",
 807             "MinDistance"],
 808     }),
 809      "ns3::Ipv6ExtensionESP": dict({
 810         "category": "",
 811         "create_function": create_element,
 812         "configure_function": configure_element,
 813         "help": "",
 814         "connector_types": [],
 815         "box_attributes": ["ExtensionNumber"],
 816     }),
 817      "ns3::CaraWifiManager": dict({
 818         "category": "Manager",
 819         "create_function": create_element,
 820         "configure_function": configure_element,
 821         "help": "",
 822         "connector_types": [],
 823         "box_attributes": ["ProbeThreshold",
 824             "FailureThreshold",
 825             "SuccessThreshold",
 826             "Timeout",
 827             "IsLowLatency",
 828             "MaxSsrc",
 829             "MaxSlrc",
 830             "RtsCtsThreshold",
 831             "FragmentationThreshold",
 832             "NonUnicastMode"],
 833
 834     }),
 835      "ns3::RttMeanDeviation": dict({
 836         "category": "",
 837         "create_function": create_element,
 838         "configure_function": configure_element,
 839         "help": "",
 840         "connector_types": [],
 841         "box_attributes": ["Gain",
 842             "MaxMultiplier",
 843             "InitialEstimation",
 844             "MinRTO"],
 845     }),
 846      "ns3::Icmpv4L4Protocol": dict({
 847         "category": "Protocol",
 848         "create_function": create_element,
 849         "configure_function": configure_element,
 850         "help": "",
 851         "connector_types": ["node"],
 852         "box_attributes": ["ProtocolNumber"],
 853     }),
 854      "ns3::WaveformGenerator": dict({
 855         "category": "",
 856         "create_function": create_element,
 857         "configure_function": configure_element,
 858         "help": "",
 859         "connector_types": [],
 860         "box_attributes": ["Period",
 861             "DutyCycle"],
 862     }),
 863      "ns3::YansWifiChannel": dict({
 864         "category": "Channel",
 865         "create_function": create_element,
 866         "configure_function": configure_element,
 867         "help": "",
 868         "connector_types": ["phys", "delay", "loss"],
 869         "box_attributes": [],
 870     }),
 871      "ns3::SimpleChannel": dict({
 872         "category": "Channel",
 873         "create_function": create_element,
 874         "configure_function": configure_element,
 875         "help": "",
 876         "connector_types": ["devs"],
 877         "box_attributes": [],
 878     }),
 879      "ns3::Ipv6ExtensionFragment": dict({
 880         "category": "",
 881         "create_function": create_element,
 882         "configure_function": configure_element,
 883         "help": "",
 884         "connector_types": [],
 885         "box_attributes": ["ExtensionNumber"],
 886     }),
 887      "ns3::Dot11sStack": dict({
 888         "category": "",
 889         "create_function": create_element,
 890         "configure_function": configure_element,
 891         "help": "",
 892         "connector_types": [],
 893         "box_attributes": ["Root"],
 894     }),
 895      "ns3::FriisSpectrumPropagationLossModel": dict({
 896         "category": "Loss",
 897         "create_function": create_element,
 898         "configure_function": configure_element,
 899         "help": "",
 900         "connector_types": [],
 901         "box_attributes": [],
 902     }),
 903      "ns3::RandomRectanglePositionAllocator": dict({
 904         "category": "Mobility",
 905         "create_function": create_element,
 906         "configure_function": configure_element,
 907         "help": "",
 908         "connector_types": [],
 909         "box_attributes": ["X",
 910            "Y"],
 911     }),
 912      "ns3::NqapWifiMac": dict({
 913         "category": "",
 914         "create_function": create_element,
 915         "configure_function": configure_element,
 916         "help": "",
 917         "connector_types": [],
 918         "box_attributes": ["BeaconInterval",
 919             "BeaconGeneration",
 920             "CtsTimeout",
 921             "AckTimeout",
 922             "BasicBlockAckTimeout",
 923             "CompressedBlockAckTimeout",
 924             "Sifs",
 925             "EifsNoDifs",
 926             "Slot",
 927             "Pifs",
 928             "MaxPropagationDelay",
 929             "Ssid"],
 930     }),
 931      "ns3::HierarchicalMobilityModel": dict({
 932         "category": "Mobility",
 933         "create_function": create_element,
 934         "configure_function": configure_element,
 935         "help": "",
 936         "connector_types": ["node"],
 937         "box_attributes": ["Position",
 938             "Velocity"],
 939     }),
 940      "ns3::ThreeLogDistancePropagationLossModel": dict({
 941         "category": "Loss",
 942         "create_function": create_element,
 943         "configure_function": configure_element,
 944         "help": "",
 945         "connector_types": [],
 946         "box_attributes": ["Distance0",
 947             "Distance1",
 948             "Distance2",
 949             "Exponent0",
 950             "Exponent1",
 951             "Exponent2",
 952             "ReferenceLoss"],
 953     }),
 954      "ns3::UanNoiseModelDefault": dict({
 955         "category": "",
 956         "create_function": create_element,
 957         "configure_function": configure_element,
 958         "help": "",
 959         "connector_types": [],
 960         "box_attributes": ["Wind",
 961             "Shipping"],
 962     }),
 963      "ns3::dot11s::HwmpRtable": dict({
 964         "category": "",
 965         "create_function": create_element,
 966         "configure_function": configure_element,
 967         "help": "",
 968         "connector_types": [],
 969         "box_attributes": [],
 970     }),
 971      "ns3::PacketBurst": dict({
 972         "category": "",
 973         "create_function": create_element,
 974         "configure_function": configure_element,
 975         "help": "",
 976         "connector_types": [],
 977         "box_attributes": [],
 978     }),
 979      "ns3::RandomPropagationDelayModel": dict({
 980         "category": "Delay",
 981         "create_function": create_element,
 982         "configure_function": configure_element,
 983         "help": "",
 984         "connector_types": [],
 985         "box_attributes": ["Variable"],
 986     }),
 987      "ns3::ArpL3Protocol": dict({
 988         "category": "Protocol",
 989         "create_function": create_element,
 990         "configure_function": configure_element,
 991         "help": "",
 992         "connector_types": ["node"],
 993         "box_attributes": [],
 994     }),
 995      "ns3::SteadyStateRandomWaypointMobilityModel": dict({
 996         "category": "Mobility",
 997         "create_function": create_element,
 998         "configure_function": configure_element,
 999         "help": "",
1000         "connector_types": [],
1001         "box_attributes": ["MinSpeed",
1002             "MaxSpeed",
1003             "MinPause",
1004             "MaxPause",
1005             "MinX",
1006             "MaxX",
1007             "MinY",
1008             "MaxY",
1009             "Position",
1010             "Velocity"],
1011     }),
1012      "ns3::BaseStationNetDevice": dict({
1013         "category": "Device",
1014         "create_function": create_element,
1015         "configure_function": configure_device,
1016         "help": "",
1017         "connector_types": [],
1018         "allow_addresses": True,
1019         "box_attributes": ["InitialRangInterval",
1020             "DcdInterval",
1021             "UcdInterval",
1022             "IntervalT8",
1023             "RangReqOppSize",
1024             "BwReqOppSize",
1025             "MaxRangCorrectionRetries",
1026             "Mtu",
1027             "RTG",
1028             "TTG"],
1029     }),
1030      "ns3::UdpServer": dict({
1031         "category": "Application",
1032         "create_function": create_element,
1033         "configure_function": configure_element,
1034         "help": "",
1035         "connector_types": [],
1036         "stop_function": stop_application,
1037         "start_function": start_application,
1038         "status_function": status_application,
1039         "box_attributes": ["Port",
1040             "PacketWindowSize",
1041             "StartTime",
1042             "StopTime"],
1043     }),
1044      "ns3::AarfcdWifiManager": dict({
1045         "category": "Manager",
1046         "create_function": create_element,
1047         "configure_function": configure_element,
1048         "help": "",
1049         "connector_types": [],
1050         "box_attributes": ["SuccessK",
1051             "TimerK",
1052             "MaxSuccessThreshold",
1053             "MinTimerThreshold",
1054             "MinSuccessThreshold",
1055             "MinRtsWnd",
1056             "MaxRtsWnd",
1057             "TurnOffRtsAfterRateDecrease",
1058             "TurnOnRtsAfterRateIncrease",
1059             "IsLowLatency",
1060             "MaxSsrc",
1061             "MaxSlrc",
1062             "RtsCtsThreshold",
1063             "FragmentationThreshold",
1064             "NonUnicastMode"],
1065     }),
1066      "ns3::UanTransducerHd": dict({
1067         "category": "",
1068         "create_function": create_element,
1069         "configure_function": configure_element,
1070         "help": "",
1071         "connector_types": [],
1072         "box_attributes": [],
1073     }),
1074      "ns3::LogDistancePropagationLossModel": dict({
1075         "category": "Loss",
1076         "create_function": create_element,
1077         "configure_function": configure_element,
1078         "help": "",
1079         "connector_types": ["prev", "next"],
1080         "box_attributes": ["Exponent",
1081             "ReferenceDistance",
1082             "ReferenceLoss"],
1083     }),
1084      "ns3::EmuNetDevice": dict({
1085         "category": "Device",
1086         "create_function": create_element,
1087         "configure_function": configure_element,
1088         "help": "",
1089         "connector_types": ["node", "queue"],
1090         "box_attributes": ["Mtu",
1091             "Address",
1092             "DeviceName",
1093             "Start",
1094             "Stop",
1095             "RxQueueSize"],
1096     }),
1097      "ns3::Ipv6ExtensionLooseRouting": dict({
1098         "category": "",
1099         "create_function": create_element,
1100         "configure_function": configure_element,
1101         "help": "",
1102         "connector_types": [],
1103         "box_attributes": ["ExtensionNumber"],
1104     }),
1105      "ns3::RandomWaypointMobilityModel": dict({
1106         "category": "Mobility",
1107         "create_function": create_element,
1108         "configure_function": configure_element,
1109         "help": "",
1110         "connector_types": ["node"],
1111         "box_attributes": ["Speed",
1112             "Pause",
1113             "Position",
1114             "Velocity"],
1115     }),
1116      "ns3::RangePropagationLossModel": dict({
1117         "category": "",
1118         "create_function": create_element,
1119         "configure_function": configure_element,
1120         "help": "",
1121         "connector_types": [],
1122         "box_attributes": ["MaxRange"],
1123     }),
1124      "ns3::AlohaNoackNetDevice": dict({
1125         "category": "Device",
1126         "create_function": create_element,
1127         "configure_function": configure_element,
1128         "help": "",
1129         "connector_types": [],
1130         "box_attributes": ["Address",
1131             "Mtu"],
1132     }),
1133      "ns3::MatrixPropagationLossModel": dict({
1134         "category": "Loss",
1135         "create_function": create_element,
1136         "configure_function": configure_element,
1137         "help": "",
1138         "connector_types": [],
1139         "box_attributes": ["DefaultLoss"],
1140     }),
1141      "ns3::WifiNetDevice": dict({
1142         "category": "Device",
1143         "create_function": create_element,
1144         "configure_function": configure_device,
1145         "help": "",
1146         "connector_types": ["node", "mac", "phy", "manager"],
1147         "allow_addresses": True,
1148         "box_attributes": ["Mtu"],
1149     }),
1150      "ns3::CsmaChannel": dict({
1151         "category": "Channel",
1152         "create_function": create_element,
1153         "configure_function": configure_element,
1154         "help": "",
1155         "connector_types": ["devs"],
1156         "box_attributes": ["DataRate",
1157             "Delay"],
1158     }),
1159      "ns3::BridgeNetDevice": dict({
1160         "category": "Device",
1161         "create_function": create_element,
1162         "configure_function": configure_element,
1163         "help": "",
1164         "connector_types": ["node"],
1165         "allow_addresses": True,
1166         "box_attributes": ["Mtu",
1167            "EnableLearning",
1168            "ExpirationTime"],
1169     }),
1170      "ns3::Ipv6ExtensionRouting": dict({
1171         "category": "",
1172         "create_function": create_element,
1173         "configure_function": configure_element,
1174         "help": "",
1175         "connector_types": [],
1176         "box_attributes": ["ExtensionNumber"],
1177     }),
1178      "ns3::QstaWifiMac": dict({
1179         "category": "Mac",
1180         "create_function": create_wifi_standard_model,
1181         "configure_function": configure_element,
1182         "help": "Station Wifi MAC Model",
1183         "connector_types": ["dev"],
1184         "box_attributes": ["ProbeRequestTimeout",
1185             "AssocRequestTimeout",
1186             "MaxMissedBeacons",
1187             "CtsTimeout",
1188             "AckTimeout",
1189             "BasicBlockAckTimeout",
1190             "CompressedBlockAckTimeout",
1191             "Sifs",
1192             "EifsNoDifs",
1193             "Slot",
1194             "Pifs",
1195             "MaxPropagationDelay",
1196             "Ssid",
1197             "Standard"],
1198     }),
1199      "ns3::UdpEchoClient": dict({
1200         "category": "Application",
1201         "create_function": create_element,
1202         "configure_function": configure_element,
1203         "help": "",
1204         "connector_types": ["node"],
1205         "stop_function": stop_application,
1206         "start_function": start_application,
1207         "status_function": status_application,
1208         "box_attributes": ["MaxPackets",
1209             "Interval",
1210             "RemoteAddress",
1211             "RemotePort",
1212             "PacketSize",
1213             "StartTime",
1214             "StopTime"],
1215     }),
1216      "ns3::UdpClient": dict({
1217         "category": "Application",
1218         "create_function": create_element,
1219         "configure_function": configure_element,
1220         "help": "",
1221         "connector_types": [],
1222         "stop_function": stop_application,
1223         "start_function": start_application,
1224         "status_function": status_application,
1225         "box_attributes": ["MaxPackets",
1226             "Interval",
1227             "RemoteAddress",
1228             "RemotePort",
1229             "PacketSize",
1230             "StartTime",
1231             "StopTime"],
1232     }),
1233      "ns3::PointToPointChannel": dict({
1234         "category": "Channel",
1235         "create_function": create_element,
1236         "configure_function": configure_element,
1237         "help": "",
1238         "connector_types": ["dev2"],
1239         "box_attributes": ["Delay"],
1240     }),
1241      "ns3::Ipv6StaticRouting": dict({
1242         "category": "",
1243         "create_function": create_element,
1244         "configure_function": configure_element,
1245         "help": "",
1246         "connector_types": [],
1247         "box_attributes": [],
1248     }),
1249      "ns3::DropTailQueue": dict({
1250         "category": "Device",
1251         "create_function": create_element,
1252         "configure_function": configure_element,
1253         "help": "",
1254         "connector_types": ["dev"],
1255         "box_attributes": ["MaxPackets",
1256            "MaxBytes"],
1257     }),
1258      "ns3::ConstantPositionMobilityModel": dict({
1259         "category": "Mobility",
1260         "create_function": create_element,
1261         "configure_function": configure_element,
1262         "help": "",
1263         "connector_types": ["node"],
1264         "box_attributes": ["Position",
1265             "Velocity"],
1266     }),
1267      "ns3::FixedRssLossModel": dict({
1268         "category": "Loss",
1269         "create_function": create_element,
1270         "configure_function": configure_element,
1271         "help": "",
1272         "connector_types": [],
1273         "box_attributes": ["Rss"],
1274     }),
1275      "ns3::EnergySourceContainer": dict({
1276         "category": "",
1277         "create_function": create_element,
1278         "configure_function": configure_element,
1279         "help": "",
1280         "connector_types": [],
1281         "box_attributes": [],
1282     }),
1283      "ns3::RandomWalk2dMobilityModel": dict({
1284         "category": "Mobility",
1285         "create_function": create_element,
1286         "configure_function": configure_element,
1287         "help": "",
1288         "connector_types": ["node"],
1289         "box_attributes": ["Bounds",
1290             "Time",
1291             "Distance",
1292             "Mode",
1293             "Direction",
1294             "Speed",
1295             "Position",
1296             "Velocity"],
1297     }),
1298      "ns3::ListPositionAllocator": dict({
1299         "category": "",
1300         "create_function": create_element,
1301         "configure_function": configure_element,
1302         "help": "",
1303         "connector_types": [],
1304         "box_attributes": [],
1305     }),
1306      "ns3::dot11s::PeerManagementProtocol": dict({
1307         "category": "Protocol",
1308         "create_function": create_element,
1309         "configure_function": configure_element,
1310         "help": "",
1311         "connector_types": [],
1312         "box_attributes": ["MaxNumberOfPeerLinks",
1313             "MaxBeaconShiftValue",
1314             "EnableBeaconCollisionAvoidance"],
1315     }),
1316      "ns3::MeshPointDevice": dict({
1317         "category": "Device",
1318         "create_function": create_element,
1319         "configure_function": configure_element,
1320         "help": "",
1321         "connector_types": [],
1322         "allow_addresses": True,
1323         "box_attributes": ["Mtu"],
1324     }),
1325      "ns3::BasicEnergySource": dict({
1326         "category": "",
1327         "create_function": create_element,
1328         "configure_function": configure_element,
1329         "help": "",
1330         "connector_types": [],
1331         "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1332             "BasicEnergySupplyVoltageV",
1333             "PeriodicEnergyUpdateInterval"],
1334     }),
1335      "ns3::Ipv6OptionPadn": dict({
1336         "category": "",
1337         "create_function": create_element,
1338         "configure_function": configure_element,
1339         "help": "",
1340         "connector_types": [],
1341         "box_attributes": ["OptionNumber"],
1342     }),
1343      "ns3::QapWifiMac": dict({
1344         "category": "Mac",
1345         "create_function": create_wifi_standard_model,
1346         "configure_function": configure_element,
1347         "help": "Access point Wifi MAC Model",
1348         "connector_types": ["dev"],
1349         "box_attributes": ["BeaconInterval",
1350             "BeaconGeneration",
1351             "CtsTimeout",
1352             "AckTimeout",
1353             "BasicBlockAckTimeout",
1354             "CompressedBlockAckTimeout",
1355             "Sifs",
1356             "EifsNoDifs",
1357             "Slot",
1358             "Pifs",
1359             "MaxPropagationDelay",
1360             "Ssid",
1361             "Standard"],
1362     }),
1363      "ns3::YansErrorRateModel": dict({
1364         "category": "Error",
1365         "create_function": create_element,
1366         "configure_function": configure_element,
1367         "help": "",
1368         "connector_types": [],
1369         "box_attributes": [],
1370     }),
1371      "ns3::WifiMacQueue": dict({
1372         "category": "",
1373         "create_function": create_element,
1374         "configure_function": configure_element,
1375         "help": "",
1376         "connector_types": [],
1377         "box_attributes": ["MaxPacketNumber",
1378            "MaxDelay"],
1379     }),
1380      "ns3::NonCommunicatingNetDevice": dict({
1381         "category": "Device",
1382         "create_function": create_element,
1383         "configure_function": configure_element,
1384         "help": "",
1385         "connector_types": [],
1386         "allow_addresses": True,
1387         "box_attributes": [],
1388     }),
1389      "ns3::RateErrorModel": dict({
1390         "category": "Error",
1391         "create_function": create_element,
1392         "configure_function": configure_element,
1393         "help": "",
1394         "connector_types": [],
1395         "box_attributes": ["ErrorUnit",
1396             "ErrorRate",
1397             "RanVar",
1398             "IsEnabled"],
1399     }),
1400      "ns3::MeshWifiInterfaceMac": dict({
1401         "category": "",
1402         "create_function": create_element,
1403         "configure_function": configure_element,
1404         "help": "",
1405         "connector_types": [],
1406         "box_attributes": ["BeaconInterval",
1407             "RandomStart",
1408             "BeaconGeneration",
1409             "CtsTimeout",
1410             "AckTimeout",
1411             "BasicBlockAckTimeout",
1412             "CompressedBlockAckTimeout",
1413             "Sifs",
1414             "EifsNoDifs",
1415             "Slot",
1416             "Pifs",
1417             "MaxPropagationDelay",
1418             "Ssid"],
1419     }),
1420      "ns3::UanPhyCalcSinrDual": dict({
1421         "category": "",
1422         "create_function": create_element,
1423         "configure_function": configure_element,
1424         "help": "",
1425         "connector_types": [],
1426         "box_attributes": [],
1427     }),
1428      "ns3::Ipv6ExtensionAH": dict({
1429         "category": "",
1430         "create_function": create_element,
1431         "configure_function": configure_element,
1432         "help": "",
1433         "connector_types": [],
1434         "box_attributes": ["ExtensionNumber"],
1435     }),
1436      "ns3::SingleModelSpectrumChannel": dict({
1437         "category": "Channel",
1438         "create_function": create_element,
1439         "configure_function": configure_element,
1440         "help": "",
1441         "connector_types": [],
1442         "box_attributes": [],
1443     }),
1444      "ns3::YansWifiPhy": dict({
1445         "category": "Phy",
1446         "create_function": create_wifi_standard_model,
1447         "configure_function": configure_element,
1448         "help": "",
1449         "connector_types": ["dev", "err", "chan"],
1450         "box_attributes": ["EnergyDetectionThreshold",
1451             "CcaMode1Threshold",
1452             "TxGain",
1453             "RxGain",
1454             "TxPowerLevels",
1455             "TxPowerEnd",
1456             "TxPowerStart",
1457             "RxNoiseFigure",
1458             "ChannelSwitchDelay",
1459             "ChannelNumber",
1460             "Standard"],
1461         "traces": ["yanswifipcap"]
1462     }),
1463      "ns3::WifiRadioEnergyModel": dict({
1464         "category": "",
1465         "create_function": create_element,
1466         "configure_function": configure_element,
1467         "help": "",
1468         "connector_types": [],
1469         "box_attributes": ["TxCurrentA",
1470             "RxCurrentA",
1471             "IdleCurrentA",
1472             "SleepCurrentA"],
1473     }),
1474      "ns3::EdcaTxopN": dict({
1475         "category": "",
1476         "create_function": create_element,
1477         "configure_function": configure_element,
1478         "help": "",
1479         "connector_types": [],
1480         "box_attributes": ["BlockAckThreshold",
1481             "MinCw",
1482             "MaxCw",
1483             "Aifsn"],
1484     }),
1485      "ns3::UanPhyPerGenDefault": dict({
1486         "category": "",
1487         "create_function": create_element,
1488         "configure_function": configure_element,
1489         "help": "",
1490         "connector_types": [],
1491         "box_attributes": ["Threshold"],
1492     }),
1493      "ns3::IdealWifiManager": dict({
1494         "category": "Manager",
1495         "create_function": create_element,
1496         "configure_function": configure_element,
1497         "help": "",
1498         "connector_types": [],
1499         "box_attributes": ["BerThreshold",
1500             "IsLowLatency",
1501             "MaxSsrc",
1502             "MaxSlrc",
1503             "RtsCtsThreshold",
1504             "FragmentationThreshold",
1505             "NonUnicastMode"],
1506     }),
1507      "ns3::MultiModelSpectrumChannel": dict({
1508         "category": "Channel",
1509         "create_function": create_element,
1510         "configure_function": configure_element,
1511         "help": "",
1512         "connector_types": [],
1513         "box_attributes": [],
1514     }),
1515      "ns3::HalfDuplexIdealPhy": dict({
1516         "category": "Phy",
1517         "create_function": create_element,
1518         "configure_function": configure_element,
1519         "help": "",
1520         "connector_types": [],
1521         "box_attributes": ["Rate"],
1522     }),
1523      "ns3::UanPhyCalcSinrDefault": dict({
1524         "category": "Phy",
1525         "create_function": create_element,
1526         "configure_function": configure_element,
1527         "help": "",
1528         "connector_types": [],
1529         "box_attributes": [],
1530     }),
1531      "ns3::ReceiveListErrorModel": dict({
1532         "category": "Error",
1533         "create_function": create_element,
1534         "configure_function": configure_element,
1535         "help": "",
1536         "connector_types": [],
1537         "box_attributes": ["IsEnabled"],
1538     }),
1539      "ns3::SpectrumAnalyzer": dict({
1540         "category": "",
1541         "create_function": create_element,
1542         "configure_function": configure_element,
1543         "help": "",
1544         "connector_types": [],
1545         "box_attributes": ["Resolution",
1546         "NoisePowerSpectralDensity"],
1547     }),
1548      "ns3::ConstantRateWifiManager": dict({
1549         "category": "Manager",
1550         "create_function": create_element,
1551         "configure_function": configure_element,
1552         "help": "",
1553         "connector_types": ["dev"],
1554         "box_attributes": ["DataMode",
1555             "ControlMode",
1556             "IsLowLatency",
1557             "MaxSsrc",
1558             "MaxSlrc",
1559             "RtsCtsThreshold",
1560             "FragmentationThreshold",
1561             "NonUnicastMode"],
1562     }),
1563      "ns3::Ipv6OptionPad1": dict({
1564         "category": "",
1565         "create_function": create_element,
1566         "configure_function": configure_element,
1567         "help": "",
1568         "connector_types": [],
1569         "box_attributes": ["OptionNumber"],
1570     }),
1571      "ns3::UdpTraceClient": dict({
1572         "category": "",
1573         "create_function": create_element,
1574         "configure_function": configure_element,
1575         "help": "",
1576         "connector_types": [],
1577         "box_attributes": ["RemoteAddress",
1578             "RemotePort",
1579             "MaxPacketSize",
1580             "StartTime",
1581             "StopTime"],
1582     }),
1583      "ns3::RraaWifiManager": dict({
1584         "category": "Manager",
1585         "create_function": create_element,
1586         "configure_function": configure_element,
1587         "help": "",
1588         "connector_types": [],
1589         "box_attributes": ["Basic",
1590             "Timeout",
1591             "ewndFor54mbps",
1592             "ewndFor48mbps",
1593             "ewndFor36mbps",
1594             "ewndFor24mbps",
1595             "ewndFor18mbps",
1596             "ewndFor12mbps",
1597             "ewndFor9mbps",
1598             "ewndFor6mbps",
1599             "poriFor48mbps",
1600             "poriFor36mbps",
1601             "poriFor24mbps",
1602             "poriFor18mbps",
1603             "poriFor12mbps",
1604             "poriFor9mbps",
1605             "poriFor6mbps",
1606             "pmtlFor54mbps",
1607             "pmtlFor48mbps",
1608             "pmtlFor36mbps",
1609             "pmtlFor24mbps",
1610             "pmtlFor18mbps",
1611             "pmtlFor12mbps",
1612             "pmtlFor9mbps",
1613             "IsLowLatency",
1614             "MaxSsrc",
1615             "MaxSlrc",
1616             "RtsCtsThreshold",
1617             "FragmentationThreshold",
1618             "NonUnicastMode"],
1619     }),
1620      "ns3::RandomPropagationLossModel": dict({
1621         "category": "Loss",
1622         "create_function": create_element,
1623         "configure_function": configure_element,
1624         "help": "",
1625         "connector_types": [],
1626         "box_attributes": ["Variable"],
1627     }),
1628      "ns3::UanChannel": dict({
1629         "category": "Channel",
1630         "create_function": create_element,
1631         "configure_function": configure_element,
1632         "help": "",
1633         "connector_types": [],
1634         "box_attributes": [],
1635     }),
1636      "ns3::MinstrelWifiManager": dict({
1637         "category": "Manager",
1638         "create_function": create_element,
1639         "configure_function": configure_element,
1640         "help": "",
1641         "connector_types": [],
1642         "box_attributes": ["UpdateStatistics",
1643             "LookAroundRate",
1644             "EWMA",
1645             "SegmentSize",
1646             "SampleColumn",
1647             "PacketLength",
1648             "IsLowLatency",
1649             "MaxSsrc",
1650             "MaxSlrc",
1651             "RtsCtsThreshold",
1652             "FragmentationThreshold",
1653             "NonUnicastMode"],
1654     }),
1655      "ns3::UanPhyDual": dict({
1656         "category": "Phy",
1657         "create_function": create_element,
1658         "configure_function": configure_element,
1659         "help": "",
1660         "connector_types": [],
1661         "box_attributes": ["CcaThresholdPhy1",
1662             "CcaThresholdPhy2",
1663             "TxPowerPhy1",
1664             "TxPowerPhy2",
1665             "RxGainPhy1",
1666             "RxGainPhy2",
1667             "SupportedModesPhy1",
1668             "SupportedModesPhy2"],
1669     }),
1670      "ns3::ListErrorModel": dict({
1671         "category": "Error",
1672         "create_function": create_element,
1673         "configure_function": configure_element,
1674         "help": "",
1675         "connector_types": ["dev"],
1676         "box_attributes": ["IsEnabled"],
1677     }),
1678      "ns3::VirtualNetDevice": dict({
1679         "category": "Device",
1680         "create_function": create_element,
1681         "configure_function": configure_element,
1682         "help": "",
1683         "connector_types": [],
1684         "allow_addresses": True,
1685         "box_attributes": ["Mtu"],
1686     }),
1687      "ns3::UanPhyGen": dict({
1688         "category": "Phy",
1689         "create_function": create_element,
1690         "configure_function": configure_element,
1691         "help": "",
1692         "connector_types": [],
1693         "box_attributes": ["CcaThreshold",
1694             "RxThreshold",
1695             "TxPower",
1696             "RxGain",
1697             "SupportedModes"],
1698     }),
1699      "ns3::Ipv6L3Protocol": dict({
1700         "category": "Protocol",
1701         "create_function": create_element,
1702         "configure_function": configure_element,
1703         "help": "",
1704         "connector_types": [],
1705         "box_attributes": ["DefaultTtl",
1706             "IpForward"],
1707     }),
1708      "ns3::PointToPointRemoteChannel": dict({
1709         "category": "Channel",
1710         "create_function": create_element,
1711         "configure_function": configure_element,
1712         "help": "",
1713         "connector_types": [],
1714         "box_attributes": ["Delay"],
1715     }),
1716      "ns3::UanPhyPerUmodem": dict({
1717         "category": "Phy",
1718         "create_function": create_element,
1719         "configure_function": configure_element,
1720         "help": "",
1721         "connector_types": [],
1722         "box_attributes": [],
1723     }),
1724      "ns3::OnoeWifiManager": dict({
1725         "category": "Manager",
1726         "create_function": create_element,
1727         "configure_function": configure_element,
1728         "help": "",
1729         "connector_types": [],
1730         "box_attributes": ["UpdatePeriod",
1731             "RaiseThreshold",
1732             "AddCreditThreshold",
1733             "IsLowLatency",
1734             "MaxSsrc",
1735             "MaxSlrc",
1736             "RtsCtsThreshold",
1737             "FragmentationThreshold",
1738             "NonUnicastMode"],
1739     }),
1740      "ns3::QadhocWifiMac": dict({
1741         "category": "Mac",
1742         "create_function": create_element,
1743         "configure_function": configure_element,
1744         "help": "",
1745         "connector_types": [],
1746         "box_attributes": ["CtsTimeout",
1747             "AckTimeout",
1748             "BasicBlockAckTimeout",
1749             "CompressedBlockAckTimeout",
1750             "Sifs",
1751             "EifsNoDifs",
1752             "Slot",
1753             "Pifs",
1754             "MaxPropagationDelay",
1755             "Ssid"],
1756     }),
1757      "ns3::JakesPropagationLossModel": dict({
1758         "category": "Loss",
1759         "create_function": create_element,
1760         "configure_function": configure_element,
1761         "help": "",
1762         "connector_types": [],
1763         "box_attributes": ["NumberOfRaysPerPath",
1764             "NumberOfOscillatorsPerRay",
1765             "DopplerFreq",
1766             "Distribution"],
1767     }),
1768      "ns3::PacketSink": dict({
1769         "category": "Application",
1770         "create_function": create_element,
1771         "configure_function": configure_element,
1772         "help": "",
1773         "connector_types": ["node"],
1774         "stop_function": stop_application,
1775         "start_function": start_application,
1776         "status_function": status_application,
1777         "box_attributes": ["Local",
1778             "Protocol",
1779             "StartTime",
1780             "StopTime"],
1781     }),
1782      "ns3::RandomDirection2dMobilityModel": dict({
1783         "category": "Mobility",
1784         "create_function": create_element,
1785         "configure_function": configure_element,
1786         "help": "",
1787         "connector_types": ["node"],
1788         "box_attributes": ["Bounds",
1789             "RndSpeed",
1790             "Pause",
1791             "Position",
1792             "Velocity"],
1793     }),
1794      "ns3::UanMacAloha": dict({
1795         "category": "",
1796         "create_function": create_element,
1797         "configure_function": configure_element,
1798         "help": "",
1799         "connector_types": [],
1800         "box_attributes": [],
1801     }),
1802      "ns3::MsduStandardAggregator": dict({
1803         "category": "",
1804         "create_function": create_element,
1805         "configure_function": configure_element,
1806         "help": "",
1807         "connector_types": [],
1808         "box_attributes": ["MaxAmsduSize"],
1809     }),
1810      "ns3::DcaTxop": dict({
1811         "category": "",
1812         "create_function": create_element,
1813         "configure_function": configure_element,
1814         "help": "",
1815         "connector_types": [],
1816         "box_attributes": ["MinCw",
1817             "MaxCw",
1818             "Aifsn"],
1819     }),
1820      "ns3::UanPhyCalcSinrFhFsk": dict({
1821         "category": "Phy",
1822         "create_function": create_element,
1823         "configure_function": configure_element,
1824         "help": "",
1825         "connector_types": [],
1826         "box_attributes": ["NumberOfHops"],
1827     }),
1828      "ns3::UanPropModelIdeal": dict({
1829         "category": "",
1830         "create_function": create_element,
1831         "configure_function": configure_element,
1832         "help": "",
1833         "connector_types": [],
1834         "box_attributes": [],
1835     }),
1836      "ns3::UanMacRcGw": dict({
1837         "category": "",
1838         "create_function": create_element,
1839         "configure_function": configure_element,
1840         "help": "",
1841         "connector_types": [],
1842         "box_attributes": ["MaxReservations",
1843             "NumberOfRates",
1844             "RetryRate",
1845             "MaxPropDelay",
1846             "SIFS",
1847             "NumberOfNodes",
1848             "MinRetryRate",
1849             "RetryStep",
1850             "NumberOfRetryRates",
1851             "TotalRate",
1852             "RateStep",
1853             "FrameSize"],
1854     }),
1855      "ns3::NistErrorRateModel": dict({
1856         "category": "Error",
1857         "create_function": create_element,
1858         "configure_function": configure_element,
1859         "help": "",
1860         "connector_types": ["phy"],
1861         "box_attributes": [],
1862     }),
1863      "ns3::Ipv4L3Protocol": dict({
1864         "category": "Protocol",
1865         "create_function": create_ipv4protocol,
1866         "configure_function": configure_element,
1867         "help": "",
1868         "connector_types": ["node"],
1869         "box_attributes": ["DefaultTtl",
1870             "IpForward",
1871             "WeakEsModel"],
1872     }),
1873      "ns3::aodv::RoutingProtocol": dict({
1874         "category": "Protocol",
1875         "create_function": create_element,
1876         "configure_function": configure_element,
1877         "help": "",
1878         "connector_types": [],
1879         "box_attributes": ["HelloInterval",
1880             "RreqRetries",
1881             "RreqRateLimit",
1882             "NodeTraversalTime",
1883             "NextHopWait",
1884             "ActiveRouteTimeout",
1885             "MyRouteTimeout",
1886             "BlackListTimeout",
1887             "DeletePeriod",
1888             "TimeoutBuffer",
1889             "NetDiameter",
1890             "NetTraversalTime",
1891             "PathDiscoveryTime",
1892             "MaxQueueLen",
1893             "MaxQueueTime",
1894             "AllowedHelloLoss",
1895             "GratuitousReply",
1896             "DestinationOnly",
1897             "EnableHello",
1898             "EnableBroadcast"],
1899     }),
1900      "ns3::TcpL4Protocol": dict({
1901         "category": "Protocol",
1902         "create_function": create_element,
1903         "configure_function": configure_element,
1904         "help": "",
1905         "connector_types": ["node"],
1906         "box_attributes": ["RttEstimatorFactory",
1907             "ProtocolNumber"],
1908     }),
1909      "ns3::olsr::RoutingProtocol": dict({
1910         "category": "Protocol",
1911         "create_function": create_element,
1912         "configure_function": configure_element,
1913         "help": "",
1914         "connector_types": [],
1915         "box_attributes": ["HelloInterval",
1916             "TcInterval",
1917             "MidInterval",
1918             "HnaInterval",
1919             "Willingness"],
1920     }),
1921      "ns3::UdpEchoServer": dict({
1922         "category": "Application",
1923         "create_function": create_element,
1924         "configure_function": configure_element,
1925         "help": "",
1926         "connector_types": ["node"],
1927         "stop_function": stop_application,
1928         "start_function": start_application,
1929         "status_function": status_application,
1930         "box_attributes": ["Port",
1931            "StartTime",
1932            "StopTime"],
1933     }),
1934      "ns3::AmrrWifiManager": dict({
1935         "category": "Manager",
1936         "create_function": create_element,
1937         "configure_function": configure_element,
1938         "help": "",
1939         "connector_types": [],
1940         "box_attributes": ["UpdatePeriod",
1941             "FailureRatio",
1942             "SuccessRatio",
1943             "MaxSuccessThreshold",
1944             "MinSuccessThreshold",
1945             "IsLowLatency",
1946             "MaxSsrc",
1947             "MaxSlrc",
1948             "RtsCtsThreshold",
1949             "FragmentationThreshold",
1950             "NonUnicastMode"],
1951     }),
1952      "ns3::ArfWifiManager": dict({
1953         "category": "Manager",
1954         "create_function": create_element,
1955         "configure_function": configure_element,
1956         "help": "",
1957         "connector_types": ["dev"],
1958         "box_attributes": ["TimerThreshold",
1959             "SuccessThreshold",
1960             "IsLowLatency",
1961             "MaxSsrc",
1962             "MaxSlrc",
1963             "RtsCtsThreshold",
1964             "FragmentationThreshold",
1965             "NonUnicastMode"],
1966     }),
1967      "ns3::SubscriberStationNetDevice": dict({
1968         "category": "Device",
1969         "create_function": create_element,
1970         "configure_function": configure_element,
1971         "help": "",
1972         "connector_types": [],
1973         "allow_addresses": True,
1974         "box_attributes": ["LostDlMapInterval",
1975             "LostUlMapInterval",
1976             "MaxDcdInterval",
1977             "MaxUcdInterval",
1978             "IntervalT1",
1979             "IntervalT2",
1980             "IntervalT3",
1981             "IntervalT7",
1982             "IntervalT12",
1983             "IntervalT20",
1984             "IntervalT21",
1985             "MaxContentionRangingRetries",
1986             "Mtu",
1987             "RTG",
1988             "TTG"],
1989     }),
1990      "ns3::flame::FlameRtable": dict({
1991         "category": "",
1992         "create_function": create_element,
1993         "configure_function": configure_element,
1994         "help": "",
1995         "connector_types": [],
1996         "box_attributes": ["Lifetime"],
1997     }),
1998 })