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