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